DevTools: use target-based model accessors only.

Source/devtools/front_end/extensions/ExtensionServer.js

 /*
  * 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
@@ skipping 361 matching lines @@
             WebInspector.Revealer.reveal(uiSourceCode.uiLocation(message.lineNumber, 0));
             return this._status.OK();
         }
 
         var resource = WebInspector.resourceForURL(message.url);
         if (resource) {
             WebInspector.Revealer.reveal(resource, message.lineNumber);
             return this._status.OK();
         }
 
-        var request = WebInspector.networkLog.requestForURL(message.url);
+        var request = WebInspector.NetworkLog.requestForURL(message.url);
         if (request) {
             WebInspector.Revealer.reveal(request);
             return this._status.OK();
         }
 
         return this._status.E_NOTFOUND(message.url);
     },
 
     _onSetOpenResourceHandler: function(message, port)
     {
@@ skipping 24 matching lines @@
 
     _onReload: function(message)
     {
         var options = /** @type {!ExtensionReloadOptions} */ (message.options || {});
 
         WebInspector.multitargetNetworkManager.setUserAgentOverride(typeof options.userAgent === "string" ? options.userAgent : "");
         var injectedScript;
         if (options.injectedScript)
             injectedScript = "(function(){" + options.injectedScript + "})()";
         var preprocessingScript = options.preprocessingScript;
-        WebInspector.resourceTreeModel.reloadPage(!!options.ignoreCache, injectedScript, preprocessingScript);
+        // Reload main frame.
+        var target = WebInspector.targetManager.mainTarget();
+        target.resourceTreeModel.reloadPage(!!options.ignoreCache, injectedScript, preprocessingScript);
         return this._status.OK();
     },
 
     _onEvaluateOnInspectedPage: function(message, port)
     {
         /**
          * @param {?Protocol.Error} error
-         * @param {?RuntimeAgent.RemoteObject} resultPayload
+         * @param {?WebInspector.RemoteObject} remoteObject
          * @param {boolean=} wasThrown
          * @this {WebInspector.ExtensionServer}
          */
-        function callback(error, resultPayload, wasThrown)
+        function callback(error, remoteObject, wasThrown)
         {
             var result;
-            if (error || !resultPayload)
+            if (error || !remoteObject)
                 result = this._status.E_PROTOCOLERROR(error.toString());
             else if (wasThrown)
-                result = { isException: true, value: resultPayload.description };
+                result = { isException: true, value: remoteObject.description };
             else
-                result = { value: resultPayload.value };
+                result = { value: remoteObject.value };
 
             this._dispatchCallback(message.requestId, port, result);
         }
         return this.evaluate(message.expression, true, true, message.evaluateOptions, port._extensionOrigin, callback.bind(this));
     },
 
     _onGetHAR: function()
     {
-        var requests = WebInspector.networkLog.requests;
+        var requests = WebInspector.NetworkLog.requests();
         var harLog = (new WebInspector.HARLog(requests)).build();
         for (var i = 0; i < harLog.entries.length; ++i)
             harLog.entries[i]._requestId = this._requestId(requests[i]);
         return harLog;
     },
 
     /**
      * @param {!WebInspector.ContentProvider} contentProvider
      */
     _makeResource: function(contentProvider)
@@ skipping 15 matching lines @@
          * @this {WebInspector.ExtensionServer}
          */
         function pushResourceData(contentProvider)
         {
             if (!resources[contentProvider.contentURL()])
                 resources[contentProvider.contentURL()] = this._makeResource(contentProvider);
         }
         var uiSourceCodes = WebInspector.workspace.uiSourceCodesForProjectType(WebInspector.projectTypes.Network);
         uiSourceCodes = uiSourceCodes.concat(WebInspector.workspace.uiSourceCodesForProjectType(WebInspector.projectTypes.ContentScripts));
         uiSourceCodes.forEach(pushResourceData.bind(this));
-        WebInspector.resourceTreeModel.forAllResources(pushResourceData.bind(this));
+        for (var target of WebInspector.targetManager.targets())
+            target.resourceTreeModel.forAllResources(pushResourceData.bind(this));
         return Object.values(resources);
     },
 
     /**
      * @param {!WebInspector.ContentProvider} contentProvider
      * @param {!Object} message
      * @param {!MessagePort} port
      */
     _getResourceContent: function(contentProvider, message, port)
     {
@@ skipping 43 matching lines @@
          */
         function callbackWrapper(error)
         {
             var response = error ? this._status.E_FAILED(error) : this._status.OK();
             this._dispatchCallback(message.requestId, port, response);
         }
 
         var url = /** @type {string} */ (message.url);
         var uiSourceCode = WebInspector.workspace.uiSourceCodeForOriginURL(url);
         if (!uiSourceCode) {
-            var resource = WebInspector.resourceTreeModel.resourceForURL(url);
+            var resource = WebInspector.ResourceTreeModel.resourceForURL(url);
             if (!resource)
                 return this._status.E_NOTFOUND(url);
             return this._status.E_NOTSUPPORTED("Resource is not editable");
         }
         uiSourceCode.setWorkingCopy(message.content);
         if (message.commit)
             uiSourceCode.commitWorkingCopy();
         callbackWrapper.call(this, null);
     },
 
@@ skipping 335 matching lines @@
         }
         return "/" + result.join("/");
     },
 
     /**
      * @param {string} expression
      * @param {boolean} exposeCommandLineAPI
      * @param {boolean} returnByValue
      * @param {?Object} options
      * @param {string} securityOrigin
-     * @param {function(?string, !RuntimeAgent.RemoteObject, boolean=)} callback
+     * @param {function(?string, ?WebInspector.RemoteObject, boolean=)} callback
      * @return {!WebInspector.ExtensionStatus.Record|undefined}
      */
     evaluate: function(expression, exposeCommandLineAPI, returnByValue, options, securityOrigin, callback)
     {
         var contextId;
 
         /**
          * @param {string} url
          * @return {boolean}
          */
         function resolveURLToFrame(url)
         {
             var found;
             function hasMatchingURL(frame)
             {
                 found = (frame.url === url) ? frame : null;
                 return found;
             }
-            WebInspector.resourceTreeModel.frames().some(hasMatchingURL);
+            WebInspector.ResourceTreeModel.frames().some(hasMatchingURL);
             return found;
         }
 
         if (typeof options === "object") {
-            var frame = options.frameURL ? resolveURLToFrame(options.frameURL) : WebInspector.resourceTreeModel.mainFrame;
+            var frame = options.frameURL ? resolveURLToFrame(options.frameURL) : WebInspector.targetManager.mainTarget().resourceTreeModel.mainFrame;
             if (!frame) {
                 if (options.frameURL)
                     console.warn("evaluate: there is no frame with URL " + options.frameURL);
                 else
                     console.warn("evaluate: the main frame is not yet available");
                 return this._status.E_NOTFOUND(options.frameURL || "<top>");
             }
 
             var contextSecurityOrigin;
             if (options.useContentScriptContext)
@@ skipping 21 matching lines @@
                         context = executionContext;
 
                 }
                 if (!context)
                     return this._status.E_FAILED(frame.url + " has no execution context");
             }
 
             contextId = context.id;
         }
         var target = target ? target : WebInspector.targetManager.mainTarget();
-        if (target)
-            target.runtimeAgent().evaluate(expression, "extension", exposeCommandLineAPI, true, contextId, returnByValue, false, callback);
+        if (!target)
+            return;
+
+        target.runtimeAgent().evaluate(expression, "extension", exposeCommandLineAPI, true, contextId, returnByValue, false, onEvalute);
+
+        /**
+         * @param {?Protocol.Error} error
+         * @param {!RuntimeAgent.RemoteObject} result
+         * @param {boolean=} wasThrown
+         */
+        function onEvalute(error, result, wasThrown)
+        {
+            if (error) {
+                callback(error, null, wasThrown);
+                return;
+            }
+            callback(error, target.runtimeModel.createRemoteObject(result), wasThrown);
+        }
     },
 
     __proto__: WebInspector.Object.prototype
 }
 
 /**
  * @constructor
  * @param {string} name
  * @param {string} title
  * @param {!WebInspector.Panel} panel
@@ skipping 66 matching lines @@
     this.E_FAILED = makeStatus.bind(null, "E_FAILED", "Operation failed: %s");
 }
 
 /**
  * @typedef {{code: string, description: string, details: !Array.<*>}}
  */
 WebInspector.ExtensionStatus.Record;
 
 WebInspector.extensionAPI = {};
 defineCommonExtensionSymbols(WebInspector.extensionAPI);