Roll reference builds to 35.0.1916.114.

chrome_linux64/resources/inspector/devtools_extension_api.js

 (function() {
     /*
  * Copyright (C) 2012 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 232 matching lines @@
     {
         function callbackWrapper(result)
         {
             var entries = (result && result.entries) || [];
             for (var i = 0; i < entries.length; ++i) {
                 entries[i].__proto__ = new Request(entries[i]._requestId);
                 delete entries[i]._requestId;
             }
             callback(result);
         }
-        return extensionServer.sendRequest({ command: commands.GetHAR }, callback && callbackWrapper);
+        extensionServer.sendRequest({ command: commands.GetHAR }, callback && callbackWrapper);
     },
 
     addRequestHeaders: function(headers)
     {
-        return extensionServer.sendRequest({ command: commands.AddRequestHeaders, headers: headers, extensionId: window.location.hostname });
+        extensionServer.sendRequest({ command: commands.AddRequestHeaders, headers: headers, extensionId: window.location.hostname });
     }
 }
 
 /**
  * @constructor
  */
 function RequestImpl(id)
 {
     this._id = id;
 }
@@ skipping 89 matching lines @@
      * @this {EventSinkImpl}
      */
     function dispatchShowEvent(message)
     {
         var frameIndex = message.arguments[0];
         if (typeof frameIndex === "number")
             this._fire(window.parent.frames[frameIndex]);
         else
             this._fire();
     }
-    this.onShown = new EventSink(events.ViewShown + id, dispatchShowEvent);
-    this.onHidden = new EventSink(events.ViewHidden + id);
+
+    if (id) {
+        this.onShown = new EventSink(events.ViewShown + id, dispatchShowEvent);
+        this.onHidden = new EventSink(events.ViewHidden + id);
+    }
 }
 
 /**
  * @constructor
  * @extends {ExtensionViewImpl}
+ * @param {string} hostPanelName
  */
 function PanelWithSidebarImpl(hostPanelName)
 {
+    ExtensionViewImpl.call(this, null);
     this._hostPanelName = hostPanelName;
     this.onSelectionChanged = new EventSink(events.PanelObjectSelected + hostPanelName);
 }
 
 PanelWithSidebarImpl.prototype = {
     createSidebarPane: function(title, callback)
     {
         var id = "extension-sidebar-" + extensionServer.nextObjectId();
         var request = {
             command: commands.CreateSidebarPane,
@@ skipping 82 matching lines @@
  * @constructor
  * @extends {ExtensionViewImpl}
  */
 function ExtensionPanelImpl(id)
 {
     ExtensionViewImpl.call(this, id);
     this.onSearch = new EventSink(events.PanelSearch + id);
 }
 
 ExtensionPanelImpl.prototype = {
+    /**
+     * @return {!Object}
+     */
     createStatusBarButton: function(iconPath, tooltipText, disabled)
     {
         var id = "button-" + extensionServer.nextObjectId();
         var request = {
             command: commands.CreateStatusBarButton,
             panel: this._id,
             id: id,
             icon: iconPath,
             tooltip: tooltipText,
             disabled: !!disabled
@@ skipping 83 matching lines @@
 };
 
 /**
  * @constructor
  */
 function Audits()
 {
 }
 
 Audits.prototype = {
+    /**
+     * @return {!AuditCategory}
+     */
     addCategory: function(displayName, resultCount)
     {
         var id = "extension-audit-category-" + extensionServer.nextObjectId();
         if (typeof resultCount !== "undefined")
             console.warn("Passing resultCount to audits.addCategory() is deprecated. Use AuditResult.updateProgress() instead.");
         extensionServer.sendRequest({ command: commands.AddAuditCategory, id: id, displayName: displayName, resultCount: resultCount });
         return new AuditCategory(id);
     }
 }
 
@@ skipping 19 matching lines @@
     this.onAuditStarted = new EventSink(events.AuditStarted + id, dispatchAuditEvent);
 }
 
 /**
  * @constructor
  */
 function AuditResultImpl(id)
 {
     this._id = id;
 
-    this.createURL = this._nodeFactory.bind(null, "url");
-    this.createSnippet = this._nodeFactory.bind(null, "snippet");
-    this.createText = this._nodeFactory.bind(null, "text");
-    this.createObject = this._nodeFactory.bind(null, "object");
-    this.createNode = this._nodeFactory.bind(null, "node");
+    this.createURL = this._nodeFactory.bind(this, "url");
+    this.createSnippet = this._nodeFactory.bind(this, "snippet");
+    this.createText = this._nodeFactory.bind(this, "text");
+    this.createObject = this._nodeFactory.bind(this, "object");
+    this.createNode = this._nodeFactory.bind(this, "node");
 }
 
 AuditResultImpl.prototype = {
     addResult: function(displayName, description, severity, details)
     {
         // shorthand for specifying details directly in addResult().
         if (details && !(details instanceof AuditResultNode))
             details = new AuditResultNode(details instanceof Array ? details : [details]);
 
         var request = {
             command: commands.AddAuditResult,
             resultId: this._id,
             displayName: displayName,
             description: description,
             severity: severity,
             details: details
         };
         extensionServer.sendRequest(request);
     },
 
+    /**
+     * @return {!Object}
+     */
     createResult: function()
     {
         return new AuditResultNode(Array.prototype.slice.call(arguments));
     },
 
     updateProgress: function(worked, totalWork)
     {
         extensionServer.sendRequest({ command: commands.UpdateAuditProgress, resultId: this._id, progress: worked / totalWork });
     },
 
     done: function()
     {
         extensionServer.sendRequest({ command: commands.StopAuditCategoryRun, resultId: this._id });
     },
 
+    /**
+     * @type {!Object.<string, string>}
+     */
     get Severity()
     {
         return apiPrivate.audits.Severity;
     },
 
+    /**
+     * @return {!{type: string, arguments: !Array.<string|number>}}
+     */
     createResourceLink: function(url, lineNumber)
     {
         return {
             type: "resourceLink",
             arguments: [url, lineNumber && lineNumber - 1]
         };
     },
 
+    /**
+     * @return {!{type: string, arguments: !Array.<string|number>}}
+     */
     _nodeFactory: function(type)
     {
         return {
             type: type,
             arguments: Array.prototype.slice.call(arguments, 1)
         };
     }
 }
 
 /**
  * @constructor
  */
 function AuditResultNode(contents)
 {
     this.contents = contents;
     this.children = [];
     this.expanded = false;
 }
 
 AuditResultNode.prototype = {
+    /**
+     * @return {!Object}
+     */
     addChild: function()
     {
         var node = new AuditResultNode(Array.prototype.slice.call(arguments));
         this.children.push(node);
         return node;
     }
 };
 
 /**
  * @constructor
@@ skipping 24 matching lines @@
     reload: function(optionsOrUserAgent)
     {
         var options = null;
         if (typeof optionsOrUserAgent === "object")
             options = optionsOrUserAgent;
         else if (typeof optionsOrUserAgent === "string") {
             options = { userAgent: optionsOrUserAgent };
             console.warn("Passing userAgent as string parameter to inspectedWindow.reload() is deprecated. " +
                          "Use inspectedWindow.reload({ userAgent: value}) instead.");
         }
-        return extensionServer.sendRequest({ command: commands.Reload, options: options });
+        extensionServer.sendRequest({ command: commands.Reload, options: options });
     },
 
+    /**
+     * @return {?Object}
+     */
     eval: function(expression, evaluateOptions)
     {
         var callback = extractCallbackArgument(arguments);
         function callbackWrapper(result)
         {
             if (result.isError || result.isException)
                 callback(undefined, result);
             else
                 callback(result.value);
         }
         var request = {
             command: commands.EvaluateOnInspectedPage,
             expression: expression
         };
         if (typeof evaluateOptions === "object")
             request.evaluateOptions = evaluateOptions;
-        return extensionServer.sendRequest(request, callback && callbackWrapper);
+        extensionServer.sendRequest(request, callback && callbackWrapper);
+        return null;
     },
 
     getResources: function(callback)
     {
         function wrapResource(resourceData)
         {
             return new Resource(resourceData);
         }
         function callbackWrapper(resources)
         {
             callback(resources.map(wrapResource));
         }
-        return extensionServer.sendRequest({ command: commands.GetPageResources }, callback && callbackWrapper);
+        extensionServer.sendRequest({ command: commands.GetPageResources }, callback && callbackWrapper);
     }
 }
 
 /**
  * @constructor
  */
 function ResourceImpl(resourceData)
 {
     this._url = resourceData.url
     this._type = resourceData.type;
@@ skipping 10 matching lines @@
         return this._type;
     },
 
     getContent: function(callback)
     {
         function callbackWrapper(response)
         {
             callback(response.content, response.encoding);
         }
 
-        return extensionServer.sendRequest({ command: commands.GetResourceContent, url: this._url }, callback && callbackWrapper);
+        extensionServer.sendRequest({ command: commands.GetResourceContent, url: this._url }, callback && callbackWrapper);
     },
 
     setContent: function(content, commit, callback)
     {
-        return extensionServer.sendRequest({ command: commands.SetResourceContent, url: this._url, content: content, commit: commit }, callback);
+        extensionServer.sendRequest({ command: commands.SetResourceContent, url: this._url, content: content, commit: commit }, callback);
     }
 }
 
 /**
  * @constructor
  */
 function TimelineImpl()
 {
     this.onEventRecorded = new EventSink(events.TimelineEventRecorded);
 }
 
+var keyboardEventRequestQueue = [];
+var forwardTimer = null;
+
 function forwardKeyboardEvent(event)
 {
     const Esc = "U+001B";
     // We only care about global hotkeys, not about random text
     if (!event.ctrlKey && !event.altKey && !event.metaKey && !/^F\d+$/.test(event.keyIdentifier) && event.keyIdentifier !== Esc)
         return;
-    var request = {
-        command: commands.ForwardKeyboardEvent,
+    var requestPayload = {
         eventType: event.type,
         ctrlKey: event.ctrlKey,
         altKey: event.altKey,
         metaKey: event.metaKey,
         keyIdentifier: event.keyIdentifier,
-        location: event.location
+        location: event.location,
+        keyCode: event.keyCode
+    };
+    keyboardEventRequestQueue.push(requestPayload);
+    if (!forwardTimer)
+        forwardTimer = setTimeout(forwardEventQueue, 0);
+}
+
+function forwardEventQueue()
+{
+    forwardTimer = null;
+    var request = {
+        command: commands.ForwardKeyboardEvent,
+        entries: keyboardEventRequestQueue
     };
     extensionServer.sendRequest(request);
+    keyboardEventRequestQueue = [];
 }
 
 document.addEventListener("keydown", forwardKeyboardEvent, false);
 document.addEventListener("keypress", forwardKeyboardEvent, false);
 
 /**
  * @constructor
  */
 function ExtensionServerClient()
 {
@@ skipping 13 matching lines @@
 }
 
 ExtensionServerClient.prototype = {
     /**
      * @param {function()=} callback
      */
     sendRequest: function(message, callback)
     {
         if (typeof callback === "function")
             message.requestId = this._registerCallback(callback);
-        return this._port.postMessage(message);
+        this._port.postMessage(message);
     },
 
+    /**
+     * @return {boolean}
+     */
     hasHandler: function(command)
     {
         return !!this._handlers[command];
     },
 
     registerHandler: function(command, handler)
     {
         this._handlers[command] = handler;
     },
 
     unregisterHandler: function(command)
     {
         delete this._handlers[command];
     },
 
+    /**
+     * @return {string}
+     */
     nextObjectId: function()
     {
         return injectedScriptId + "_" + ++this._lastObjectId;
     },
 
     _registerCallback: function(callback)
     {
         var id = ++this._lastRequestId;
         this._callbacks[id] = callback;
         return id;
@@ skipping 38 matching lines @@
 }
 
 // extensionServer is a closure variable defined by the glue below -- make sure we fail if it's not there.
 if (!extensionServer)
     extensionServer = new ExtensionServerClient();
 
 return new InspectorExtensionAPI();
 }
 
 /**
- * @param {!ExtensionDescriptor} extensionInfo
- * @return {string}
+ * @suppress {checkVars, checkTypes}
  */
-function buildExtensionAPIInjectedScript(extensionInfo)
-{
-    return "(function(injectedScriptId){ " +
-        "var extensionServer;" +
-        defineCommonExtensionSymbols.toString() + ";" +
-        injectedExtensionAPI.toString() + ";" +
-        buildPlatformExtensionAPI(extensionInfo) + ";" +
-        "platformExtensionAPI(injectedExtensionAPI(injectedScriptId));" +
-        "return {};" +
-        "})";
-}
-/*
- * Copyright (C) 2011 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:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 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.
- */
-
 function platformExtensionAPI(coreAPI)
 {
     function getTabId()
     {
         return tabId;
     }
     chrome = window.chrome || {};
     // Override chrome.devtools as a workaround for a error-throwing getter being exposed
     // in extension pages loaded into a non-extension process (only happens for remote client
     // extensions)
@@ skipping 16 matching lines @@
         for (var i = 0; i < properties.length; ++i) {
             var descriptor = Object.getOwnPropertyDescriptor(coreAPI, properties[i]);
             Object.defineProperty(chrome.experimental.devtools, properties[i], descriptor);
         }
         chrome.experimental.devtools.inspectedWindow = chrome.devtools.inspectedWindow;
     }
     if (extensionInfo.exposeWebInspectorNamespace)
         window.webInspector = coreAPI;
 }
 
+/**
+ * @param {!ExtensionDescriptor} extensionInfo
+ * @return {string}
+ */
+function buildPlatformExtensionAPI(extensionInfo)
+{
+    return "var extensionInfo = " + JSON.stringify(extensionInfo) + ";" +
+       "var tabId = " + WebInspector._inspectedTabId + ";" +
+       platformExtensionAPI.toString();
+}
+
+/**
+ * @param {!ExtensionDescriptor} extensionInfo
+ * @return {string}
+ */
+function buildExtensionAPIInjectedScript(extensionInfo)
+{
+    return "(function(injectedScriptId){ " +
+        "var extensionServer;" +
+        defineCommonExtensionSymbols.toString() + ";" +
+        injectedExtensionAPI.toString() + ";" +
+        buildPlatformExtensionAPI(extensionInfo) + ";" +
+        "platformExtensionAPI(injectedExtensionAPI(injectedScriptId));" +
+        "return {};" +
+        "})";
+}
+
         var tabId;
         var extensionInfo = {};
         var extensionServer;
         platformExtensionAPI(injectedExtensionAPI("remote-" + window.parent.frames.length));
     })();