DevTools: Implement evaluation on async call frames.

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 60 matching lines @@
 {
     if (typeof obj === "number" && obj === 0 && 1 / obj < 0)
         return "-0"; // Negative zero.
     return "" + obj;
 }
 
 /**
  * Please use this bind, not the one from Function.prototype
  * @param {function(...)} func
  * @param {Object} thisObject
- * @param {...number} var_args
+ * @param {...} var_args
  */
 function bind(func, thisObject, var_args)
 {
     var args = slice(arguments, 2);
 
     /**
-     * @param {...number} var_args
+     * @param {...} var_args
      */
     function bound(var_args)
     {
         return func.apply(thisObject, args.concat(slice(arguments)));
     }
-    bound.toString = function() {
+    bound.toString = function()
+    {
         return "bound: " + func;
     };
     return bound;
 }
 
 /**
  * @constructor
  */
 var InjectedScript = function()
 {
@@ skipping 426 matching lines @@
             return this._createThrownValue(e, objectGroup);
         }
     },
 
     /**
      * Resolves a value from CallArgument description.
      * @param {RuntimeAgent.CallArgument} callArgumentJson
      * @return {*} resolved value
      * @throws {string} error message
      */
-    _resolveCallArgument: function(callArgumentJson) {
+    _resolveCallArgument: function(callArgumentJson)
+    {
         var objectId = callArgumentJson.objectId;
         if (objectId) {
             var parsedArgId = this._parseObjectId(objectId);
             if (!parsedArgId || parsedArgId["injectedScriptId"] !== injectedScriptId)
                 throw "Arguments should belong to the same JavaScript world as the target object.";
 
             var resolvedArg = this._objectForId(parsedArgId);
             if (!this._isDefined(resolvedArg))
                 throw "Could not find object with given id";
 
             return resolvedArg;
         } else if ("value" in callArgumentJson) {
             return callArgumentJson.value;
         }
         return undefined;
     },
 
     /**
      * @param {Function} evalFunction
      * @param {Object} object
      * @param {string} objectGroup
      * @param {boolean} isEvalOnCallFrame
      * @param {boolean} injectCommandLineAPI
      * @param {boolean} returnByValue
      * @param {boolean} generatePreview
+     * @param {!Object=} contextExtension
      * @return {*}
      */
-    _evaluateAndWrap: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue, generatePreview)
+    _evaluateAndWrap: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue, generatePreview, contextExtension)
     {
         try {
             return { wasThrown: false,
-                     result: this._wrapObject(this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI), objectGroup, returnByValue, generatePreview) };
+                     result: this._wrapObject(this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, contextExtension), objectGroup, returnByValue, generatePreview) };
         } catch (e) {
             return this._createThrownValue(e, objectGroup);
         }
     },
 
     /**
      * @param {*} value
      * @param {string} objectGroup
      * @return {Object}
      */
     _createThrownValue: function(value, objectGroup)
     {
         var remoteObject = this._wrapObject(value, objectGroup);
         try {
             remoteObject.description = toStringDescription(value);
         } catch (e) {}
         return { wasThrown: true, result: remoteObject };
     },
 
     /**
      * @param {Function} evalFunction
      * @param {Object} object
      * @param {string} objectGroup
      * @param {string} expression
      * @param {boolean} isEvalOnCallFrame
      * @param {boolean} injectCommandLineAPI
+     * @param {!Object=} contextExtension
      * @return {*}
      */
-    _evaluateOn: function(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI)
+    _evaluateOn: function(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, contextExtension)
     {
         // Only install command line api object for the time of evaluation.
         // Surround the expression in with statements to inject our command line API so that
         // the window object properties still take more precedent than our API functions.
 
         try {
             if (injectCommandLineAPI && inspectedWindow.console) {
                 inspectedWindow.console._commandLineAPI = new CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null);
                 expression = "with ((console && console._commandLineAPI) || { __proto__: null }) {\n" + expression + "\n}";
             }
-            var result = evalFunction.call(object, expression);
+            var result = evalFunction.call(object, expression, contextExtension);
             if (objectGroup === "console")
                 this._lastResult = result;
             return result;
         } finally {
             if (injectCommandLineAPI && inspectedWindow.console)
                 delete inspectedWindow.console._commandLineAPI;
         }
     },
 
     /**
-     * @param {Object} callFrame
-     * @return {!Array.<InjectedScript.CallFrameProxy>|boolean}
+     * @param {?Object} callFrame
+     * @param {number} asyncOrdinal
+     * @return {!Array.<!InjectedScript.CallFrameProxy>|boolean}
      */
-    wrapCallFrames: function(callFrame)
+    wrapCallFrames: function(callFrame, asyncOrdinal)
     {
         if (!callFrame)
             return false;
 
         var result = [];
         var depth = 0;
         do {
-            result.push(new InjectedScript.CallFrameProxy(depth++, callFrame));
+            result.push(new InjectedScript.CallFrameProxy(depth++, callFrame, asyncOrdinal));
             callFrame = callFrame.caller;
         } while (callFrame);
         return result;
     },
 
     /**
-     * @param {Object} topCallFrame
+     * @param {!Object} topCallFrame
+     * @param {!Array.<!Object>} asyncCallStacks
      * @param {string} callFrameId
      * @param {string} expression
      * @param {string} objectGroup
      * @param {boolean} injectCommandLineAPI
      * @param {boolean} returnByValue
      * @param {boolean} generatePreview
      * @return {*}
      */
-    evaluateOnCallFrame: function(topCallFrame, callFrameId, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
+    evaluateOnCallFrame: function(topCallFrame, asyncCallStacks, callFrameId, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
     {
-        var callFrame = this.callFrameForId(topCallFrame, callFrameId);
+        var parsedCallFrameId = InjectedScriptHost.evaluate("(" + 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(topCallFrame.evaluateGlobal, topCallFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, generatePreview, InjectedScript.CallFrameProxy._toProtoChainedScope(callFrame));

[yurys, 2014/01/21 11:56:52]

Why do we use topCallFrame as object argument but not callFrame here ? We should
be evaluating either in the context of current frame or in an async frame I
believe.

[aandrey, 2014/01/21 13:30:22]

We can evaluate only on the call frames of the current call stack while paused,
thus callFrame.evaluate and callFrame.evaluateGlobal would throw, given that
callFrame is async.

The topCallFrame.evaluateGlobal runs global eval rather than eval-on-call-frame.
All evaluateGlobal methods of the valid ("sync") call frames behave in the same
way.

[yurys, 2014/01/21 13:54:43]

Sound like we should have a version of evaluateGlobal that would work on pause
rather than abusing CallFrame.evaluateGlobal. It should be a straightforward
change on V8 side and would make this code simpler.

         return this._evaluateAndWrap(callFrame.evaluate, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, generatePreview);
     },
 
     /**
-     * @param {Object} topCallFrame
+     * @param {!Object} topCallFrame
      * @param {string} callFrameId
      * @return {*}
      */
     restartFrame: function(topCallFrame, callFrameId)
     {
         var callFrame = this.callFrameForId(topCallFrame, callFrameId);
         if (!callFrame)
             return "Could not find call frame with given id";
         var result = callFrame.restart();
         if (result === false)
             result = "Restart frame is not supported";
         return result;
     },
 
     /**
-     * @param {Object} topCallFrame
+     * @param {!Object} topCallFrame
      * @param {string} callFrameId
      * @return {*} a stepIn position array ready for protocol JSON or a string error
      */
     getStepInPositions: function(topCallFrame, callFrameId)
     {
         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;
     },
 
     /**
      * Either callFrameId or functionObjectId must be specified.
-     * @param {Object} topCallFrame
+     * @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;
@@ skipping 23 matching lines @@
         }
         try {
             setter(scopeNumber, variableName, resolvedValue);
         } catch (e) {
             return "Failed to change variable value: " + e;
         }
         return undefined;
     },
 
     /**
-     * @param {Object} topCallFrame
+     * @param {!Object} topCallFrame
      * @param {string} callFrameId
-     * @return {Object}
+     * @return {?Object}
      */
     callFrameForId: function(topCallFrame, callFrameId)
     {
         var parsedCallFrameId = InjectedScriptHost.evaluate("(" + callFrameId + ")");
+        return this._callFrameForParsedId(topCallFrame, parsedCallFrameId, []);
+    },
+
+    /**
+     * @param {!Object} topCallFrame
+     * @param {!Object} parsedCallFrameId
+     * @param {!Array.<!Object>} asyncCallStacks
+     * @return {?Object}
+     */
+    _callFrameForParsedId: function(topCallFrame, parsedCallFrameId, asyncCallStacks)
+    {
+        var asyncOrdinal = parsedCallFrameId["asyncOrdinal"] || 0; // 1-based index

[yurys, 2014/01/21 11:56:52]

You don't really need  "|| 0" part.

[aandrey, 2014/01/21 13:30:22]

Done.

+        if (asyncOrdinal)
+            topCallFrame = asyncCallStacks[asyncOrdinal - 1];
+        var callFrame = topCallFrame;
         var ordinal = parsedCallFrameId["ordinal"];
-        var callFrame = topCallFrame;
         while (--ordinal >= 0 && callFrame)
             callFrame = callFrame.caller;
         return callFrame;
     },
 
     /**
      * @param {Object} objectId
      * @return {Object}
      */
     _objectForId: function(objectId)
@@ skipping 351 matching lines @@
             var rightHalf = maxLength - leftHalf - 1;
             return string.substr(0, leftHalf) + "\u2026" + string.substr(string.length - rightHalf, rightHalf);
         }
         return string.substr(0, maxLength) + "\u2026";
     }
 }
 /**
  * @constructor
  * @param {number} ordinal
  * @param {!Object} callFrame
+ * @param {number} asyncOrdinal
  */
-InjectedScript.CallFrameProxy = function(ordinal, callFrame)
+InjectedScript.CallFrameProxy = function(ordinal, callFrame, asyncOrdinal)
 {
-    this.callFrameId = "{\"ordinal\":" + ordinal + ",\"injectedScriptId\":" + injectedScriptId + "}";
+    this.callFrameId = "{\"ordinal\":" + ordinal + ",\"injectedScriptId\":" + injectedScriptId + (asyncOrdinal ? ",\"asyncOrdinal\":" + asyncOrdinal : "") + "}";
     this.functionName = (callFrame.type === "function" ? callFrame.functionName : "");
     this.location = { scriptId: toString(callFrame.sourceID), lineNumber: callFrame.line, columnNumber: callFrame.column };
     this.scopeChain = this._wrapScopeChain(callFrame);
     this.this = injectedScript._wrapObject(callFrame.thisObject, "backtrace");
     if (callFrame.isAtReturn)
         this.returnValue = injectedScript._wrapObject(callFrame.returnValue, "backtrace");
 }
 
 InjectedScript.CallFrameProxy.prototype = {
     /**
      * @param {Object} callFrame
      * @return {!Array.<DebuggerAgent.Scope>}
      */
     _wrapScopeChain: function(callFrame)
     {
         var scopeChain = callFrame.scopeChain;
         var scopeChainProxy = [];
-        for (var i = 0; i < scopeChain.length; i++) {
+        for (var i = 0; i < scopeChain.length; ++i) {
             var scope = InjectedScript.CallFrameProxy._createScopeJson(callFrame.scopeType(i), scopeChain[i], "backtrace");
             scopeChainProxy.push(scope);
         }
         return scopeChainProxy;
     }
 }
 
 /**
  * @param {number} scopeTypeCode
  * @param {*} scopeObject
  * @param {string} groupId
  * @return {!DebuggerAgent.Scope}
  */
-InjectedScript.CallFrameProxy._createScopeJson = function(scopeTypeCode, scopeObject, groupId) {
+InjectedScript.CallFrameProxy._createScopeJson = function(scopeTypeCode, scopeObject, groupId)
+{
     const GLOBAL_SCOPE = 0;
     const LOCAL_SCOPE = 1;
     const WITH_SCOPE = 2;
     const CLOSURE_SCOPE = 3;
     const CATCH_SCOPE = 4;
 
     /** @type {!Object.<number, string>} */
     var scopeTypeNames = {};
     scopeTypeNames[GLOBAL_SCOPE] = "global";
     scopeTypeNames[LOCAL_SCOPE] = "local";
     scopeTypeNames[WITH_SCOPE] = "with";
     scopeTypeNames[CLOSURE_SCOPE] = "closure";
     scopeTypeNames[CATCH_SCOPE] = "catch";
 
     return {
         object: injectedScript._wrapObject(scopeObject, groupId),
         type: /** @type {DebuggerAgent.ScopeType} */ (scopeTypeNames[scopeTypeCode])
     };
 }
 
 /**
+ * @param {!Object} callFrame
+ * @return {!Object}
+ */
+InjectedScript.CallFrameProxy._toProtoChainedScope = function(callFrame)
+{
+    /**
+     * @this {Object}
+     */
+    function getter(name)
+    {
+        return this[name];
+    }
+
+    function addProperties(object)
+    {
+        for (var o = object; injectedScript._isDefined(o); o = o.__proto__) {
+            var names = Object.getOwnPropertyNames(/** @type {!Object} */ (o));
+            for (var i = 0, n = names.length; i < n; ++i) {
+                var name = names[i];
+                if (name in proxy || name === "__proto__")
+                    continue;
+                Object.prototype.__defineGetter__.call(proxy, name, bind(getter, object, name));

[yurys, 2014/01/21 11:56:52]

Why not simply copy the value: proxy[name] = o[name] ?

[aandrey, 2014/01/21 13:30:22]

To avoid side effects.
For example, accessing window["webkitStorageInfo"] may trigger a warning:

'window.webkitStorageInfo' is deprecated. Please use
'navigator.webkitTemporaryStorage' or 'navigator.webkitPersistentStorage'
instead. 

[yurys, 2014/01/21 13:54:43]

I'm concerned about the performance here. We may end up adding wrapping many
properties of a global object. On the other hand, if it happens only for
evaluation on asyn call frame it might be OK.

What if instead we passed chain of extension objects  into evaluateGlobal and
have it construct a several with blocks for each of the extension object, would
it solve this problem?

+            }
+        }
+        return proxy;
+    }
+
+    var proxy = { __proto__: null };
+
+    var scopeChain = callFrame.scopeChain;
+    for (var i = 0; i < scopeChain.length; ++i)
+        addProperties(scopeChain[i]);
+
+    return proxy;
+}
+
+/**
  * @constructor
  * @param {CommandLineAPIImpl} commandLineAPIImpl
  * @param {Object} callFrame
  */
 function CommandLineAPI(commandLineAPIImpl, callFrame)
 {
     /**
      * @param {string} member
      * @return {boolean}
      */
@@ skipping 257 matching lines @@
     undebug: function(fn)
     {
         InjectedScriptHost.undebugFunction(fn);
     },
 
     monitor: function(fn)
     {
         InjectedScriptHost.monitorFunction(fn);
     },
 
-    unmonitor: function(fn) {
+    unmonitor: function(fn)
+    {
         InjectedScriptHost.unmonitorFunction(fn);
     },
 
     table: function(data, opt_columns)
     {
         inspectedWindow.console.table.apply(inspectedWindow.console, arguments);
     },
 
     /**
      * @param {number} num
@@ skipping 35 matching lines @@
      */
     _logEvent: function(event)
     {
         inspectedWindow.console.log(event.type, event);
     }
 }
 
 injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
 return injectedScript;
 })