[Storage] Cache storage inspection on all the frames!

Source/devtools/front_end/sdk/ServiceWorkerCacheModel.js

 // Copyright 2014 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.
 
 /**
  * Invariant: This model can only be constructed on a ServiceWorker target.
  * @constructor
  * @extends {WebInspector.SDKModel}
  */
 WebInspector.ServiceWorkerCacheModel = function(target)
 {
     WebInspector.SDKModel.call(this, WebInspector.ServiceWorkerCacheModel, target);
 
-    /** @type {!Set.<string>} */
-    this._cacheNames = new Set();
+    /** @type {!Object.<string, !Array.<string>>} */
+    this._cacheNamesBySecurityOrigin = {};

[pfeldman, 2015/04/01 07:01:09]

Use Map.

Also, please extract the Cache-per-Origin change from this one since it seems to
be self-contained.

[dmurph, 2015/04/02 20:59:03]

It's basically exactly the same patch, but without some of the CPP changes.  I'd
rather have it all in one, especially because we're trying to get it in before
the branch point (tomorrow).  Is that alright?

 
-    this._agent = target.serviceWorkerCacheAgent();
+    this._agent = target.cacheStorageAgent();
 }
 
 WebInspector.ServiceWorkerCacheModel.EventTypes = {
     CacheAdded: "CacheAdded",
-    CacheRemoved: "CacheRemoved",
+    CacheRemoved: "CacheRemoved"
 }
 
 WebInspector.ServiceWorkerCacheModel.prototype = {
-    _reset: function()
+    enable: function()
     {
-        this._updateCacheNames([]);
-        this._loadCacheNames();
+        if (this._enabled)
+            return;
+
+        this.target().resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.SecurityOriginAdded, this._securityOriginAdded, this);
+        this.target().resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.SecurityOriginRemoved, this._securityOriginRemoved, this);
+
+        var securityOrigins = this.target().resourceTreeModel.securityOrigins();
+        for (var i = 0; i < securityOrigins.length; ++i)
+            this._addOrigin(securityOrigins[i]);
+        this._enabled = true;
     },
 
     refreshCacheNames: function()
     {
-        this._loadCacheNames();
+        var securityOrigins = this.target().resourceTreeModel.securityOrigins();
+        for (var securityOrigin of securityOrigins) {
+            this._loadCacheNames(securityOrigin);
+        }
     },
 
     /**
      * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
      */
     deleteCache: function(cacheId)
     {
+        var securityOrigin = cacheId.securityOrigin;
         /**
          * @this {WebInspector.ServiceWorkerCacheModel}
          */
         function callback(error)
         {
             if (error) {
                 console.error("ServiceWorkerCacheAgent error: ", error);
                 return;
             }
-            this._cacheRemoved(cacheId.name);
+            if (!this._cacheNamesBySecurityOrigin[securityOrigin])
+                return;
+            var caches = this._cacheNamesBySecurityOrigin[securityOrigin];
+            var index = caches.indexOf(cacheId.name);
+            if (index != -1) {
+                caches.splice(index, 1);
+            }
+            this._cacheRemoved(securityOrigin, cacheId.name);
         }
-        this._agent.deleteCache(cacheId.name, callback.bind(this));
+        this._agent.deleteCache(securityOrigin, cacheId.name, callback.bind(this));
     },
 
     /**
      * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
      * @param {number} skipCount
      * @param {number} pageSize
      * @param {function(!Array.<!WebInspector.ServiceWorkerCacheModel.Entry>, boolean)} callback
      */
     loadCacheData: function(cacheId, skipCount, pageSize, callback)
     {
         this._requestEntries(cacheId, cacheId.name, skipCount, pageSize, callback);
     },
 
     /**
      * @return {!Array.<!WebInspector.ServiceWorkerCacheModel.CacheId>}
      */
     caches: function()
     {
         var result = [];
-        for (var cacheName of this._cacheNames) {
-          result.push(new WebInspector.ServiceWorkerCacheModel.CacheId(cacheName));
+        for (var securityOrigin in this._cacheNamesBySecurityOrigin) {
+            var caches = this._cacheNamesBySecurityOrigin[securityOrigin];
+            for (var cacheName of caches) {
+                result.push(new WebInspector.ServiceWorkerCacheModel.CacheId(securityOrigin, cacheName));
+            }
         }
         return result;
     },
 
     dispose: function()
     {
-        this._updateCacheNames([]);
+        for (var securityOrigin in this._cacheNamesBySecurityOrigin) {
+            this._updateCacheNames(securityOrigin, []);
+        }
+        this._cacheNamesBySecurityOrigin = {};
     },
 
-    _loadCacheNames: function()
+    _addOrigin: function(securityOrigin) {
+        console.assert(!this._cacheNamesBySecurityOrigin[securityOrigin]);
+        this._cacheNamesBySecurityOrigin[securityOrigin] = [];
+        this._loadCacheNames(securityOrigin);
+    },
+
+    /**
+     * @param {string} securityOrigin
+     */
+    _removeOrigin: function(securityOrigin)
+    {
+        console.assert(this._cacheNamesBySecurityOrigin[securityOrigin]);
+        for (var cacheName of this._cacheNamesBySecurityOrigin[securityOrigin])
+          this._cacheRemoved(securityOrigin, cacheName);
+        delete this._cacheNamesBySecurityOrigin[securityOrigin];
+    },
+
+    /**
+     * @param {string} securityOrigin
+     */
+    _loadCacheNames: function(securityOrigin)
     {
         /**
          * @param {?Protocol.Error} error
          * @param {!Array.<string>} cacheNames
          * @this {WebInspector.ServiceWorkerCacheModel}
          */
         function callback(error, cacheNames)
         {
             if (error) {
                 console.error("ServiceWorkerCacheAgent error: ", error);
                 return;
             }
-
-            if (!this._cacheNames)
+            if (!this._cacheNamesBySecurityOrigin[securityOrigin])
                 return;
-            this._updateCacheNames(cacheNames);
+            this._updateCacheNames(securityOrigin, cacheNames);
         }
-
-        this._agent.requestCacheNames(callback.bind(this));
+        this._agent.requestCacheNames(securityOrigin, callback.bind(this));
     },
 
     /**
+     * @param {string} securityOrigin
      * @param {!Array.<string>} cacheNames
      */
-    _updateCacheNames: function(cacheNames)
+    _updateCacheNames: function(securityOrigin, cacheNames)
     {
-        /** @type {!Set.<string>} */
-        var newCacheNames = new Set(cacheNames);
-        /** @type {!Set.<string>} */
-        var oldCacheNames = this._cacheNames;
+        /** @type {!Object<string,boolean>} */
+        var newCacheNames = cacheNames.keySet();
+        /** @type {!Object<string,boolean>} */
+        var oldCacheNames = this._cacheNamesBySecurityOrigin[securityOrigin].keySet();
 
-        this._cacheNames = new Set(cacheNames);
+        this._cacheNamesBySecurityOrigin[securityOrigin] = cacheNames;
 
-        for (var oldCacheName of oldCacheNames) {
+        for (var oldCacheName in oldCacheNames) {
             if (!newCacheNames[oldCacheName])
-                this._cacheRemoved(oldCacheName);
+                this._cacheRemoved(securityOrigin, oldCacheName);
         }
-        for (var newCacheName of newCacheNames) {
+        for (var newCacheName in newCacheNames) {
             if (!oldCacheNames[newCacheName])
-                this._cacheAdded(newCacheName);
+                this._cacheAdded(securityOrigin, newCacheName);
         }
     },
 
     /**
+     * @param {!WebInspector.Event} event
+     */
+    _securityOriginAdded: function(event)
+    {
+        var securityOrigin = /** @type {string} */ (event.data);
+        this._addOrigin(securityOrigin);
+    },
+
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _securityOriginRemoved: function(event)
+    {
+        var securityOrigin = /** @type {string} */ (event.data);
+        this._removeOrigin(securityOrigin);
+    },
+
+    /**
+     * @param {string} securityOrigin
      * @param {string} cacheName
      */
-    _cacheAdded: function(cacheName)
+    _cacheAdded: function(securityOrigin, cacheName)
     {
-        var cacheId = new WebInspector.ServiceWorkerCacheModel.CacheId(cacheName);
+        var cacheId = new WebInspector.ServiceWorkerCacheModel.CacheId(securityOrigin, cacheName);
         this.dispatchEventToListeners(WebInspector.ServiceWorkerCacheModel.EventTypes.CacheAdded, cacheId);
     },
 
     /**
+     * @param {string} securityOrigin
      * @param {string} cacheName
      */
-    _cacheRemoved: function(cacheName)
+    _cacheRemoved: function(securityOrigin, cacheName)
     {
-        var cacheId = new WebInspector.ServiceWorkerCacheModel.CacheId(cacheName);
+        var cacheId = new WebInspector.ServiceWorkerCacheModel.CacheId(securityOrigin, cacheName);
         this.dispatchEventToListeners(WebInspector.ServiceWorkerCacheModel.EventTypes.CacheRemoved, cacheId);
     },
 
     /**
      * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
      * @param {string} cacheName
      * @param {number} skipCount
      * @param {number} pageSize
      * @param {function(!Array.<!WebInspector.ServiceWorkerCacheModel.Entry>, boolean)} callback
      */
     _requestEntries: function(cacheId, cacheName, skipCount, pageSize, callback)
     {
         /**
          * @param {?Protocol.Error} error
          * @param {!Array.<!WebInspector.ServiceWorkerCacheModel.Entry>} dataEntries
          * @param {boolean} hasMore
          * @this {WebInspector.ServiceWorkerCacheModel}
          */
         function innerCallback(error, dataEntries, hasMore)
         {
             if (error) {
                 console.error("ServiceWorkerCacheAgent error: ", error);
                 return;
             }
-
-            if (!this._cacheNames)
+            if (!this._cacheNamesBySecurityOrigin[cacheId.securityOrigin])
                 return;
             var entries = [];
             for (var i = 0; i < dataEntries.length; ++i) {
                 var request = WebInspector.RemoteObject.fromLocalObject(JSON.parse(dataEntries[i].request));
                 var response = WebInspector.RemoteObject.fromLocalObject(JSON.parse(dataEntries[i].response));
                 entries.push(new WebInspector.ServiceWorkerCacheModel.Entry(request, response));
             }
             callback(entries, hasMore);
         }
-
-        this._agent.requestEntries(cacheName, skipCount, pageSize, innerCallback.bind(this));
+        this._agent.requestEntries(cacheId.securityOrigin, cacheName, skipCount, pageSize, innerCallback.bind(this));
     },
 
     __proto__: WebInspector.SDKModel.prototype
 }
 
 /**
  * @constructor
  * @param {!WebInspector.RemoteObject} request
  * @param {!WebInspector.RemoteObject} response
  */
 WebInspector.ServiceWorkerCacheModel.Entry = function(request, response)
 {
     this.request = request;
     this.response = response;
 }
 
 /**
  * @constructor
+ * @param {string} securityOrigin
  * @param {string} name
  */
-WebInspector.ServiceWorkerCacheModel.CacheId = function(name)
+WebInspector.ServiceWorkerCacheModel.CacheId = function(securityOrigin, name)
 {
+    this.securityOrigin = securityOrigin;
     this.name = name;
 }
 
 WebInspector.ServiceWorkerCacheModel.CacheId.prototype = {
     /**
      * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
      * @return {boolean}
      */
     equals: function(cacheId)
     {
-        return this.name === cacheId.name;
+        return this.name === cacheId.name && this.securityOrigin === cacheId.securityOrigin;
     }
 }
 
 /**
  * @constructor
  * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
  */
 WebInspector.ServiceWorkerCacheModel.Cache = function(cacheId)
 {
     this.cacheId = cacheId;
+}
+
+WebInspector.ServiceWorkerCacheModel._symbol = Symbol("CacheStorageModel");
+/**
+ * @param {!WebInspector.Target} target
+ * @return {!WebInspector.ServiceWorkerCacheModel}
+ */
+WebInspector.ServiceWorkerCacheModel.fromTarget = function(target)
+{
+    if (!target[WebInspector.ServiceWorkerCacheModel._symbol])
+        target[WebInspector.ServiceWorkerCacheModel._symbol] = new WebInspector.ServiceWorkerCacheModel(target);
+
+    return target[WebInspector.ServiceWorkerCacheModel._symbol];
 }