DevTools: Fix __commandLineAPI is not defined error and remove the with- hack for eval on call fram…

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 598 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(null, null, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview);
+        return this._evaluateAndWrap(null, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview);
     },
 
     /**
      * @param {string} objectId
      * @param {string} expression
      * @param {string} args
      * @param {boolean} returnByValue
      * @return {!Object|string}
      */
     callFunctionOn: function(objectId, expression, args, returnByValue)
@@ skipping 52 matching lines @@
         } else if ("value" in callArgumentJson) {
             var value = callArgumentJson.value;
             if (callArgumentJson.type === "number" && typeof value !== "number")
                 value = Number(value);
             return value;
         }
         return undefined;
     },
 
     /**
-     * @param {?function(string):*} evalFunction
-     * @param {?Object} object
+     * @param {?JavaScriptCallFrame} callFrame
      * @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)
+    _evaluateAndWrap: function(callFrame, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview, scopeChain)
     {
-        var wrappedResult = this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain);
+        var wrappedResult = this._evaluateOn(callFrame, objectGroup, expression, injectCommandLineAPI, scopeChain);
         if (!wrappedResult.exceptionDetails) {
             return { wasThrown: false,
                      result: this._wrapObject(wrappedResult.result, objectGroup, returnByValue, generatePreview),
                      __proto__: null };
         }
         return this._createThrownValue(wrappedResult.result, objectGroup, generatePreview, wrappedResult.exceptionDetails);
     },
 
     /**
      * @param {*} value
      * @param {string} objectGroup
      * @param {boolean} generatePreview
      * @param {!DebuggerAgent.ExceptionDetails=} exceptionDetails
      * @return {!Object}
      */
     _createThrownValue: function(value, objectGroup, generatePreview, exceptionDetails)
     {
         var remoteObject = this._wrapObject(value, objectGroup, false, generatePreview && !(value instanceof Error));
         if (!remoteObject.description){
             try {
                 remoteObject.description = toStringDescription(value);
             } catch (e) {}
         }
         return { wasThrown: true, result: remoteObject, exceptionDetails: exceptionDetails, __proto__: null };
     },
 
     /**
-     * @param {?function(string):*} evalFunction
-     * @param {?Object} object
+     * @param {?JavaScriptCallFrame} callFrame
      * @param {string} objectGroup
      * @param {string} expression
-     * @param {boolean} isEvalOnCallFrame
      * @param {boolean} injectCommandLineAPI
      * @param {!Array.<!Object>=} scopeChain
      * @return {*}
      */
-    _evaluateOn: function(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain)
+    _evaluateOn: function(callFrame, objectGroup, expression, injectCommandLineAPI, scopeChain)
     {
         // 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.
 
-        injectCommandLineAPI = injectCommandLineAPI && !("__commandLineAPI" in inspectedWindow);
+        var scopeExtensionForEval = (callFrame && injectCommandLineAPI) ? new CommandLineAPI(this._commandLineAPIImpl, callFrame) : undefined;
+
+        injectCommandLineAPI = !scopeExtensionForEval && !callFrame && injectCommandLineAPI && !("__commandLineAPI" in inspectedWindow);
         var injectScopeChain = scopeChain && scopeChain.length && !("__scopeChainForEval" in inspectedWindow);
 
         try {
             var prefix = "";
             var suffix = "";
             if (injectCommandLineAPI) {
-                InjectedScriptHost.setNonEnumProperty(inspectedWindow, "__commandLineAPI", new CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null));
-                prefix = "with (__commandLineAPI || { __proto__: null }) {";
+                InjectedScriptHost.setNonEnumProperty(inspectedWindow, "__commandLineAPI", new CommandLineAPI(this._commandLineAPIImpl, callFrame));
+                prefix = "with (typeof __commandLineAPI !== 'undefined' ? __commandLineAPI : { __proto__: null }) {";
                 suffix = "}";
             }
             if (injectScopeChain) {
                 InjectedScriptHost.setNonEnumProperty(inspectedWindow, "__scopeChainForEval", scopeChain);
                 for (var i = 0; i < scopeChain.length; ++i) {
-                    prefix = "with (__scopeChainForEval[" + i + "] || { __proto__: null }) {" + (suffix ? " " : "") + prefix;
+                    prefix = "with (typeof __scopeChainForEval !== 'undefined' ? __scopeChainForEval[" + i + "] : { __proto__: null }) {" + (suffix ? " " : "") + prefix;
                     if (suffix)
                         suffix += " }";
                     else
                         suffix = "}";
                 }
             }
 
             if (prefix)
                 expression = prefix + "\n" + expression + "\n" + suffix;
-            var wrappedResult = evalFunction ? InjectedScriptHost.callFunction(evalFunction, object, [expression]) : InjectedScriptHost.evaluateWithExceptionDetails(expression);
+            var wrappedResult = callFrame ? callFrame.evaluateWithExceptionDetails(expression, scopeExtensionForEval) : InjectedScriptHost.evaluateWithExceptionDetails(expression);
             if (objectGroup === "console" && !wrappedResult.exceptionDetails)
                 this._lastResult = wrappedResult.result;
             return wrappedResult;
         } finally {
             if (injectCommandLineAPI)
                 delete inspectedWindow["__commandLineAPI"];
             if (injectScopeChain)
                 delete inspectedWindow["__scopeChainForEval"];
         }
     },
@@ skipping 12 matching lines @@
         var depth = 0;
         do {
             result[depth] = new InjectedScript.CallFrameProxy(depth, callFrame, asyncOrdinal);
             callFrame = callFrame.caller;
             ++depth;
         } while (callFrame);
         return result;
     },
 
     /**
-     * @param {!Object} topCallFrame
-     * @param {!Array.<!Object>} asyncCallStacks
+     * @param {!JavaScriptCallFrame} topCallFrame
+     * @param {!Array.<!JavaScriptCallFrame>} asyncCallStacks
      * @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(/** @type {!Object} */ (InjectedScriptHost.eval("(" + 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(null, null, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview, callFrame.scopeChain);
-        return this._evaluateAndWrap(callFrame.evaluateWithExceptionDetails, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, generatePreview);
+            return this._evaluateAndWrap(null, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview, callFrame.scopeChain);
+        return this._evaluateAndWrap(callFrame, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview);
     },
 
     /**
-     * @param {!Object} topCallFrame
+     * @param {!JavaScriptCallFrame} 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 {!JavaScriptCallFrame} 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 {!JavaScriptCallFrame} 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)
     {
         try {
@@ skipping 11 matching lines @@
                     return "Could not resolve function by id";
                 InjectedScriptHost.setFunctionVariableValue(func, scopeNumber, variableName, resolvedValue);
             }
         } catch (e) {
             return toString(e);
         }
         return undefined;
     },
 
     /**
-     * @param {!Object} topCallFrame
+     * @param {!JavaScriptCallFrame} topCallFrame
      * @param {string} callFrameId
-     * @return {?Object}
+     * @return {?JavaScriptCallFrame}
      */
     _callFrameForId: function(topCallFrame, callFrameId)
     {
         var parsedCallFrameId = nullifyObjectProto(/** @type {!Object} */ (InjectedScriptHost.eval("(" + callFrameId + ")")));
         return this._callFrameForParsedId(topCallFrame, parsedCallFrameId, []);
     },
 
     /**
-     * @param {!Object} topCallFrame
+     * @param {!JavaScriptCallFrame} topCallFrame
      * @param {!Object} parsedCallFrameId
-     * @param {!Array.<!Object>} asyncCallStacks
-     * @return {?Object}
+     * @param {!Array.<!JavaScriptCallFrame>} asyncCallStacks
+     * @return {?JavaScriptCallFrame}
      */
     _callFrameForParsedId: function(topCallFrame, parsedCallFrameId, asyncCallStacks)
     {
         var asyncOrdinal = parsedCallFrameId["asyncOrdinal"]; // 1-based index
         if (asyncOrdinal)
             topCallFrame = asyncCallStacks[asyncOrdinal - 1];
         var ordinal = parsedCallFrameId["ordinal"];
         var callFrame = topCallFrame;
         while (--ordinal >= 0 && callFrame)
             callFrame = callFrame.caller;
@@ skipping 524 matching lines @@
     return {
         object: injectedScript._wrapObject(scopeObject, groupId),
         type: /** @type {!DebuggerAgent.ScopeType} */ (scopeTypeNames[scopeTypeCode]),
         __proto__: null
     };
 }
 
 /**
  * @constructor
  * @param {!CommandLineAPIImpl} commandLineAPIImpl
- * @param {?Object} callFrame
+ * @param {?JavaScriptCallFrame} callFrame
  */
 function CommandLineAPI(commandLineAPIImpl, callFrame)
 {
     /**
      * @param {string} member
      * @return {boolean}
      */
     function inScopeVariables(member)
     {
         if (!callFrame)
-            return false;
+            return (member in inspectedWindow);
 
         var scopeChain = callFrame.scopeChain;
         for (var i = 0; i < scopeChain.length; ++i) {
             if (member in scopeChain[i])
                 return true;
         }
         return false;
     }
 
     /**
@@ skipping 13 matching lines @@
                 funcSyntax = funcSyntax.replace(/\bopt_(\w+)\b/g, "[$1]");
                 funcArgsSyntax = funcSyntax.trim();
             } catch (e) {
             }
             return "function " + name + "(" + funcArgsSyntax + ") { [Command Line API] }";
         };
     }
 
     for (var i = 0; i < CommandLineAPI.members_.length; ++i) {
         var member = CommandLineAPI.members_[i];
-        if (member in inspectedWindow || inScopeVariables(member))
+        if (inScopeVariables(member))
             continue;
 
         this[member] = bind(commandLineAPIImpl[member], commandLineAPIImpl);
         this[member].toString = customToStringMethod(member);
     }
 
     for (var i = 0; i < 5; ++i) {
         var member = "$" + i;
-        if (member in inspectedWindow || inScopeVariables(member))
+        if (inScopeVariables(member))
             continue;
 
         this.__defineGetter__("$" + i, bind(commandLineAPIImpl._inspectedObject, commandLineAPIImpl, i));
     }
 
     this.$_ = injectedScript._lastResult;
 
     this.__proto__ = null;
 }
 
@@ skipping 278 matching lines @@
      */
     _logEvent: function(event)
     {
         inspectedWindow.console.log(event.type, event);
     }
 }
 
 injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
 return injectedScript;
 })