[DevTools] No longer store security origins in ResourceTreeModel

third_party/WebKit/Source/devtools/front_end/sdk/ResourceTreeModel.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 15 matching lines @@
  * 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.
  */
 
 /**
  * @constructor
  * @extends {WebInspector.SDKModel}
  * @param {!WebInspector.Target} target
  * @param {?WebInspector.NetworkManager} networkManager
+ * @param {!WebInspector.SecurityOriginManager} securityOriginManager
  */
-WebInspector.ResourceTreeModel = function(target, networkManager)
+WebInspector.ResourceTreeModel = function(target, networkManager, securityOriginManager)
 {
     WebInspector.SDKModel.call(this, WebInspector.ResourceTreeModel, target);
     if (networkManager) {
         networkManager.addEventListener(WebInspector.NetworkManager.EventTypes.RequestFinished,
             this._onRequestFinished, this);
         networkManager.addEventListener(WebInspector.NetworkManager.EventTypes.RequestUpdateDropped,
             this._onRequestUpdateDropped, this);
     }
 
     this._agent = target.pageAgent();
     this._agent.enable();
+    this._securityOriginManager = securityOriginManager;
 
     this._fetchResourceTree();
 
     target.registerPageDispatcher(new WebInspector.PageDispatcher(this));
 
-    this._securityOriginFrameCount = {};
     this._inspectedPageURL = "";
     this._pendingReloadOptions = null;
     this._reloadSuspensionCount = 0;
 
     target.runtimeModel.setExecutionContextComparator(this._executionContextComparator.bind(this));
 }
 
 WebInspector.ResourceTreeModel.EventTypes = {
     FrameAdded: "FrameAdded",
     FrameNavigated: "FrameNavigated",
     FrameDetached: "FrameDetached",
     FrameResized: "FrameResized",
     FrameWillNavigate: "FrameWillNavigate",
     MainFrameNavigated: "MainFrameNavigated",
     ResourceAdded: "ResourceAdded",
     WillLoadCachedResources: "WillLoadCachedResources",
     CachedResourcesLoaded: "CachedResourcesLoaded",
     DOMContentLoaded: "DOMContentLoaded",
     Load: "Load",
     PageReloadRequested: "PageReloadRequested",
     WillReloadPage: "WillReloadPage",
     InspectedURLChanged: "InspectedURLChanged",
-    SecurityOriginAdded: "SecurityOriginAdded",
-    SecurityOriginRemoved: "SecurityOriginRemoved",
     ScreencastFrame: "ScreencastFrame",
     ScreencastVisibilityChanged: "ScreencastVisibilityChanged",
     ColorPicked: "ColorPicked"
 }
 
+/**
+ * @param {!WebInspector.Target} target
+ * @return {?WebInspector.ResourceTreeModel}
+ */
+WebInspector.ResourceTreeModel.fromTarget = function(target)
+{
+    return /** @type {?WebInspector.ResourceTreeModel} */ (target.model(WebInspector.ResourceTreeModel));
+}
 
 /**
  * @return {!Array.<!WebInspector.ResourceTreeFrame>}
  */
 WebInspector.ResourceTreeModel.frames = function()
 {
     var result = [];
-    for (var target of WebInspector.targetManager.targets())
-        result = result.concat(target.resourceTreeModel._frames.valuesArray());
+    for (var target of WebInspector.targetManager.targets(WebInspector.Target.Capability.DOM))
+        result = result.concat(WebInspector.ResourceTreeModel.fromTarget(target)._frames.valuesArray());
     return result;
 }
 
 /**
  * @param {string} url
  * @return {?WebInspector.Resource}
  */
 WebInspector.ResourceTreeModel.resourceForURL = function(url)
 {
-    for (var target of WebInspector.targetManager.targets()) {
-        var mainFrame = target.resourceTreeModel.mainFrame;
+    for (var target of WebInspector.targetManager.targets(WebInspector.Target.Capability.DOM)) {
+        var mainFrame = WebInspector.ResourceTreeModel.fromTarget(target).mainFrame;
         var result = mainFrame ? mainFrame.resourceForURL(url) : null;
         if (result)
             return result;
     }
     return null;
 }
 
 WebInspector.ResourceTreeModel.prototype = {
     _fetchResourceTree: function()
     {
         /** @type {!Map<string, !WebInspector.ResourceTreeFrame>} */
         this._frames = new Map();
         this._cachedResourcesProcessed = false;
         this._agent.getResourceTree(this._processCachedResources.bind(this));
     },
 
     _processCachedResources: function(error, mainFramePayload)
     {
-        if (error) {
-            this._cachedResourcesProcessed = true;
-            this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.CachedResourcesLoaded);
-            return;
+        if (!error) {
+            this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.WillLoadCachedResources);
+            this._inspectedPageURL = mainFramePayload.frame.url;
+            this._addFramesRecursively(null, mainFramePayload);
+            this._dispatchInspectedURLChanged();
         }
-
-        this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.WillLoadCachedResources);
-        this._inspectedPageURL = mainFramePayload.frame.url;
-
-        // Do not process SW resources.
-        if (this.target().hasBrowserCapability())
-            this._addFramesRecursively(null, mainFramePayload);
-        else
-            this._addSecurityOrigin(mainFramePayload.frame.securityOrigin);
-
-        this._dispatchInspectedURLChanged();
         this._cachedResourcesProcessed = true;
         this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.CachedResourcesLoaded);
     },
 
     /**
      * @return {string}
      */
     inspectedPageURL: function()
     {
         return this._inspectedPageURL;
@@ skipping 22 matching lines @@
         this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.InspectedURLChanged, this._inspectedPageURL);
     },
 
     /**
      * @param {!WebInspector.ResourceTreeFrame} frame
      * @param {boolean=} aboutToNavigate
      */
     _addFrame: function(frame, aboutToNavigate)
     {
         this._frames.set(frame.id, frame);
-        if (frame.isMainFrame())
+        if (frame.isMainFrame()) {
             this.mainFrame = frame;
+            this._securityOriginManager.setMainSecurityOrigin(frame.url);
+        }
         this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.FrameAdded, frame);
         if (!aboutToNavigate)
-            this._addSecurityOrigin(frame.securityOrigin);
+            this._securityOriginManager.addSecurityOrigin(frame.securityOrigin);
     },
 
     /**
-     * @param {string} securityOrigin
-     */
-    _addSecurityOrigin: function(securityOrigin)
-    {
-        if (!this._securityOriginFrameCount[securityOrigin]) {
-            this._securityOriginFrameCount[securityOrigin] = 1;
-            this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.SecurityOriginAdded, securityOrigin);
-            return;
-        }
-        this._securityOriginFrameCount[securityOrigin] += 1;
-    },
-
-    /**
-     * @param {string|undefined} securityOrigin
-     */
-    _removeSecurityOrigin: function(securityOrigin)
-    {
-        if (typeof securityOrigin === "undefined")
-            return;
-        if (this._securityOriginFrameCount[securityOrigin] === 1) {
-            delete this._securityOriginFrameCount[securityOrigin];
-            this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.SecurityOriginRemoved, securityOrigin);
-            return;
-        }
-        this._securityOriginFrameCount[securityOrigin] -= 1;
-    },
-
-    /**
-     * @return {!Array.<string>}
-     */
-    securityOrigins: function()
-    {
-        return Object.keys(this._securityOriginFrameCount);
-    },
-
-    /**
      * @param {!WebInspector.ResourceTreeFrame} mainFrame
      */
     _handleMainFrameDetached: function(mainFrame)
     {
         /**
          * @param {!WebInspector.ResourceTreeFrame} frame
          * @this {WebInspector.ResourceTreeModel}
          */
         function removeOriginForFrame(frame)
         {
             for (var i = 0; i < frame.childFrames.length; ++i)
                 removeOriginForFrame.call(this, frame.childFrames[i]);
             if (!frame.isMainFrame())
-                this._removeSecurityOrigin(frame.securityOrigin);
+                this._securityOriginManager.removeSecurityOrigin(frame.securityOrigin);
         }
         removeOriginForFrame.call(this, mainFrame);
     },
 
     /**
      * @param {!PageAgent.FrameId} frameId
      * @param {?PageAgent.FrameId} parentFrameId
      * @return {?WebInspector.ResourceTreeFrame}
      */
     _frameAttached: function(frameId, parentFrameId)
@@ skipping 26 matching lines @@
         var frame = this._frames.get(framePayload.id);
         if (!frame) {
             // Simulate missed "frameAttached" for a main frame navigation to the new backend process.
             console.assert(!framePayload.parentId, "Main frame shouldn't have parent frame id.");
             frame = this._frameAttached(framePayload.id, framePayload.parentId || "");
             console.assert(frame);
         }
 
         this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.FrameWillNavigate, frame);
 
-        this._removeSecurityOrigin(frame.securityOrigin);
+        this._securityOriginManager.removeSecurityOrigin(frame.securityOrigin);
         frame._navigate(framePayload);
         var addedOrigin = frame.securityOrigin;
 
         if (frame.isMainFrame())
             this._inspectedPageURL = frame.url;
 
         this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.FrameNavigated, frame);
         if (frame.isMainFrame()) {
             this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.MainFrameNavigated, frame);
             if (WebInspector.moduleSetting("preserveConsoleLog").get())
                 WebInspector.console.log(WebInspector.UIString("Navigated to %s", frame.url));
             else
                 this.target().consoleModel.clear();
         }
         if (addedOrigin)
-            this._addSecurityOrigin(addedOrigin);
+            this._securityOriginManager.addSecurityOrigin(addedOrigin);
 
         // Fill frame with retained resources (the ones loaded using new loader).
         var resources = frame.resources();
         for (var i = 0; i < resources.length; ++i)
             this.dispatchEventToListeners(WebInspector.ResourceTreeModel.EventTypes.ResourceAdded, resources[i]);
 
         if (frame.isMainFrame())
             this._dispatchInspectedURLChanged();
     },
 
     /**
      * @param {!PageAgent.FrameId} frameId
      */
     _frameDetached: function(frameId)
     {
         // Do nothing unless cached resource tree is processed - it will overwrite everything.
         if (!this._cachedResourcesProcessed)
             return;
 
         var frame = this._frames.get(frameId);
         if (!frame)
             return;
 
-        this._removeSecurityOrigin(frame.securityOrigin);
+        this._securityOriginManager.removeSecurityOrigin(frame.securityOrigin);
         if (frame.parentFrame)
             frame.parentFrame._removeChildFrame(frame);
         else
             frame._remove();
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _onRequestFinished: function(event)
@@ skipping 235 matching lines @@
     /**
      * @type {!Object.<string, !WebInspector.Resource>}
      */
     this._resourcesMap = {};
 
     if (this._parentFrame)
         this._parentFrame._childFrames.push(this);
 }
 
 /**
+ * @param {!WebInspector.ExecutionContext|!WebInspector.CSSStyleSheetHeader|!WebInspector.Resource} object
+ * @return {?WebInspector.ResourceTreeFrame}
+ */
+WebInspector.ResourceTreeFrame._fromObject = function(object)
+{
+    var resourceTreeModel = WebInspector.ResourceTreeModel.fromTarget(object.target());
+    var frameId = object.frameId;
+    if (!resourceTreeModel || !frameId)
+        return null;
+    return resourceTreeModel.frameForId(frameId);
+}
+
+/**
  * @param {!WebInspector.Script} script
  * @return {?WebInspector.ResourceTreeFrame}
  */
 WebInspector.ResourceTreeFrame.fromScript = function(script)
 {
     var executionContext = script.executionContext();
-    if (!executionContext || !executionContext.frameId)
+    if (!executionContext)
         return null;
-    return script.target().resourceTreeModel.frameForId(executionContext.frameId);
+    return WebInspector.ResourceTreeFrame._fromObject(executionContext);
 }
 
 /**
  * @param {!WebInspector.CSSStyleSheetHeader} header
  * @return {?WebInspector.ResourceTreeFrame}
  */
 WebInspector.ResourceTreeFrame.fromStyleSheet = function(header)
 {
-    return header.target().resourceTreeModel.frameForId(header.frameId);
+    return WebInspector.ResourceTreeFrame._fromObject(header);
 }
 
 /**
  * @param {!WebInspector.Resource} resource
  * @return {?WebInspector.ResourceTreeFrame}
  */
 WebInspector.ResourceTreeFrame.fromResource = function(resource)
 {
-    return resource.target().resourceTreeModel.frameForId(resource.frameId);
+    return WebInspector.ResourceTreeFrame._fromObject(resource);
 }
 
 WebInspector.ResourceTreeFrame.prototype = {
     /**
      * @return {!WebInspector.Target}
      */
     target: function()
     {
         return this._model.target();
     },
@@ skipping 368 matching lines @@
 
     /**
      * @override
      */
     navigationRequested: function()
     {
        // Frontend is not interested in interstitials.
     }
 
 }