DevTools: added injectedScript.evaluateWithDetails, that return exception details if it occured

Source/core/inspector/InjectedScriptSource.js

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 333 matching lines @@
         }
         return objectId;
     },
 
     /**
      * @param {string} objectId
      * @return {!Object}
      */
     _parseObjectId: function(objectId)
     {
-        return nullifyObjectProto(InjectedScriptHost.evaluate("(" + objectId + ")"));
+        return nullifyObjectProto(this._injectedScriptHostEvaluateThrowable("(" + objectId + ")"));
     },
 
     /**
      * @param {string} objectGroupName
      */
     releaseObjectGroup: function(objectGroupName)
     {
         var group = this._objectGroups[objectGroupName];
         if (!group)
             return;
         for (var i = 0; i < group.length; i++)
             this._releaseObject(group[i]);
         delete this._objectGroups[objectGroupName];
     },
 
     /**
      * @param {string} methodName
      * @param {string} args
      * @return {*}
      */
     dispatch: function(methodName, args)
     {
-        var argsArray = InjectedScriptHost.evaluate("(" + args + ")");
+        var argsArray = this._injectedScriptHostEvaluateThrowable("(" + args + ")");
         var result = this[methodName].apply(this, argsArray);
         if (typeof result === "undefined") {
             inspectedWindow.console.error("Web Inspector error: InjectedScript.%s returns undefined", methodName);
             result = null;
         }
         return result;
     },
 
     /**
      * @param {string} objectId
@@ skipping 183 matching lines @@
     /**
      * @param {string} expression
      * @param {string} objectGroup
      * @param {boolean} injectCommandLineAPI
      * @param {boolean} returnByValue
      * @param {boolean} generatePreview
      * @return {*}
      */
     evaluate: function(expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
     {
-        return this._evaluateAndWrap(InjectedScriptHost.evaluate, InjectedScriptHost, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview);
+        return this._evaluateAndWrapWithDetails(InjectedScriptHost.evaluate, InjectedScriptHost, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview);
     },
 
     /**
      * @param {string} objectId
      * @param {string} expression
      * @param {string} args
      * @param {boolean} returnByValue
      * @return {!Object|string}
      */
     callFunctionOn: function(objectId, expression, args, returnByValue)
     {
         var parsedObjectId = this._parseObjectId(objectId);
         var object = this._objectForId(parsedObjectId);
         if (!this._isDefined(object))
             return "Could not find object with given id";
 
         if (args) {
             var resolvedArgs = [];
-            args = InjectedScriptHost.evaluate(args);
+            args = this._injectedScriptHostEvaluateThrowable(args);
             for (var i = 0; i < args.length; ++i) {
                 try {
                     resolvedArgs[i] = this._resolveCallArgument(args[i]);
                 } catch (e) {
                     return toString(e);
                 }
             }
         }
 
         try {
             var objectGroup = this._idToObjectGroupName[parsedObjectId.id];
             var func = InjectedScriptHost.evaluate("(" + expression + ")");
+            if (func.exceptionDetails)

[vsevik, 2014/07/04 06:54:58]

Everything except func.apply could me moved out of the try/catch block now.

+                return this._createThrownValue(func.result, objectGroup, func.exceptionDetails);
+            func = func.result;
             if (typeof func !== "function")
                 return "Given expression does not evaluate to a function";
 
             return { wasThrown: false,
                      result: this._wrapObject(func.apply(object, resolvedArgs), objectGroup, returnByValue),
                      __proto__: null };
         } catch (e) {
             return this._createThrownValue(e, objectGroup);
         }
     },
@@ skipping 32 matching lines @@
      * @param {!Object} object
      * @param {string} expression
      * @param {string} objectGroup
      * @param {boolean} isEvalOnCallFrame
      * @param {boolean} injectCommandLineAPI
      * @param {boolean} returnByValue
      * @param {boolean} generatePreview
      * @param {!Array.<!Object>=} scopeChain
      * @return {!Object}
      */
     _evaluateAndWrap: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue, generatePreview, scopeChain)

[vsevik, 2014/07/04 06:54:58]

Now that this one is only called for evaluation on callframe it makes sense to
name it evaluateOnCallFrameAndWrap and make callframe its first argument.

     {
         try {
             return { wasThrown: false,
                      result: this._wrapObject(this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain), objectGroup, returnByValue, generatePreview),
                      __proto__: null };
         } catch (e) {
             return this._createThrownValue(e, objectGroup);
         }
     },
 
     /**
+     * @param {!Function} evalFunction
+     * @param {!Object} object
+     * @param {string} expression
+     * @param {string} objectGroup
+     * @param {boolean} isEvalOnCallFrame
+     * @param {boolean} injectCommandLineAPI
+     * @param {boolean} returnByValue
+     * @param {boolean} generatePreview
+     * @param {!Array.<!Object>=} scopeChain
+     * @return {!Object}
+     */
+    _evaluateAndWrapWithDetails: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue, generatePreview, scopeChain)

[vsevik, 2014/07/04 06:54:58]

This one could be changed accordingly, making it _evaluateAndWrap that doesn't
accept evalFunction, but takes it directly from InjectedScriptHost instead.

+    {
+        var result = this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain), objectGroup, returnByValue, generatePreview;
+        if (!result.exceptionDetails)
+            return { wasThrown: false,
+                     result: this._wrapObject(result.result),
+                     __proto__: null };
+        else
+            return this._createThrownValue(result.result, objectGroup, result.exceptionDetails);
+    },
+
+    /**
      * @param {*} value
      * @param {string} objectGroup
+     * @param {!Object=} exceptionDetails
      * @return {!Object}
      */
-    _createThrownValue: function(value, objectGroup)
+    _createThrownValue: function(value, objectGroup, exceptionDetails)
     {
         var remoteObject = this._wrapObject(value, objectGroup);
         try {
             remoteObject.description = toStringDescription(value);
         } catch (e) {}
-        return { wasThrown: true, result: remoteObject, __proto__: null };
+        return { wasThrown: true, result: remoteObject, __proto__: null, exceptionDetails: exceptionDetails, objectGroup };
     },
 
     /**
      * @param {!Function} evalFunction
      * @param {!Object} object
      * @param {string} objectGroup
      * @param {string} expression
      * @param {boolean} isEvalOnCallFrame
      * @param {boolean} injectCommandLineAPI
      * @param {!Array.<!Object>=} scopeChain
@@ skipping 67 matching lines @@
      * @param {string} callFrameId
      * @param {string} expression
      * @param {string} objectGroup
      * @param {boolean} injectCommandLineAPI
      * @param {boolean} returnByValue
      * @param {boolean} generatePreview
      * @return {*}
      */
     evaluateOnCallFrame: function(topCallFrame, asyncCallStacks, callFrameId, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
     {
-        var parsedCallFrameId = nullifyObjectProto(InjectedScriptHost.evaluate("(" + callFrameId + ")"));
+        var parsedCallFrameId = nullifyObjectProto(this._injectedScriptHostEvaluateThrowable("(" + callFrameId + ")"));
         var callFrame = this._callFrameForParsedId(topCallFrame, parsedCallFrameId, asyncCallStacks);
         if (!callFrame)
             return "Could not find call frame with given id";
         if (parsedCallFrameId["asyncOrdinal"])
-            return this._evaluateAndWrap(InjectedScriptHost.evaluate, InjectedScriptHost, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview, callFrame.scopeChain);
+            return this._evaluateAndWrapWithDetails(InjectedScriptHost.evaluate, InjectedScriptHost, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview, callFrame.scopeChain);
         return this._evaluateAndWrap(callFrame.evaluate, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, generatePreview);

[vsevik, 2014/07/04 06:54:58]

So we are still missing exceptionDetails in case of evaluation on call frame.
This is something worth investigation, but might probably require complicated v8
changes. We could do this separately though.

     },
 
     /**
      * @param {!Object} topCallFrame
      * @param {string} callFrameId
      * @return {*}
      */
     restartFrame: function(topCallFrame, callFrameId)
     {
         var callFrame = this._callFrameForId(topCallFrame, callFrameId);
@@ skipping 15 matching lines @@
         var callFrame = this._callFrameForId(topCallFrame, callFrameId);
         if (!callFrame)
             return "Could not find call frame with given id";
         var stepInPositionsUnpacked = JSON.parse(callFrame.stepInPositions);
         if (typeof stepInPositionsUnpacked !== "object")
             return "Step in positions not available";
         return stepInPositionsUnpacked;
     },
 
     /**
+     * @param {string} expression
+     * @return {*} expression result value
+     */
+    _injectedScriptHostEvaluateThrowable: function(expression) {

[vsevik, 2014/07/04 06:54:59]

We could probably name this one _evaluateOrThrow

+        var wrappedResult = InjectedScriptHost.evaluate(expression);
+        return wrappedResult.result;

[vsevik, 2014/07/04 06:54:58]

Return early? :)

+        if (wrappedResult.exceptionDetails)
+            throw wrappedResult.result;
+        return wrappedResult.result;
+    },
+
+    /**
      * Either callFrameId or functionObjectId must be specified.
      * @param {!Object} topCallFrame
      * @param {string|boolean} callFrameId or false
      * @param {string|boolean} functionObjectId or false
      * @param {number} scopeNumber
      * @param {string} variableName
      * @param {string} newValueJsonString RuntimeAgent.CallArgument structure serialized as string
      * @return {string|undefined} undefined if success or an error message
      */
     setVariableValue: function(topCallFrame, callFrameId, functionObjectId, scopeNumber, variableName, newValueJsonString)
     {
         var setter;
         if (typeof callFrameId === "string") {
             var callFrame = this._callFrameForId(topCallFrame, callFrameId);
             if (!callFrame)
                 return "Could not find call frame with given id";
             setter = bind(callFrame.setVariableValue, callFrame);
         } else {
             var parsedFunctionId = this._parseObjectId(/** @type {string} */ (functionObjectId));
             var func = this._objectForId(parsedFunctionId);
             if (typeof func !== "function")
                 return "Cannot resolve function by id.";
             setter = bind(InjectedScriptHost.setFunctionVariableValue, InjectedScriptHost, func);
         }
         var newValueJson;
         try {
-            newValueJson = InjectedScriptHost.evaluate("(" + newValueJsonString + ")");
+            newValueJson = this._injectedScriptHostEvaluateThrowable("(" + newValueJsonString + ")");
         } catch (e) {
             return "Failed to parse new value JSON " + newValueJsonString + " : " + e;
         }
         var resolvedValue;
         try {
             resolvedValue = this._resolveCallArgument(newValueJson);
         } catch (e) {
             return toString(e);
         }
         try {
             setter(scopeNumber, variableName, resolvedValue);
         } catch (e) {
             return "Failed to change variable value: " + e;
         }
         return undefined;
     },
 
     /**
      * @param {!Object} topCallFrame
      * @param {string} callFrameId
      * @return {?Object}
      */
     _callFrameForId: function(topCallFrame, callFrameId)
     {
-        var parsedCallFrameId = nullifyObjectProto(InjectedScriptHost.evaluate("(" + callFrameId + ")"));
+        var parsedCallFrameId = nullifyObjectProto(this._injectedScriptHostEvaluateThrowable("(" + callFrameId + ")"));
         return this._callFrameForParsedId(topCallFrame, parsedCallFrameId, []);
     },
 
     /**
      * @param {!Object} topCallFrame
      * @param {!Object} parsedCallFrameId
      * @param {!Array.<!Object>} asyncCallStacks
      * @return {?Object}
      */
     _callFrameForParsedId: function(topCallFrame, parsedCallFrameId, asyncCallStacks)
@@ skipping 49 matching lines @@
     },
 
     /**
      * @param {string} name
      * @param {string} source
      * @return {?Object}
      */
     injectModule: function(name, source)
     {
         delete this._modules[name];
-        var moduleFunction = InjectedScriptHost.evaluate("(" + source + ")");
+        var moduleFunction = this._injectedScriptHostEvaluateThrowable("(" + source + ")");
         if (typeof moduleFunction !== "function") {
             inspectedWindow.console.error("Web Inspector error: A function was expected for module %s evaluation", name);
             return null;
         }
         var module = moduleFunction.call(inspectedWindow, InjectedScriptHost, inspectedWindow, injectedScriptId, this);
         this._modules[name] = module;
         return module;
     },
 
     /**
@@ skipping 750 matching lines @@
      */
     _logEvent: function(event)
     {
         inspectedWindow.console.log(event.type, event);
     }
 }
 
 injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
 return injectedScript;
 })