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._evaluateOrThrow("(" + 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._evaluateOrThrow("(" + 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 202 matching lines @@
      */
     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._evaluateOrThrow(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 + ")");
+            var func = this._evaluateOrThrow("(" + expression + ")");
             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 34 matching lines @@
      * @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)
     {
-        try {
+        var wrappedResult = this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain);
+        if (wrappedResult != undefined || !wrappedResult.exceptionDetails) {

[aandrey, 2014/07/05 11:15:12]

in fact, seems like I was wrong that wrappedResult can be undefined here, sorry
for that! I thought we catch and ignore exceptions in _evaluateOn and return
undefined, but we don't...

[kozyatinskiy1, 2014/07/05 11:24:32]

Now, there are no way, when wrappedResult is undefined, maybe in future when we
add new evaluateOn_ calls with different parameters, method can return
undefined. But I suppose this patch isn't correct place to process this case.
Removed undefined wrappedResult processing.

             return { wasThrown: false,
-                     result: this._wrapObject(this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain), objectGroup, returnByValue, generatePreview),
+                     result: this._wrapObject(wrappedResult.result, objectGroup, returnByValue, generatePreview),
                      __proto__: null };
-        } catch (e) {
-            return this._createThrownValue(e, objectGroup);
         }
+        var result = (wrappedResult != undefined) ? wrappedResult.result : wrappedResult;
+        return this._createThrownValue(result, objectGroup, wrappedResult.exceptionDetails);
+    },
+
+    /**
+     * @param {string} expression
+     * @return {?}
+     */
+    _evaluateOrThrow: function(expression)
+    {
+        var wrappedResult = InjectedScriptHost.evaluate(expression);
+        if (wrappedResult.exceptionDetails)
+            throw wrappedResult.result;
+        return wrappedResult.result;
     },
 
     /**
      * @param {*} value
      * @param {string} objectGroup
+     * @param {!DebuggerAgent.ExceptionDetails=} 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, exceptionDetails: exceptionDetails, __proto__: null };
     },
 
     /**
      * @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._evaluateOrThrow("(" + 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._evaluateAndWrap(callFrame.evaluate, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, generatePreview);
     },
 
     /**
      * @param {!Object} topCallFrame
@@ skipping 47 matching lines @@
             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._evaluateOrThrow("(" + 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._evaluateOrThrow("(" + 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._evaluateOrThrow("(" + 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;
 })