[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 = new Map();
 
-    this._agent = target.serviceWorkerCacheAgent();
+    this._agent = target.cacheStorageAgent();
+
+    /** @type {boolean} */
+    this._enabled = false;
 }
 
 WebInspector.ServiceWorkerCacheModel.EventTypes = {
     CacheAdded: "CacheAdded",
-    CacheRemoved: "CacheRemoved",
+    CacheRemoved: "CacheRemoved"
 }
 
 WebInspector.ServiceWorkerCacheModel.prototype = {
-    _reset: function()
+    /**
+     * @return {boolean}
+     */
+    isEnabled: function()
     {
-        this._updateCacheNames([]);
-        this._loadCacheNames();
+        return this._enabled;
+    },
+    enable: function()
+    {
+        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])

[pfeldman, 2015/04/02 21:18:57]

Now that this is a map, you should use .set, .get and .delete

[dmurph, 2015/04/02 23:23:18]

Done.

+                return;
+            var caches = this._cacheNamesBySecurityOrigin[securityOrigin];
+            var index = caches.indexOf(cacheId.name);

[pfeldman, 2015/04/02 21:18:57]

Arrays have .remove() in devtools.

[dmurph, 2015/04/02 23:23:17]

Done.

+            if (index != -1) {

[pfeldman, 2015/04/02 21:18:57]

no {} around single-line blocks

[dmurph, 2015/04/02 23:23:17]

Done.

+                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) {

[pfeldman, 2015/04/02 21:18:58]

this would be for (var caches of this._cacheNamesBySecurityOrigin.values())

[dmurph, 2015/04/02 23:23:17]

Done.

+            var caches = this._cacheNamesBySecurityOrigin[securityOrigin];
+            for (var cacheName of caches) {
+                result.push(new WebInspector.ServiceWorkerCacheModel.CacheId(securityOrigin, cacheName));
+            }
         }
         return result;
     },
 
     dispose: function()

[pfeldman, 2015/04/02 21:18:58]

unregister the listeners to resourceTreeModel here.

[dmurph, 2015/04/02 23:23:17]

done.

     {
-        this._updateCacheNames([]);
+        for (var securityOrigin in this._cacheNamesBySecurityOrigin) {

[pfeldman, 2015/04/02 21:18:57]

of .keys()

[dmurph, 2015/04/02 23:23:17]

Done.

+            this._updateCacheNames(securityOrigin, []);
+        }
+        this._cacheNamesBySecurityOrigin = {};

[pfeldman, 2015/04/02 21:18:57]

.clear()

[dmurph, 2015/04/02 23:23:17]

Done.

     },
 
-    _loadCacheNames: function()
+    _addOrigin: function(securityOrigin) {
+        console.assert(!this._cacheNamesBySecurityOrigin[securityOrigin]);

[pfeldman, 2015/04/02 21:18:58]

ditto

[dmurph, 2015/04/02 23:23:18]

Done.

+        this._cacheNamesBySecurityOrigin[securityOrigin] = [];
+        this._loadCacheNames(securityOrigin);
+    },
+
+    /**
+     * @param {string} securityOrigin
+     */
+    _removeOrigin: function(securityOrigin)
+    {
+        console.assert(this._cacheNamesBySecurityOrigin[securityOrigin]);
+        for (var cacheName of this._cacheNamesBySecurityOrigin[securityOrigin])

[pfeldman, 2015/04/02 21:18:58]

ditto (and may times below)

[dmurph, 2015/04/02 23:23:17]

Done

+          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];
 }