home *** CD-ROM | disk | FTP | other *** search
/ Computer Active Guide 2009 July / CAG7.ISO / Internetas / SafariSetup.exe / AppleApplicationSupport.msi / WebKit.resources_inspector_InjectedScript.js < prev    next >
Encoding:
JavaScript  |  2010-06-03  |  38.0 KB  |  1,045 lines
  1. /*
  2.  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * 1.  Redistributions of source code must retain the above copyright
  9.  *     notice, this list of conditions and the following disclaimer.
  10.  * 2.  Redistributions in binary form must reproduce the above copyright
  11.  *     notice, this list of conditions and the following disclaimer in the
  12.  *     documentation and/or other materials provided with the distribution.
  13.  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14.  *     its contributors may be used to endorse or promote products derived
  15.  *     from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18.  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20.  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21.  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22.  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. var injectedScriptConstructor = (function (InjectedScriptHost, inspectedWindow, injectedScriptId, jsEngine) {
  30.  
  31. var InjectedScript = {};
  32.  
  33. InjectedScript.lastBoundObjectId = 1;
  34. InjectedScript.idToWrappedObject = {};
  35. InjectedScript.objectGroups = {};
  36.  
  37. InjectedScript.wrapObjectForConsole = function(object, canAccessInspectedWindow)
  38. {
  39.     if (canAccessInspectedWindow)
  40.         return InjectedScript.wrapObject(object, "console");
  41.     var result = {};
  42.     result.type = typeof object;
  43.     result.description = InjectedScript._toString(object);
  44.     return result;
  45. }
  46.  
  47. InjectedScript.wrapObject = function(object, objectGroupName)
  48. {
  49.     try {
  50.         var objectId;
  51.         if (typeof object === "object" || typeof object === "function" || InjectedScript._isHTMLAllCollection(object)) {
  52.             var id = InjectedScript.lastBoundObjectId++;
  53.             objectId = "object#" + id;
  54.             InjectedScript.idToWrappedObject[objectId] = object;
  55.  
  56.             var group = InjectedScript.objectGroups[objectGroupName];
  57.             if (!group) {
  58.                 group = [];
  59.                 InjectedScript.objectGroups[objectGroupName] = group;
  60.             }
  61.             group.push(objectId);
  62.         }
  63.         return InjectedScript.createProxyObject(object, objectId);
  64.     } catch (e) {
  65.         return InjectedScript.createProxyObject("[ Exception: " + e.toString() + " ]");
  66.     }
  67.     return InjectedScript.createProxyObject(object, objectId);
  68. };
  69.  
  70. InjectedScript.unwrapObject = function(objectId) {
  71.     return InjectedScript.idToWrappedObject[objectId];
  72. };
  73.  
  74. InjectedScript.releaseWrapperObjectGroup = function(objectGroupName) {
  75.     var group = InjectedScript.objectGroups[objectGroupName];
  76.     if (!group)
  77.         return;
  78.     for (var i = 0; i < group.length; i++)
  79.         delete InjectedScript.idToWrappedObject[group[i]];
  80.     delete InjectedScript.objectGroups[objectGroupName];
  81. };
  82.  
  83. // Called from within InspectorController on the 'inspected page' side.
  84. InjectedScript.reset = function()
  85. {
  86.     InjectedScript._searchResults = [];
  87.     InjectedScript._includedInSearchResultsPropertyName = "__includedInInspectorSearchResults";
  88. }
  89.  
  90. InjectedScript.reset();
  91.  
  92. InjectedScript.dispatch = function(methodName, args, callId)
  93. {
  94.     var argsArray = eval("(" + args + ")");
  95.     if (callId)
  96.         argsArray.splice(0, 0, callId);  // Methods that run asynchronously have a call back id parameter.
  97.     var result = InjectedScript[methodName].apply(InjectedScript, argsArray);
  98.     if (typeof result === "undefined") {
  99.         inspectedWindow.console.error("Web Inspector error: InjectedScript.%s returns undefined", methodName);
  100.         result = null;
  101.     }
  102.     return result;
  103. }
  104.  
  105. InjectedScript.getPrototypes = function(nodeId)
  106. {
  107.     var node = InjectedScript._nodeForId(nodeId);
  108.     if (!node)
  109.         return false;
  110.  
  111.     var result = [];
  112.     for (var prototype = node; prototype; prototype = prototype.__proto__) {
  113.         var title = InjectedScript._describe(prototype, true);
  114.         if (title.match(/Prototype$/)) {
  115.             title = title.replace(/Prototype$/, "");
  116.         }
  117.         result.push(title);
  118.     }
  119.     return result;
  120. }
  121.  
  122. InjectedScript.getProperties = function(objectProxy, ignoreHasOwnProperty, abbreviate)
  123. {
  124.     var object = InjectedScript._resolveObject(objectProxy);
  125.     if (!InjectedScript._isDefined(object))
  126.         return false;
  127.     var properties = [];
  128.     
  129.     var propertyNames = ignoreHasOwnProperty ? InjectedScript._getPropertyNames(object) : Object.getOwnPropertyNames(object);
  130.     if (!ignoreHasOwnProperty && object.__proto__)
  131.         propertyNames.push("__proto__");
  132.  
  133.     if (jsEngine === "v8") {
  134.         // Check if the object is a scope.
  135.         if (InjectedScript._isScopeProxy(objectProxy)) {
  136.             propertyNames = [];
  137.             for (var name in object)
  138.                 propertyNames.push(name);
  139.         } else {
  140.             // FIXME(http://crbug.com/41243): Object.getOwnPropertyNames may return duplicated names.
  141.             var a = [];
  142.             propertyNames.sort();
  143.             var prev;
  144.             for (var i = 0; i < propertyNames.length; i++) {
  145.                 var n = propertyNames[i];
  146.                 if (n != prev)
  147.                     a.push(n);
  148.                 prev = n;
  149.             }
  150.             propertyNames = a;
  151.         }
  152.     }
  153.     
  154.     // Go over properties, prepare results.
  155.     for (var i = 0; i < propertyNames.length; ++i) {
  156.         var propertyName = propertyNames[i];
  157.  
  158.         var property = {};
  159.         property.name = propertyName + "";
  160.         property.parentObjectProxy = objectProxy;
  161.         var isGetter = object["__lookupGetter__"] && object.__lookupGetter__(propertyName);
  162.         if (!isGetter) {
  163.             try {
  164.                 var childObject = object[propertyName];
  165.                 var childObjectProxy = new InjectedScript.createProxyObject(childObject, objectProxy.objectId, abbreviate);
  166.                 childObjectProxy.path = objectProxy.path ? objectProxy.path.slice() : [];
  167.                 childObjectProxy.path.push(propertyName);
  168.                 property.value = childObjectProxy;
  169.             } catch(e) {
  170.                 property.value = { description: e.toString() };
  171.                 property.isError = true;
  172.             }
  173.         } else {
  174.             // FIXME: this should show something like "getter" (bug 16734).
  175.             property.value = { description: "\u2014" }; // em dash
  176.             property.isGetter = true;
  177.         }
  178.         properties.push(property);
  179.     }
  180.     return properties;
  181. }
  182.  
  183. InjectedScript._isScopeProxy = function(objectProxy)
  184. {
  185.     var objectId = objectProxy.objectId;
  186.     return typeof objectId === "object" && !objectId.thisObject;
  187. } 
  188.  
  189. InjectedScript.setPropertyValue = function(objectProxy, propertyName, expression)
  190. {
  191.     var object = InjectedScript._resolveObject(objectProxy);
  192.     if (!InjectedScript._isDefined(object))
  193.         return false;
  194.  
  195.     var expressionLength = expression.length;
  196.     if (!expressionLength) {
  197.         delete object[propertyName];
  198.         return !(propertyName in object);
  199.     }
  200.  
  201.     try {
  202.         // Surround the expression in parenthesis so the result of the eval is the result
  203.         // of the whole expression not the last potential sub-expression.
  204.  
  205.         // There is a regression introduced here: eval is now happening against global object,
  206.         // not call frame while on a breakpoint.
  207.         // TODO: bring evaluation against call frame back.
  208.         var result = inspectedWindow.eval("(" + expression + ")");
  209.         // Store the result in the property.
  210.         object[propertyName] = result;
  211.         return true;
  212.     } catch(e) {
  213.         try {
  214.             var result = inspectedWindow.eval("\"" + InjectedScript._escapeCharacters(expression, "\"") + "\"");
  215.             object[propertyName] = result;
  216.             return true;
  217.         } catch(e) {
  218.             return false;
  219.         }
  220.     }
  221. }
  222.  
  223. InjectedScript.getNodePropertyValue = function(nodeId, propertyName)
  224. {
  225.     var node = InjectedScript._nodeForId(nodeId);
  226.     if (!node)
  227.         return false;
  228.     var result = node[propertyName];
  229.     return result !== undefined ? result : false;
  230. }
  231.  
  232. InjectedScript.setOuterHTML = function(nodeId, value, expanded)
  233. {
  234.     var node = InjectedScript._nodeForId(nodeId);
  235.     if (!node)
  236.         return false;
  237.  
  238.     var parent = node.parentNode;
  239.     var prevSibling = node.previousSibling;
  240.     node.outerHTML = value;
  241.     var newNode = prevSibling ? prevSibling.nextSibling : parent.firstChild;
  242.  
  243.     return InjectedScriptHost.pushNodePathToFrontend(newNode, expanded, false);
  244. }
  245.  
  246. InjectedScript._populatePropertyNames = function(object, resultSet)
  247. {
  248.     for (var o = object; o; o = o.__proto__) {
  249.         try {
  250.             var names = Object.getOwnPropertyNames(o);
  251.             for (var i = 0; i < names.length; ++i)
  252.                 resultSet[names[i] + ""] = true;
  253.         } catch (e) {
  254.         }
  255.     }
  256. }
  257.  
  258. InjectedScript._getPropertyNames = function(object, resultSet)
  259. {
  260.     var propertyNameSet = {};
  261.     InjectedScript._populatePropertyNames(object, propertyNameSet);
  262.     return Object.keys(propertyNameSet);
  263. }
  264.  
  265. InjectedScript.getCompletions = function(expression, includeInspectorCommandLineAPI, callFrameId)
  266. {
  267.     var props = {};
  268.     try {
  269.         var expressionResult;
  270.         // Evaluate on call frame if call frame id is available.
  271.         if (typeof callFrameId === "number") {
  272.             var callFrame = InjectedScript._callFrameForId(callFrameId);
  273.             if (!callFrame)
  274.                 return props;
  275.             if (expression)
  276.                 expressionResult = InjectedScript._evaluateOn(callFrame.evaluate, callFrame, expression, true);
  277.             else {
  278.                 // Evaluate into properties in scope of the selected call frame.
  279.                 var scopeChain = callFrame.scopeChain;
  280.                 for (var i = 0; i < scopeChain.length; ++i)
  281.                     InjectedScript._populatePropertyNames(scopeChain[i], props);
  282.             }
  283.         } else {
  284.             if (!expression)
  285.                 expression = "this";
  286.             expressionResult = InjectedScript._evaluateOn(inspectedWindow.eval, inspectedWindow, expression);
  287.         }
  288.         if (typeof expressionResult == "object")
  289.             InjectedScript._populatePropertyNames(expressionResult, props);
  290.         if (includeInspectorCommandLineAPI)
  291.             for (var prop in inspectedWindow.console._inspectorCommandLineAPI)
  292.                 if (prop.charAt(0) !== '_')
  293.                     props[prop] = true;
  294.     } catch(e) {
  295.     }
  296.     return props;
  297. }
  298.  
  299. InjectedScript.evaluate = function(expression, objectGroup)
  300. {
  301.     return InjectedScript._evaluateAndWrap(inspectedWindow.eval, inspectedWindow, expression, objectGroup);
  302. }
  303.  
  304. InjectedScript._evaluateAndWrap = function(evalFunction, object, expression, objectGroup, dontUseCommandLineAPI)
  305. {
  306.     var result = {};
  307.     try {
  308.         result.value = InjectedScript.wrapObject(InjectedScript._evaluateOn(evalFunction, object, expression, dontUseCommandLineAPI), objectGroup);
  309.  
  310.         // Handle error that might have happened while describing result.
  311.         if (result.value.errorText) {
  312.             result.value = result.value.errorText;
  313.             result.isException = true;
  314.         }
  315.     } catch (e) {
  316.         result.value = e.toString();
  317.         result.isException = true;
  318.     }
  319.     return result;
  320. }
  321.  
  322. InjectedScript._evaluateOn = function(evalFunction, object, expression, dontUseCommandLineAPI)
  323. {
  324.     InjectedScript._ensureCommandLineAPIInstalled(evalFunction, object);
  325.     // Surround the expression in with statements to inject our command line API so that
  326.     // the window object properties still take more precedent than our API functions.
  327.     if (!dontUseCommandLineAPI)
  328.         expression = "with (window.console._inspectorCommandLineAPI) { with (window) {\n" + expression + "\n} }";
  329.  
  330.     var value = evalFunction.call(object, expression);
  331.  
  332.     // When evaluating on call frame error is not thrown, but returned as a value.
  333.     if (InjectedScript._type(value) === "error")
  334.         throw value.toString();
  335.  
  336.     return value;
  337. }
  338.  
  339. InjectedScript.addInspectedNode = function(nodeId)
  340. {
  341.     var node = InjectedScript._nodeForId(nodeId);
  342.     if (!node)
  343.         return false;
  344.  
  345.     InjectedScript._ensureCommandLineAPIInstalled(inspectedWindow.eval, inspectedWindow);
  346.     var inspectedNodes = inspectedWindow.console._inspectorCommandLineAPI._inspectedNodes;
  347.     inspectedNodes.unshift(node);
  348.     if (inspectedNodes.length >= 5)
  349.         inspectedNodes.pop();
  350.     return true;
  351. }
  352.  
  353. InjectedScript.getNodeId = function(node)
  354. {
  355.     return InjectedScriptHost.pushNodePathToFrontend(node, false, false);
  356. }
  357.  
  358. InjectedScript.performSearch = function(whitespaceTrimmedQuery, runSynchronously)
  359. {
  360.     // FIXME: Few things are missing here:
  361.     // 1) Search works with node granularity - number of matches within node is not calculated.
  362.     // 2) Search does not work outside main documents' domain - we need to use specific InjectedScript instances
  363.     //    for other domains.
  364.     // 3) There is no need to push all search results to the front-end at a time, pushing next / previous result
  365.     //    is sufficient.
  366.     var tagNameQuery = whitespaceTrimmedQuery;
  367.     var attributeNameQuery = whitespaceTrimmedQuery;
  368.     var startTagFound = (tagNameQuery.indexOf("<") === 0);
  369.     var endTagFound = (tagNameQuery.lastIndexOf(">") === (tagNameQuery.length - 1));
  370.  
  371.     if (startTagFound || endTagFound) {
  372.         var tagNameQueryLength = tagNameQuery.length;
  373.         tagNameQuery = tagNameQuery.substring((startTagFound ? 1 : 0), (endTagFound ? (tagNameQueryLength - 1) : tagNameQueryLength));
  374.     }
  375.  
  376.     // Check the tagNameQuery is it is a possibly valid tag name.
  377.     if (!/^[a-zA-Z0-9\-_:]+$/.test(tagNameQuery))
  378.         tagNameQuery = null;
  379.  
  380.     // Check the attributeNameQuery is it is a possibly valid tag name.
  381.     if (!/^[a-zA-Z0-9\-_:]+$/.test(attributeNameQuery))
  382.         attributeNameQuery = null;
  383.  
  384.     const escapedQuery = InjectedScript._escapeCharacters(whitespaceTrimmedQuery, "'");
  385.     const escapedTagNameQuery = (tagNameQuery ?  InjectedScript._escapeCharacters(tagNameQuery, "'") : null);
  386.     const escapedWhitespaceTrimmedQuery = InjectedScript._escapeCharacters(whitespaceTrimmedQuery, "'");
  387.     const searchResultsProperty = InjectedScript._includedInSearchResultsPropertyName;
  388.  
  389.     function addNodesToResults(nodes, length, getItem)
  390.     {
  391.         if (!length)
  392.             return;
  393.  
  394.         var nodeIds = [];
  395.         for (var i = 0; i < length; ++i) {
  396.             var node = getItem.call(nodes, i);
  397.             // Skip this node if it already has the property.
  398.             if (searchResultsProperty in node)
  399.                 continue;
  400.  
  401.             if (!InjectedScript._searchResults.length) {
  402.                 InjectedScript._currentSearchResultIndex = 0;
  403.             }
  404.  
  405.             node[searchResultsProperty] = true;
  406.             InjectedScript._searchResults.push(node);
  407.             var nodeId = InjectedScriptHost.pushNodePathToFrontend(node, false, false);
  408.             nodeIds.push(nodeId);
  409.         }
  410.         InjectedScriptHost.addNodesToSearchResult(nodeIds.join(","));
  411.     }
  412.  
  413.     function matchExactItems(doc)
  414.     {
  415.         matchExactId.call(this, doc);
  416.         matchExactClassNames.call(this, doc);
  417.         matchExactTagNames.call(this, doc);
  418.         matchExactAttributeNames.call(this, doc);
  419.     }
  420.  
  421.     function matchExactId(doc)
  422.     {
  423.         const result = doc.__proto__.getElementById.call(doc, whitespaceTrimmedQuery);
  424.         addNodesToResults.call(this, result, (result ? 1 : 0), function() { return this });
  425.     }
  426.  
  427.     function matchExactClassNames(doc)
  428.     {
  429.         const result = doc.__proto__.getElementsByClassName.call(doc, whitespaceTrimmedQuery);
  430.         addNodesToResults.call(this, result, result.length, result.item);
  431.     }
  432.  
  433.     function matchExactTagNames(doc)
  434.     {
  435.         if (!tagNameQuery)
  436.             return;
  437.         const result = doc.__proto__.getElementsByTagName.call(doc, tagNameQuery);
  438.         addNodesToResults.call(this, result, result.length, result.item);
  439.     }
  440.  
  441.     function matchExactAttributeNames(doc)
  442.     {
  443.         if (!attributeNameQuery)
  444.             return;
  445.         const result = doc.__proto__.querySelectorAll.call(doc, "[" + attributeNameQuery + "]");
  446.         addNodesToResults.call(this, result, result.length, result.item);
  447.     }
  448.  
  449.     function matchPartialTagNames(doc)
  450.     {
  451.         if (!tagNameQuery)
  452.             return;
  453.         const result = doc.__proto__.evaluate.call(doc, "//*[contains(name(), '" + escapedTagNameQuery + "')]", doc, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
  454.         addNodesToResults.call(this, result, result.snapshotLength, result.snapshotItem);
  455.     }
  456.  
  457.     function matchStartOfTagNames(doc)
  458.     {
  459.         if (!tagNameQuery)
  460.             return;
  461.         const result = doc.__proto__.evaluate.call(doc, "//*[starts-with(name(), '" + escapedTagNameQuery + "')]", doc, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
  462.         addNodesToResults.call(this, result, result.snapshotLength, result.snapshotItem);
  463.     }
  464.  
  465.     function matchPartialTagNamesAndAttributeValues(doc)
  466.     {
  467.         if (!tagNameQuery) {
  468.             matchPartialAttributeValues.call(this, doc);
  469.             return;
  470.         }
  471.  
  472.         const result = doc.__proto__.evaluate.call(doc, "//*[contains(name(), '" + escapedTagNameQuery + "') or contains(@*, '" + escapedQuery + "')]", doc, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
  473.         addNodesToResults.call(this, result, result.snapshotLength, result.snapshotItem);
  474.     }
  475.  
  476.     function matchPartialAttributeValues(doc)
  477.     {
  478.         const result = doc.__proto__.evaluate.call(doc, "//*[contains(@*, '" + escapedQuery + "')]", doc, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
  479.         addNodesToResults.call(this, result, result.snapshotLength, result.snapshotItem);
  480.     }
  481.  
  482.     function matchStyleSelector(doc)
  483.     {
  484.         const result = doc.__proto__.querySelectorAll.call(doc, whitespaceTrimmedQuery);
  485.         addNodesToResults.call(this, result, result.length, result.item);
  486.     }
  487.  
  488.     function matchPlainText(doc)
  489.     {
  490.         const result = doc.__proto__.evaluate.call(doc, "//text()[contains(., '" + escapedQuery + "')] | //comment()[contains(., '" + escapedQuery + "')]", doc, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
  491.         addNodesToResults.call(this, result, result.snapshotLength, result.snapshotItem);
  492.     }
  493.  
  494.     function matchXPathQuery(doc)
  495.     {
  496.         const result = doc.__proto__.evaluate.call(doc, whitespaceTrimmedQuery, doc, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
  497.         addNodesToResults.call(this, result, result.snapshotLength, result.snapshotItem);
  498.     }
  499.  
  500.     function finishedSearching()
  501.     {
  502.         // Remove the searchResultsProperty now that the search is finished.
  503.         for (var i = 0; i < InjectedScript._searchResults.length; ++i)
  504.             delete InjectedScript._searchResults[i][searchResultsProperty];
  505.     }
  506.  
  507.     const mainFrameDocument = inspectedWindow.document;
  508.     const searchDocuments = [mainFrameDocument];
  509.     var searchFunctions;
  510.     if (tagNameQuery && startTagFound && endTagFound)
  511.         searchFunctions = [matchExactTagNames, matchPlainText];
  512.     else if (tagNameQuery && startTagFound)
  513.         searchFunctions = [matchStartOfTagNames, matchPlainText];
  514.     else if (tagNameQuery && endTagFound) {
  515.         // FIXME: we should have a matchEndOfTagNames search function if endTagFound is true but not startTagFound.
  516.         // This requires ends-with() support in XPath, WebKit only supports starts-with() and contains().
  517.         searchFunctions = [matchPartialTagNames, matchPlainText];
  518.     } else if (whitespaceTrimmedQuery === "//*" || whitespaceTrimmedQuery === "*") {
  519.         // These queries will match every node. Matching everything isn't useful and can be slow for large pages,
  520.         // so limit the search functions list to plain text and attribute matching.
  521.         searchFunctions = [matchPartialAttributeValues, matchPlainText];
  522.     } else
  523.         searchFunctions = [matchExactItems, matchStyleSelector, matchPartialTagNamesAndAttributeValues, matchPlainText, matchXPathQuery];
  524.  
  525.     // Find all frames, iframes and object elements to search their documents.
  526.     const subdocumentResult = mainFrameDocument.querySelectorAll("iframe, frame, object");
  527.  
  528.     for (var i = 0; i < subdocumentResult.length; ++i) {
  529.         var element = subdocumentResult.item(i);
  530.         if (element.contentDocument)
  531.             searchDocuments.push(element.contentDocument);
  532.     }
  533.  
  534.     const panel = InjectedScript;
  535.     var documentIndex = 0;
  536.     var searchFunctionIndex = 0;
  537.     var chunkIntervalIdentifier = null;
  538.  
  539.     // Split up the work into chunks so we don't block the UI thread while processing.
  540.  
  541.     function processChunk()
  542.     {
  543.         var searchDocument = searchDocuments[documentIndex];
  544.         var searchFunction = searchFunctions[searchFunctionIndex];
  545.  
  546.         if (++searchFunctionIndex > searchFunctions.length) {
  547.             searchFunction = searchFunctions[0];
  548.             searchFunctionIndex = 0;
  549.  
  550.             if (++documentIndex > searchDocuments.length) {
  551.                 if (panel._currentSearchChunkIntervalIdentifier === chunkIntervalIdentifier)
  552.                     delete panel._currentSearchChunkIntervalIdentifier;
  553.                 clearInterval(chunkIntervalIdentifier);
  554.                 finishedSearching.call(panel);
  555.                 return false;
  556.             }
  557.  
  558.             searchDocument = searchDocuments[documentIndex];
  559.         }
  560.  
  561.         try {
  562.             searchFunction.call(panel, searchDocument);
  563.         } catch(err) {
  564.             // ignore any exceptions. the query might be malformed, but we allow that.
  565.         }
  566.         return true;
  567.     }
  568.  
  569.     if (runSynchronously)
  570.         while (processChunk()) {}
  571.     else {
  572.         processChunk();
  573.         chunkIntervalIdentifier = setInterval(processChunk, 25);
  574.         InjectedScript._currentSearchChunkIntervalIdentifier = chunkIntervalIdentifier;
  575.     }
  576.     return true;
  577. }
  578.  
  579. InjectedScript.searchCanceled = function()
  580. {
  581.     if (InjectedScript._searchResults) {
  582.         const searchResultsProperty = InjectedScript._includedInSearchResultsPropertyName;
  583.         for (var i = 0; i < this._searchResults.length; ++i) {
  584.             var node = this._searchResults[i];
  585.  
  586.             // Remove the searchResultsProperty since there might be an unfinished search.
  587.             delete node[searchResultsProperty];
  588.         }
  589.     }
  590.  
  591.     if (InjectedScript._currentSearchChunkIntervalIdentifier) {
  592.         clearInterval(InjectedScript._currentSearchChunkIntervalIdentifier);
  593.         delete InjectedScript._currentSearchChunkIntervalIdentifier;
  594.     }
  595.     InjectedScript._searchResults = [];
  596.     return true;
  597. }
  598.  
  599. InjectedScript.openInInspectedWindow = function(url)
  600. {
  601.     // Don't call window.open on wrapper - popup blocker mutes it.
  602.     // URIs should have no double quotes.
  603.     inspectedWindow.eval("window.open(\"" + url + "\")");
  604.     return true;
  605. }
  606.  
  607. InjectedScript.callFrames = function()
  608. {
  609.     var callFrame = InjectedScriptHost.currentCallFrame();
  610.     if (!callFrame)
  611.         return false;
  612.  
  613.     var result = [];
  614.     var depth = 0;
  615.     do {
  616.         result.push(new InjectedScript.CallFrameProxy(depth++, callFrame));
  617.         callFrame = callFrame.caller;
  618.     } while (callFrame);
  619.     return result;
  620. }
  621.  
  622. InjectedScript.evaluateInCallFrame = function(callFrameId, code, objectGroup)
  623. {
  624.     var callFrame = InjectedScript._callFrameForId(callFrameId);
  625.     if (!callFrame)
  626.         return false;
  627.     return InjectedScript._evaluateAndWrap(callFrame.evaluate, callFrame, code, objectGroup, true);
  628. }
  629.  
  630. InjectedScript._callFrameForId = function(id)
  631. {
  632.     var callFrame = InjectedScriptHost.currentCallFrame();
  633.     while (--id >= 0 && callFrame)
  634.         callFrame = callFrame.caller;
  635.     return callFrame;
  636. }
  637.  
  638. InjectedScript.clearConsoleMessages = function()
  639. {
  640.     InjectedScriptHost.clearConsoleMessages();
  641.     return true;
  642. }
  643.  
  644. InjectedScript._inspectObject = function(o)
  645. {
  646.     if (arguments.length === 0)
  647.         return;
  648.  
  649.     inspectedWindow.console.log(o);
  650.     if (InjectedScript._type(o) === "node") {
  651.         InjectedScriptHost.pushNodePathToFrontend(o, false, true);
  652.     } else {
  653.         switch (InjectedScript._describe(o)) {
  654.             case "Database":
  655.                 InjectedScriptHost.selectDatabase(o);
  656.                 break;
  657.             case "Storage":
  658.                 InjectedScriptHost.selectDOMStorage(o);
  659.                 break;
  660.         }
  661.     }
  662. }
  663.  
  664. InjectedScript._copy = function(o)
  665. {
  666.     if (InjectedScript._type(o) === "node") {
  667.         var nodeId = InjectedScriptHost.pushNodePathToFrontend(o, false, false);
  668.         InjectedScriptHost.copyNode(nodeId);
  669.     } else {
  670.         InjectedScriptHost.copyText(o);
  671.     }
  672. }
  673.  
  674. InjectedScript._ensureCommandLineAPIInstalled = function(evalFunction, evalObject)
  675. {
  676.     if (evalFunction.call(evalObject, "window.console._inspectorCommandLineAPI"))
  677.         return;
  678.     var inspectorCommandLineAPI = evalFunction.call(evalObject, "window.console._inspectorCommandLineAPI = { \n\
  679.         $: function() { return document.getElementById.apply(document, arguments) }, \n\
  680.         $$: function() { return document.querySelectorAll.apply(document, arguments) }, \n\
  681.         $x: function(xpath, context) \n\
  682.         { \n\
  683.             var nodes = []; \n\
  684.             try { \n\
  685.                 var doc = context || document; \n\
  686.                 var results = doc.evaluate(xpath, doc, null, XPathResult.ANY_TYPE, null); \n\
  687.                 var node; \n\
  688.                 while (node = results.iterateNext()) nodes.push(node); \n\
  689.             } catch (e) {} \n\
  690.             return nodes; \n\
  691.         }, \n\
  692.         dir: function() { return console.dir.apply(console, arguments) }, \n\
  693.         dirxml: function() { return console.dirxml.apply(console, arguments) }, \n\
  694.         keys: function(o) { var a = []; for (var k in o) a.push(k); return a; }, \n\
  695.         values: function(o) { var a = []; for (var k in o) a.push(o[k]); return a; }, \n\
  696.         profile: function() { return console.profile.apply(console, arguments) }, \n\
  697.         profileEnd: function() { return console.profileEnd.apply(console, arguments) }, \n\
  698.         _logEvent: function _inspectorCommandLineAPI_logEvent(e) { console.log(e.type, e); }, \n\
  699.         _allEventTypes: [\"mouse\", \"key\", \"load\", \"unload\", \"abort\", \"error\", \n\
  700.             \"select\", \"change\", \"submit\", \"reset\", \"focus\", \"blur\", \n\
  701.             \"resize\", \"scroll\"], \n\
  702.         _normalizeEventTypes: function(t) \n\
  703.         { \n\
  704.             if (typeof t === \"undefined\") \n\
  705.                 t = console._inspectorCommandLineAPI._allEventTypes; \n\
  706.             else if (typeof t === \"string\") \n\
  707.                 t = [t]; \n\
  708.             var i, te = []; \n\
  709.             for (i = 0; i < t.length; i++) { \n\
  710.                 if (t[i] === \"mouse\") \n\
  711.                     te.splice(0, 0, \"mousedown\", \"mouseup\", \"click\", \"dblclick\", \n\
  712.                         \"mousemove\", \"mouseover\", \"mouseout\"); \n\
  713.                 else if (t[i] === \"key\") \n\
  714.                     te.splice(0, 0, \"keydown\", \"keyup\", \"keypress\"); \n\
  715.                 else \n\
  716.                     te.push(t[i]); \n\
  717.             } \n\
  718.             return te; \n\
  719.         }, \n\
  720.         monitorEvents: function(o, t) \n\
  721.         { \n\
  722.             if (!o || !o.addEventListener || !o.removeEventListener) \n\
  723.                 return; \n\
  724.             t = console._inspectorCommandLineAPI._normalizeEventTypes(t); \n\
  725.             for (i = 0; i < t.length; i++) { \n\
  726.                 o.removeEventListener(t[i], console._inspectorCommandLineAPI._logEvent, false); \n\
  727.                 o.addEventListener(t[i], console._inspectorCommandLineAPI._logEvent, false); \n\
  728.             } \n\
  729.         }, \n\
  730.         unmonitorEvents: function(o, t) \n\
  731.         { \n\
  732.             if (!o || !o.removeEventListener) \n\
  733.                 return; \n\
  734.             t = console._inspectorCommandLineAPI._normalizeEventTypes(t); \n\
  735.             for (i = 0; i < t.length; i++) { \n\
  736.                 o.removeEventListener(t[i], console._inspectorCommandLineAPI._logEvent, false); \n\
  737.             } \n\
  738.         }, \n\
  739.         _inspectedNodes: [], \n\
  740.         get $0() { return console._inspectorCommandLineAPI._inspectedNodes[0] }, \n\
  741.         get $1() { return console._inspectorCommandLineAPI._inspectedNodes[1] }, \n\
  742.         get $2() { return console._inspectorCommandLineAPI._inspectedNodes[2] }, \n\
  743.         get $3() { return console._inspectorCommandLineAPI._inspectedNodes[3] }, \n\
  744.         get $4() { return console._inspectorCommandLineAPI._inspectedNodes[4] }, \n\
  745.     };");
  746.  
  747.     inspectorCommandLineAPI.clear = InjectedScript.clearConsoleMessages;
  748.     inspectorCommandLineAPI.inspect = InjectedScript._inspectObject;
  749.     inspectorCommandLineAPI.copy = InjectedScript._copy;
  750. }
  751.  
  752. InjectedScript._resolveObject = function(objectProxy)
  753. {
  754.     var object = InjectedScript._objectForId(objectProxy.objectId);
  755.     var path = objectProxy.path;
  756.     var protoDepth = objectProxy.protoDepth;
  757.  
  758.     // Follow the property path.
  759.     for (var i = 0; InjectedScript._isDefined(object) && path && i < path.length; ++i)
  760.         object = object[path[i]];
  761.  
  762.     return object;
  763. }
  764.  
  765. InjectedScript._nodeForId = function(nodeId)
  766. {
  767.     if (!nodeId)
  768.         return null;
  769.     return InjectedScriptHost.nodeForId(nodeId);
  770. }
  771.  
  772. InjectedScript._objectForId = function(objectId)
  773. {
  774.     // There are three types of object ids used:
  775.     // - numbers point to DOM Node via the InspectorDOMAgent mapping
  776.     // - strings point to console objects cached in InspectorController for lazy evaluation upon them
  777.     // - objects contain complex ids and are currently used for scoped objects
  778.     if (typeof objectId === "number") {
  779.         return InjectedScript._nodeForId(objectId);
  780.     } else if (typeof objectId === "string") {
  781.         return InjectedScript.unwrapObject(objectId);
  782.     } else if (typeof objectId === "object") {
  783.         var callFrame = InjectedScript._callFrameForId(objectId.callFrame);
  784.         if (objectId.thisObject)
  785.             return callFrame.thisObject;
  786.         else
  787.             return callFrame.scopeChain[objectId.chainIndex];
  788.     }
  789.     return objectId;
  790. }
  791.  
  792. InjectedScript.pushNodeToFrontend = function(objectProxy)
  793. {
  794.     var object = InjectedScript._resolveObject(objectProxy);
  795.     if (!object || InjectedScript._type(object) !== "node")
  796.         return false;
  797.     return InjectedScriptHost.pushNodePathToFrontend(object, false, false);
  798. }
  799.  
  800. InjectedScript.nodeByPath = function(path)
  801. {
  802.     // We make this call through the injected script only to get a nice
  803.     // callback for it.
  804.     return InjectedScriptHost.pushNodeByPathToFrontend(path.join(","));
  805. }
  806.  
  807. // Called from within InspectorController on the 'inspected page' side.
  808. InjectedScript.createProxyObject = function(object, objectId, abbreviate)
  809. {
  810.     var result = {};
  811.     result.injectedScriptId = injectedScriptId;
  812.     result.objectId = objectId;
  813.     result.type = InjectedScript._type(object);
  814.     if (result.type === "array")
  815.         result.propertyLength = object.length;
  816.  
  817.     var type = typeof object;
  818.     
  819.     result.hasChildren = (type === "object" && object !== null && (Object.getOwnPropertyNames(object).length || object.__proto__)) || type === "function";
  820.     try {
  821.         result.description = InjectedScript._describe(object, abbreviate);
  822.     } catch (e) {
  823.         result.errorText = e.toString();
  824.     }
  825.     return result;
  826. }
  827.  
  828. InjectedScript.evaluateOnSelf = function(funcBody, args)
  829. {
  830.     var func = window.eval("(" + funcBody + ")");
  831.     return func.apply(this, args || []);
  832. }
  833.  
  834. InjectedScript.CallFrameProxy = function(id, callFrame)
  835. {
  836.     this.id = id;
  837.     this.type = callFrame.type;
  838.     this.functionName = (this.type === "function" ? callFrame.functionName : "");
  839.     this.sourceID = callFrame.sourceID;
  840.     this.line = callFrame.line;
  841.     this.scopeChain = this._wrapScopeChain(callFrame);
  842. }
  843.  
  844. InjectedScript.CallFrameProxy.prototype = {
  845.     _wrapScopeChain: function(callFrame)
  846.     {
  847.         const GLOBAL_SCOPE = 0;
  848.         const LOCAL_SCOPE = 1;
  849.         const WITH_SCOPE = 2;
  850.         const CLOSURE_SCOPE = 3;
  851.         const CATCH_SCOPE = 4;
  852.     
  853.         var scopeChain = callFrame.scopeChain;
  854.         var scopeChainProxy = [];
  855.         var foundLocalScope = false;
  856.         for (var i = 0; i < scopeChain.length; i++) {
  857.             var scopeType = callFrame.scopeType(i);
  858.             var scopeObject = scopeChain[i];
  859.             var scopeObjectProxy = InjectedScript.createProxyObject(scopeObject, { callFrame: this.id, chainIndex: i }, true);
  860.  
  861.             switch(scopeType) {
  862.                 case LOCAL_SCOPE: {
  863.                     foundLocalScope = true;
  864.                     scopeObjectProxy.isLocal = true;
  865.                     scopeObjectProxy.thisObject = InjectedScript.createProxyObject(callFrame.thisObject, { callFrame: this.id, thisObject: true }, true);
  866.                     break;
  867.                 }
  868.                 case CLOSURE_SCOPE: {
  869.                     scopeObjectProxy.isClosure = true;
  870.                     break;
  871.                 }
  872.                 case WITH_SCOPE:
  873.                 case CATCH_SCOPE: {
  874.                     if (foundLocalScope && scopeObject instanceof inspectedWindow.Element)
  875.                         scopeObjectProxy.isElement = true;
  876.                     else if (foundLocalScope && scopeObject instanceof inspectedWindow.Document)
  877.                         scopeObjectProxy.isDocument = true;
  878.                     else
  879.                         scopeObjectProxy.isWithBlock = true;
  880.                     break;
  881.                 }
  882.             }
  883.             scopeChainProxy.push(scopeObjectProxy);
  884.         }
  885.         return scopeChainProxy;
  886.     }
  887. }
  888.  
  889. InjectedScript.executeSql = function(callId, databaseId, query)
  890. {
  891.     function successCallback(tx, result)
  892.     {
  893.         var rows = result.rows;
  894.         var result = [];
  895.         var length = rows.length;
  896.         for (var i = 0; i < length; ++i) {
  897.             var data = {};
  898.             result.push(data);
  899.             var row = rows.item(i);
  900.             for (var columnIdentifier in row) {
  901.                 // FIXME: (Bug 19439) We should specially format SQL NULL here
  902.                 // (which is represented by JavaScript null here, and turned
  903.                 // into the string "null" by the String() function).
  904.                 var text = row[columnIdentifier];
  905.                 data[columnIdentifier] = String(text);
  906.             }
  907.         }
  908.         InjectedScriptHost.reportDidDispatchOnInjectedScript(callId, result, false);
  909.     }
  910.  
  911.     function errorCallback(tx, error)
  912.     {
  913.         InjectedScriptHost.reportDidDispatchOnInjectedScript(callId, error, false);
  914.     }
  915.  
  916.     function queryTransaction(tx)
  917.     {
  918.         tx.executeSql(query, null, successCallback, errorCallback);
  919.     }
  920.  
  921.     var database = InjectedScriptHost.databaseForId(databaseId);
  922.     if (!database)
  923.         errorCallback(null, { code : 2 });  // Return as unexpected version.
  924.     database.transaction(queryTransaction, errorCallback);
  925.     return true;
  926. }
  927.  
  928. InjectedScript._isDefined = function(object)
  929. {
  930.     return object || InjectedScript._isHTMLAllCollection(object);
  931. }
  932.  
  933. InjectedScript._isHTMLAllCollection = function(object)
  934. {
  935.     // document.all is reported as undefined, but we still want to process it.
  936.     return (typeof object === "undefined") && inspectedWindow.HTMLAllCollection && object instanceof inspectedWindow.HTMLAllCollection;
  937. }
  938.  
  939. InjectedScript._type = function(obj)
  940. {
  941.     if (obj === null)
  942.         return "null";
  943.  
  944.     var type = typeof obj;
  945.     if (type !== "object" && type !== "function") {
  946.         // FIXME(33716): typeof document.all is always 'undefined'.
  947.         if (InjectedScript._isHTMLAllCollection(obj))
  948.             return "array";
  949.         return type;
  950.     }
  951.  
  952.     // If owning frame has navigated to somewhere else window properties will be undefined.
  953.     // In this case just return result of the typeof.
  954.     if (!inspectedWindow.document)
  955.         return type;
  956.  
  957.     if (obj instanceof inspectedWindow.Node)
  958.         return (obj.nodeType === undefined ? type : "node");
  959.     if (obj instanceof inspectedWindow.String)
  960.         return "string";
  961.     if (obj instanceof inspectedWindow.Array)
  962.         return "array";
  963.     if (obj instanceof inspectedWindow.Boolean)
  964.         return "boolean";
  965.     if (obj instanceof inspectedWindow.Number)
  966.         return "number";
  967.     if (obj instanceof inspectedWindow.Date)
  968.         return "date";
  969.     if (obj instanceof inspectedWindow.RegExp)
  970.         return "regexp";
  971.     if (obj instanceof inspectedWindow.NodeList)
  972.         return "array";
  973.     if (obj instanceof inspectedWindow.HTMLCollection)
  974.         return "array";
  975.     if (obj instanceof inspectedWindow.Error)
  976.         return "error";
  977.     return type;
  978. }
  979.  
  980. InjectedScript._describe = function(obj, abbreviated)
  981. {
  982.     var type1 = InjectedScript._type(obj);
  983.     var type2 = InjectedScript._className(obj);
  984.  
  985.     switch (type1) {
  986.     case "object":
  987.     case "node":
  988.     case "array":
  989.         return type2;
  990.     case "string":
  991.         if (!abbreviated)
  992.             return obj;
  993.         if (obj.length > 100)
  994.             return "\"" + obj.substring(0, 100) + "\u2026\"";
  995.         return "\"" + obj + "\"";
  996.     case "function":
  997.         var objectText = InjectedScript._toString(obj);
  998.         if (!/^function /.test(objectText))
  999.             objectText = (type2 == "object") ? type1 : type2;
  1000.         else if (abbreviated)
  1001.             objectText = /.*/.exec(obj)[0].replace(/ +$/g, "");
  1002.         return objectText;
  1003.     default:
  1004.         return InjectedScript._toString(obj);
  1005.     }
  1006. }
  1007.  
  1008. InjectedScript._toString = function(obj)
  1009. {
  1010.     // We don't use String(obj) because inspectedWindow.String is undefined if owning frame navigated to another page.
  1011.     return "" + obj;
  1012. }
  1013.  
  1014. InjectedScript._className = function(obj)
  1015. {
  1016.     var str = inspectedWindow.Object ? inspectedWindow.Object.prototype.toString.call(obj) : InjectedScript._toString(obj);
  1017.     return str.replace(/^\[object (.*)\]$/i, "$1");
  1018. }
  1019.  
  1020. InjectedScript._escapeCharacters = function(str, chars)
  1021. {
  1022.     var foundChar = false;
  1023.     for (var i = 0; i < chars.length; ++i) {
  1024.         if (str.indexOf(chars.charAt(i)) !== -1) {
  1025.             foundChar = true;
  1026.             break;
  1027.         }
  1028.     }
  1029.  
  1030.     if (!foundChar)
  1031.         return str;
  1032.  
  1033.     var result = "";
  1034.     for (var i = 0; i < str.length; ++i) {
  1035.         if (chars.indexOf(str.charAt(i)) !== -1)
  1036.             result += "\\";
  1037.         result += str.charAt(i);
  1038.     }
  1039.  
  1040.     return result;
  1041. }
  1042.  
  1043. return InjectedScript;
  1044. });
  1045.