DevTools: rename inspectedWindow to inspectedGlobalObject in InjectedScriptSource.js

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 13 matching lines @@
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 "use strict";
 
 /**
  * @param {!InjectedScriptHostClass} InjectedScriptHost
- * @param {!Window} inspectedWindow
+ * @param {!Window|!WorkerGlobalScope} inspectedGlobalObject
  * @param {number} injectedScriptId
  */
-(function (InjectedScriptHost, inspectedWindow, injectedScriptId) {
+(function (InjectedScriptHost, inspectedGlobalObject, injectedScriptId) {
 
 /**
  * Protect against Object overwritten by the user code.
  * @suppress {duplicate}
  */
 var Object = /** @type {function(new:Object, *=)} */ ({}.constructor);
 
 /**
  * @param {!Array.<T>} array
  * @param {...} var_args
@@ skipping 189 matching lines @@
 
 /**
  * @param {!Object} object
  * @param {string} attribute
  * @return {boolean}
  */
 function doesAttributeHaveObservableSideEffectOnGet(object, attribute)
 {
     for (var interfaceName in domAttributesWithObservableSideEffectOnGet) {
         var isInstance = InjectedScriptHost.suppressWarningsAndCallFunction(function(object, interfaceName) {
-            return /* suppressBlacklist */ typeof inspectedWindow[interfaceName] === "function" && object instanceof inspectedWindow[interfaceName];
+            return /* suppressBlacklist */ typeof inspectedGlobalObject[interfaceName] === "function" && object instanceof inspectedGlobalObject[interfaceName];
         }, null, [object, interfaceName]);
         if (isInstance) {
             return attribute in domAttributesWithObservableSideEffectOnGet[interfaceName];
         }
     }
     return false;
 }
 
 /**
  * @constructor
@@ skipping 23 matching lines @@
      */
     isPrimitiveValue: function(object)
     {
         // FIXME(33716): typeof document.all is always 'undefined'.
         return InjectedScript.primitiveTypes[typeof object] && !this._isHTMLAllCollection(object);
     },
 
     /**
      * @param {*} object
      * @param {string} groupName
-     * @param {boolean} canAccessInspectedWindow
+     * @param {boolean} canAccessInspectedGlobalObject
      * @param {boolean} generatePreview
      * @return {!RuntimeAgent.RemoteObject}
      */
-    wrapObject: function(object, groupName, canAccessInspectedWindow, generatePreview)
+    wrapObject: function(object, groupName, canAccessInspectedGlobalObject, generatePreview)
     {
-        if (canAccessInspectedWindow)
+        if (canAccessInspectedGlobalObject)
             return this._wrapObject(object, groupName, false, generatePreview);
         return this._fallbackWrapper(object);
     },
 
     /**
      * @param {*} object
      * @param {string} groupName
      * @param {boolean=} doNotBind
      * @return {!RuntimeAgent.RemoteObject}
      */
@@ skipping 11 matching lines @@
         var result = { __proto__: null };
         result.type = typeof object;
         if (this.isPrimitiveValue(object))
             result.value = object;
         else
             result.description = toString(object);
         return /** @type {!RuntimeAgent.RemoteObject} */ (result);
     },
 
     /**
-     * @param {boolean} canAccessInspectedWindow
+     * @param {boolean} canAccessInspectedGlobalObject
      * @param {!Object} table
      * @param {!Array.<string>|string|boolean} columns
      * @return {!RuntimeAgent.RemoteObject}
      */
-    wrapTable: function(canAccessInspectedWindow, table, columns)
+    wrapTable: function(canAccessInspectedGlobalObject, table, columns)
     {
-        if (!canAccessInspectedWindow)
+        if (!canAccessInspectedGlobalObject)
             return this._fallbackWrapper(table);
         var columnNames = null;
         if (typeof columns === "string")
             columns = [columns];
         if (InjectedScriptHost.subtype(columns) === "array") {
             columnNames = [];
             for (var i = 0; i < columns.length; ++i)
                 columnNames[i] = toString(columns[i]);
         }
         return this._wrapObject(table, "console", false, true, columnNames, true);
@@ skipping 70 matching lines @@
     /**
      * @param {string} methodName
      * @param {string} args
      * @return {*}
      */
     dispatch: function(methodName, args)
     {
         var argsArray = /** @type {!Array.<*>} */ (InjectedScriptHost.eval("(" + args + ")"));
         var result = InjectedScriptHost.callFunction(this[methodName], this, argsArray);
         if (typeof result === "undefined") {
-            inspectedWindow.console.error("Web Inspector error: InjectedScript.%s returns undefined", methodName);
+            inspectedGlobalObject.console.error("Web Inspector error: InjectedScript.%s returns undefined", methodName);
             result = null;
         }
         return result;
     },
 
     /**
      * @param {string} objectId
      * @param {boolean} ownProperties
      * @param {boolean} accessorPropertiesOnly
      * @param {boolean} generatePreview
@@ skipping 295 matching lines @@
          * @this {InjectedScript}
          */
         function wrap(object, forceValueType, generatePreview, columnNames, isTable, customObjectConfig)
         {
             return this._wrapObject(object, objectGroup, forceValueType, generatePreview, columnNames, isTable, false, customObjectConfig);
         }
 
         try {
 
             var remoteObjectAPI = { bindRemoteObject: bind(wrap, this), __proto__: null};
-            InjectedScriptHost.setNonEnumProperty(inspectedWindow, "__remoteObjectAPI", remoteObjectAPI);
+            InjectedScriptHost.setNonEnumProperty(inspectedGlobalObject, "__remoteObjectAPI", remoteObjectAPI);
 
             var func = InjectedScriptHost.eval("with (typeof __remoteObjectAPI !== 'undefined' ? __remoteObjectAPI : { __proto__: null }) {(" + expression + ")}");
             if (typeof func !== "function")
                 return "Given expression does not evaluate to a function";
 
             return { wasThrown: false,
                      result: this._wrapObject(InjectedScriptHost.callFunction(func, object, resolvedArgs), objectGroup, returnByValue),
                      __proto__: null };
         } catch (e) {
             return this._createThrownValue(e, objectGroup, false);
         } finally {
             try {
-                delete inspectedWindow["__remoteObjectAPI"];
+                delete inspectedGlobalObject["__remoteObjectAPI"];
             } catch(e) {
             }
         }
     },
 
     /**
      * @param {string|undefined} objectGroupName
      * @param {*} jsonMLObject
      * @throws {string} error message
      */
@@ skipping 103 matching lines @@
      * @return {*}
      */
     _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.
 
         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);
+        injectCommandLineAPI = !scopeExtensionForEval && !callFrame && injectCommandLineAPI && !("__commandLineAPI" in inspectedGlobalObject);
+        var injectScopeChain = scopeChain && scopeChain.length && !("__scopeChainForEval" in inspectedGlobalObject);
 
         try {
             var prefix = "";
             var suffix = "";
             if (injectCommandLineAPI) {
-                InjectedScriptHost.setNonEnumProperty(inspectedWindow, "__commandLineAPI", new CommandLineAPI(this._commandLineAPIImpl, callFrame));
+                InjectedScriptHost.setNonEnumProperty(inspectedGlobalObject, "__commandLineAPI", new CommandLineAPI(this._commandLineAPIImpl, callFrame));
                 prefix = "with (typeof __commandLineAPI !== 'undefined' ? __commandLineAPI : { __proto__: null }) {";
                 suffix = "}";
             }
             if (injectScopeChain) {
-                InjectedScriptHost.setNonEnumProperty(inspectedWindow, "__scopeChainForEval", scopeChain);
+                InjectedScriptHost.setNonEnumProperty(inspectedGlobalObject, "__scopeChainForEval", scopeChain);
                 for (var i = 0; i < scopeChain.length; ++i) {
                     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 = callFrame ? callFrame.evaluateWithExceptionDetails(expression, scopeExtensionForEval) : InjectedScriptHost.evaluateWithExceptionDetails(expression);
             if (objectGroup === "console" && !wrappedResult.exceptionDetails)
                 this._lastResult = wrappedResult.result;
             return wrappedResult;
         } finally {
             if (injectCommandLineAPI) {
                 try {
-                    delete inspectedWindow["__commandLineAPI"];
+                    delete inspectedGlobalObject["__commandLineAPI"];
                 } catch(e) {
                 }
             }
             if (injectScopeChain) {
                 try {
-                    delete inspectedWindow["__scopeChainForEval"];
+                    delete inspectedGlobalObject["__scopeChainForEval"];
                 } catch(e) {
                 }
             }
         }
     },
 
     /**
      * @param {?Object} callFrame
      * @param {number} asyncOrdinal
      * @return {!Array.<!InjectedScript.CallFrameProxy>|boolean}
@@ skipping 172 matching lines @@
     /**
      * @param {string} name
      * @param {string} source
      * @return {?Object}
      */
     injectModule: function(name, source)
     {
         delete this._modules[name];
         var moduleFunction = InjectedScriptHost.eval("(" + source + ")");
         if (typeof moduleFunction !== "function") {
-            inspectedWindow.console.error("Web Inspector error: A function was expected for module %s evaluation", name);
+            inspectedGlobalObject.console.error("Web Inspector error: A function was expected for module %s evaluation", name);
             return null;
         }
-        var module = /** @type {!Object} */ (InjectedScriptHost.callFunction(moduleFunction, inspectedWindow, [InjectedScriptHost, inspectedWindow, injectedScriptId, this]));
+        var module = /** @type {!Object} */ (InjectedScriptHost.callFunction(moduleFunction, inspectedGlobalObject, [InjectedScriptHost, inspectedGlobalObject, injectedScriptId, this]));
         this._modules[name] = module;
         return module;
     },
 
     /**
      * @param {*} object
      * @return {boolean}
      */
     _isDefined: function(object)
     {
@@ skipping 190 matching lines @@
      * @param {*=} customObjectConfig
      * @return {?RuntimeAgent.CustomPreview}
      */
     _customPreview: function(object, objectGroupName, customObjectConfig)
     {
         /**
          * @param {!Error} error
          */
         function logError(error)
         {
-            Promise.resolve().then(inspectedWindow.console.error.bind(inspectedWindow.console, "Custom Formatter Failed: " + error.message));
+            Promise.resolve().then(inspectedGlobalObject.console.error.bind(inspectedGlobalObject.console, "Custom Formatter Failed: " + error.message));
         }
 
         try {
-            var formatters = inspectedWindow["devtoolsFormatters"];
+            var formatters = inspectedGlobalObject["devtoolsFormatters"];
             if (!formatters || !isArrayLike(formatters))
                 return null;
 
             for (var i = 0; i < formatters.length; ++i) {
                 try {
                     var formatted = formatters[i].header(object, customObjectConfig);
                     if (!formatted)
                         continue;
 
                     var hasBody = formatters[i].hasBody(object, customObjectConfig);
@@ skipping 343 matching lines @@
  */
 function CommandLineAPI(commandLineAPIImpl, callFrame)
 {
     /**
      * @param {string} member
      * @return {boolean}
      */
     function inScopeVariables(member)
     {
         if (!callFrame)
-            return (member in inspectedWindow);
+            return (member in inspectedGlobalObject);
 
         var scopeChain = callFrame.scopeChain;
         for (var i = 0; i < scopeChain.length; ++i) {
             if (member in scopeChain[i])
                 return true;
         }
         return false;
     }
 
     /**
@@ skipping 63 matching lines @@
     /**
      * @param {string} selector
      * @param {!Node=} opt_startNode
      * @return {*}
      */
     $: function (selector, opt_startNode)
     {
         if (this._canQuerySelectorOnNode(opt_startNode))
             return opt_startNode.querySelector(selector);
 
-        return inspectedWindow.document.querySelector(selector);
+        return inspectedGlobalObject.document.querySelector(selector);
     },
 
     /**
      * @param {string} selector
      * @param {!Node=} opt_startNode
      * @return {*}
      */
     $$: function (selector, opt_startNode)
     {
         if (this._canQuerySelectorOnNode(opt_startNode))
             return opt_startNode.querySelectorAll(selector);
-        return inspectedWindow.document.querySelectorAll(selector);
+        return inspectedGlobalObject.document.querySelectorAll(selector);
     },
 
     /**
      * @param {!Node=} node
      * @return {boolean}
      */
     _canQuerySelectorOnNode: function(node)
     {
         return !!node && InjectedScriptHost.subtype(node) === "node" && (node.nodeType === Node.ELEMENT_NODE || node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE);
     },
 
     /**
      * @param {string} xpath
      * @param {!Node=} opt_startNode
      * @return {*}
      */
     $x: function(xpath, opt_startNode)
     {
-        var doc = (opt_startNode && opt_startNode.ownerDocument) || inspectedWindow.document;
+        var doc = (opt_startNode && opt_startNode.ownerDocument) || inspectedGlobalObject.document;
         var result = doc.evaluate(xpath, opt_startNode || doc, null, XPathResult.ANY_TYPE, null);
         switch (result.resultType) {
         case XPathResult.NUMBER_TYPE:
             return result.numberValue;
         case XPathResult.STRING_TYPE:
             return result.stringValue;
         case XPathResult.BOOLEAN_TYPE:
             return result.booleanValue;
         default:
             var nodes = [];
             var node;
             while (node = result.iterateNext())
                 push(nodes, node);
             return nodes;
         }
     },
 
     /**
      * @return {*}
      */
     dir: function(var_args)
     {
-        return InjectedScriptHost.callFunction(inspectedWindow.console.dir, inspectedWindow.console, slice(arguments));
+        return InjectedScriptHost.callFunction(inspectedGlobalObject.console.dir, inspectedGlobalObject.console, slice(arguments));
     },
 
     /**
      * @return {*}
      */
     dirxml: function(var_args)
     {
-        return InjectedScriptHost.callFunction(inspectedWindow.console.dirxml, inspectedWindow.console, slice(arguments));
+        return InjectedScriptHost.callFunction(inspectedGlobalObject.console.dirxml, inspectedGlobalObject.console, slice(arguments));
     },
 
     /**
      * @return {!Array.<string>}
      */
     keys: function(object)
     {
         return Object.keys(object);
     },
 
     /**
      * @return {!Array.<*>}
      */
     values: function(object)
     {
         var result = [];
         for (var key in object)
             push(result, object[key]);
         return result;
     },
 
     /**
      * @return {*}
      */
     profile: function(opt_title)
     {
-        return InjectedScriptHost.callFunction(inspectedWindow.console.profile, inspectedWindow.console, slice(arguments));
+        return InjectedScriptHost.callFunction(inspectedGlobalObject.console.profile, inspectedGlobalObject.console, slice(arguments));
     },
 
     /**
      * @return {*}
      */
     profileEnd: function(opt_title)
     {
-        return InjectedScriptHost.callFunction(inspectedWindow.console.profileEnd, inspectedWindow.console, slice(arguments));
+        return InjectedScriptHost.callFunction(inspectedGlobalObject.console.profileEnd, inspectedGlobalObject.console, slice(arguments));
     },
 
     /**
      * @param {!Object} object
      * @param {!Array.<string>|string=} opt_types
      */
     monitorEvents: function(object, opt_types)
     {
         if (!object || !object.addEventListener || !object.removeEventListener)
             return;
@@ skipping 90 matching lines @@
         InjectedScriptHost.monitorFunction(fn);
     },
 
     unmonitor: function(fn)
     {
         InjectedScriptHost.unmonitorFunction(fn);
     },
 
     table: function(data, opt_columns)
     {
-        InjectedScriptHost.callFunction(inspectedWindow.console.table, inspectedWindow.console, slice(arguments));
+        InjectedScriptHost.callFunction(inspectedGlobalObject.console.table, inspectedGlobalObject.console, slice(arguments));
     },
 
     /**
      * @param {number} num
      */
     _inspectedObject: function(num)
     {
         return InjectedScriptHost.inspectedObject(num);
     },
 
@@ skipping 22 matching lines @@
                 push(result, types[i]);
         }
         return result;
     },
 
     /**
      * @param {!Event} event
      */
     _logEvent: function(event)
     {
-        inspectedWindow.console.log(event.type, event);
+        inspectedGlobalObject.console.log(event.type, event);
     }
 }
 
 injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
 return injectedScript;
 })