[Extensions] Make chrome://extensions use developerPrivate for error calls

chrome/browser/resources/extensions/extension_error_overlay.js

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * The type of the stack trace object. The definition is based on
  * extensions/browser/extension_error.cc:RuntimeError::ToValue().
  * @typedef {{columnNumber: number,
  *            functionName: string,
  *            lineNumber: number,
@@ skipping 73 matching lines @@
    * want to include any of our own code in stack traces.
    * @param {string} url The url in question.
    * @return {boolean} True if the url should be displayed, and false
    *     otherwise (i.e., if it is an internal script).
    */
   RuntimeErrorContent.shouldDisplayForUrl = function(url) {
     // All our internal scripts are in the 'extensions::' namespace.
     return !/^extensions::/.test(url);
   };
 
-  /**
-   * Send a call to chrome to open the developer tools for an error.
-   * This will call either the bound function in ExtensionErrorHandler or the
-   * API function from developerPrivate, depending on whether this is being
-   * used in the native chrome:extensions page or the Apps Developer Tool.
-   * @see chrome/browser/ui/webui/extensions/extension_error_ui_util.h
-   * @param {OpenDevToolsProperties} args The arguments to pass to openDevTools.
-   * @private
-   */
-  RuntimeErrorContent.openDevtools_ = function(args) {
-    if (chrome.send)
-      chrome.send('extensionErrorOpenDevTools', [args]);
-    else if (chrome.developerPrivate)
-      chrome.developerPrivate.openDevTools(args);
-    else
-      assertNotReached('Cannot call either openDevTools function.');
-  };
-
   RuntimeErrorContent.prototype = {
     __proto__: HTMLDivElement.prototype,
 
     /**
      * The underlying error whose details are being displayed.
      * @type {?RuntimeError}
      * @private
      */
     error_: null,
 
@@ skipping 107 matching lines @@
         }
         frameNode.textContent = description;
 
         // When the user clicks on a frame in the stack trace, we should
         // highlight that overlay in the list, display the appropriate source
         // code with the line highlighted, and link the "Open DevTools" button
         // with that frame.
         frameNode.addEventListener('click', function(frame, frameNode, e) {
           this.setActiveFrame_(frameNode);
 
-          // Request the file source with the section highlighted; this will
-          // call ExtensionErrorOverlay.requestFileSourceResponse() when
-          // completed, which in turn calls setCode().
-          ExtensionErrorOverlay.requestFileSource(
+          // Request the file source with the section highlighted.
+          extensions.ExtensionErrorOverlay.getInstance().requestFileSource(
               {extensionId: this.error_.extensionId,
                message: this.error_.message,
                pathSuffix: getRelativeUrl(frame.url,
                                           assert(this.extensionUrl_)),
                lineNumber: frame.lineNumber});
         }.bind(this, frame, frameNode));
 
         this.stackTrace_.appendChild(frameNode);
       }
 
       // Set the current stack frame to the first stack frame and show the
       // trace, if one exists. (We can't just check error.stackTrace, because
       // it's possible the trace was purely internal, and we don't show
       // internal frames.)
       if (this.stackTrace_.children.length > 0) {
         this.stackTrace_.hidden = false;
         this.setActiveFrame_(assertInstanceof(this.stackTrace_.firstChild,
             HTMLElement));
       }
     },
 
     /**
      * Open the developer tools for the active stack frame.
      */
     openDevtools: function() {
       var stackFrame =
           this.error_.stackTrace[this.currentFrameNode_.indexIntoTrace];
 
-      RuntimeErrorContent.openDevtools_(
+      chrome.developerPrivate.openDevTools(
           {renderProcessId: this.error_.renderProcessId || -1,
            renderViewId: this.error_.renderViewId || -1,
            url: stackFrame.url,
            lineNumber: stackFrame.lineNumber || 0,
            columnNumber: stackFrame.columnNumber || 0});
     }
   };
 
   /**
    * The ExtensionErrorOverlay will show the contents of a file which pertains
@@ skipping 59 matching lines @@
     if (error.stackTrace) {
       for (var i = 0; i < error.stackTrace.length; ++i) {
         if (RuntimeErrorContent.shouldDisplayForUrl(error.stackTrace[i].url))
           return true;
       }
     }
 
     return false;
   };
 
-  /**
-   * Send a call to chrome to request the source of a given file.
-   * This will call either the bound function in ExtensionErrorHandler or the
-   * API function from developerPrivate, depending on whether this is being
-   * used in the native chrome:extensions page or the Apps Developer Tool.
-   * @see chrome/browser/ui/webui/extensions/extension_error_ui_util.h
-   * @param {RequestFileSourceProperties} args The arguments to pass to
-   *     requestFileSource.
-   */
-  ExtensionErrorOverlay.requestFileSource = function(args) {
-    if (chrome.send) {
-      chrome.send('extensionErrorRequestFileSource', [args]);
-    } else if (chrome.developerPrivate) {
-      chrome.developerPrivate.requestFileSource(args, function(result) {
-        extensions.ExtensionErrorOverlay.requestFileSourceResponse(result);
-      });
-    } else {
-      assertNotReached('Cannot call either requestFileSource function.');
-    }
-  };
-
   cr.addSingletonGetter(ExtensionErrorOverlay);
 
   ExtensionErrorOverlay.prototype = {
     /**
      * The underlying error whose details are being displayed.
      * @type {?RuntimeError}
      * @private
      */
     error_: null,
 
@@ skipping 111 matching lines @@
 
         if (relativeUrl.toLowerCase() ==
                 ExtensionErrorOverlay.MANIFEST_FILENAME_) {
           requestFileSourceArgs.manifestKey = error.manifestKey;
           requestFileSourceArgs.manifestSpecific = error.manifestSpecific;
         } else {
           requestFileSourceArgs.lineNumber =
               error.stackTrace && error.stackTrace[0] ?
                   error.stackTrace[0].lineNumber : 0;
         }
-        ExtensionErrorOverlay.requestFileSource(requestFileSourceArgs);
+        this.requestFileSource(requestFileSourceArgs);
       } else {
-        ExtensionErrorOverlay.requestFileSourceResponse(null);
+        this.onFileSourceResponse_(null);
       }
     },
 
+    /**
+     * Requests a file's source.
+     * @param {RequestFileSourceProperties} args The arguments for the call.
+     */
+    requestFileSource: function(args) {
+      chrome.developerPrivate.requestFileSource(
+          args, this.onFileSourceResponse_.bind(this));
+    },
 
     /**
      * Set the code to be displayed in the code portion of the overlay.
      * @see ExtensionErrorOverlay.requestFileSourceResponse().
-     * @param {?ExtensionHighlight} code The code to be displayed. If |code| is
-     *     null, then
-     *     a "Could not display code" message will be displayed instead.
+     * @param {?RequestFileSourceResponse} response The response from the
+     *     request file source call, which will be shown as code. If |response|
+     *     is null, then a "Could not display code" message will be displayed
+     *     instead.
      */
-    setCode: function(code) {
+    onFileSourceResponse_: function(response) {
       document.querySelector(
           '#extension-error-overlay .extension-error-overlay-title').
-              textContent = code.title;
-
+              textContent = response.title;
       this.codeDiv_.populate(
-          code,
+          response,
           loadTimeData.getString('extensionErrorOverlayNoCodeToDisplay'));
+      this.setVisible(true);
     },
   };
 
-  /**
-   * Called by the ExtensionErrorHandler responding to the request for a file's
-   * source. Populate the content area of the overlay and display the overlay.
-   * @param {?ExtensionHighlight} result The three 'highlight' strings represent
-   *     three portions of the file's content to display - the portion which is
-   *     most relevant and should be emphasized (highlight), and the parts both
-   *     before and after this portion. These may be empty.
-   */
-  ExtensionErrorOverlay.requestFileSourceResponse = function(result) {
-    var overlay = extensions.ExtensionErrorOverlay.getInstance();
-    overlay.setCode(result);
-    overlay.setVisible(true);
-  };
-
   // Export
   return {
     ExtensionErrorOverlay: ExtensionErrorOverlay
   };
 });