[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();
+    // We use JSON.stringify of the CacheId to form our key.  This is because
+    // we cannot specify our own equality function for Sets yet.
+    /** @type {!Map<string, !WebInspector.ServiceWorkerCacheModel.CacheId>} */
+    this._caches = new Map();

[pfeldman, 2015/04/16 10:22:52]

Sorry, I did not notice you migrated to cacheIds, so was only reviewing the
test-related part.

I am not sure I follow this bit. What I would understand is if there was a
WebInspector.ServiceWorkerCache that would contain a this._securityOrigin,
this._cacheId fields along with cache-related methods and a map from opaque
cacheId to such a cache instance.

Mapping a JSON-stringified id object to itself in order to fetch sequrityOrigin
+ flattening cache-related methods here does not look particularly good.

[pfeldman, 2015/04/17 07:57:36]

This would actually be totally fine if the key is an opaque cacheId string that
came from the backend and the value is the Cache metadata that came from the
backend (see protocol.json comments below). Flat map would work best for this.

[dmurph, 2015/04/18 00:59:31]

Awesome, that's what I was thinking.  Done.

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

[pfeldman, 2015/04/16 10:22:52]

drop {}

[dmurph, 2015/04/18 00:59:31]

Done.

+            this._loadCacheNames(securityOrigin);
+        }
     },
 
     /**
      * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
      */
     deleteCache: function(cacheId)
     {
         /**
          * @this {WebInspector.ServiceWorkerCacheModel}
          */
         function callback(error)
         {
             if (error) {
-                console.error("ServiceWorkerCacheAgent error: ", error);
+                console.error("ServiceWorkerCacheAgent error deleting cache ", cacheId.toString(), ": ", error);
                 return;
             }
-            this._cacheRemoved(cacheId.name);
+            this._caches.delete(JSON.stringify(cacheId));
+            this._cacheRemoved(cacheId);
         }
-        this._agent.deleteCache(cacheId.name, callback.bind(this));
+        this._agent.deleteCache(cacheId, 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);
+        this._requestEntries(cacheId, 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));
+        var caches = new Array(this._caches.size);
+        var i = 0;
+        for (var cache of this._caches.values()) {

[pfeldman, 2015/04/16 10:22:52]

drop {}

[dmurph, 2015/04/18 00:59:31]

Done.

+          caches[i++] = cache;

[pfeldman, 2015/04/16 10:22:53]

We typically just .push for simplicity.

[dmurph, 2015/04/18 00:59:31]

Done.

         }
-        return result;
+        return caches;
     },
 
     dispose: function()
     {
-        this._updateCacheNames([]);
+        for (var cacheId of this._caches.values())
+            this._cacheRemoved(cacheId);
+        this._caches.clear();
+        if (this._enabled) {
+            this.target().resourceTreeModel.removeEventListener(WebInspector.ResourceTreeModel.EventTypes.SecurityOriginAdded, this._securityOriginAdded, this);
+            this.target().resourceTreeModel.removeEventListener(WebInspector.ResourceTreeModel.EventTypes.SecurityOriginRemoved, this._securityOriginRemoved, this);
+        }
     },
 
-    _loadCacheNames: function()
+    _addOrigin: 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)
-                return;
-            this._updateCacheNames(cacheNames);
-        }
-
-        this._agent.requestCacheNames(callback.bind(this));
+        this._loadCacheNames(securityOrigin);
     },
 
     /**
-     * @param {!Array.<string>} cacheNames
+     * @param {string} securityOrigin
      */
-    _updateCacheNames: function(cacheNames)
+    _removeOrigin: function(securityOrigin)
     {
-        /** @type {!Set.<string>} */
-        var newCacheNames = new Set(cacheNames);
-        /** @type {!Set.<string>} */
-        var oldCacheNames = this._cacheNames;
-
-        this._cacheNames = new Set(cacheNames);
-
-        for (var oldCacheName of oldCacheNames) {
-            if (!newCacheNames[oldCacheName])
-                this._cacheRemoved(oldCacheName);
-        }
-        for (var newCacheName of newCacheNames) {
-            if (!oldCacheNames[newCacheName])
-                this._cacheAdded(newCacheName);
+        for (var serializedId of this._caches.keys()) {
+            var cacheId = this._caches.get(serializedId);
+            if (cacheId.securityOrigin == securityOrigin) {
+                this._caches.delete(serializedId);
+                this._cacheRemoved(cacheId);
+            }
         }
     },
 
     /**
-     * @param {string} cacheName
+     * @param {string} securityOrigin
      */
-    _cacheAdded: function(cacheName)
+    _loadCacheNames: function(securityOrigin)
     {
-        var cacheId = new WebInspector.ServiceWorkerCacheModel.CacheId(cacheName);
+        /**
+         * @param {?Protocol.Error} error
+         * @param {!Array.<!WebInspector.ServiceWorkerCacheModel.CacheId>} cacheIds
+         * @this {WebInspector.ServiceWorkerCacheModel}
+         */
+        function callback(error, cacheIds)
+        {
+            if (error) {
+                console.error("ServiceWorkerCacheAgent error while loading caches: ", error);
+                return;
+            }
+            this._updateCacheNames(securityOrigin, cacheIds);
+        }
+        this._agent.requestCacheNames(securityOrigin, callback.bind(this));
+    },
+
+    /**
+     * @param {string} securityOrigin
+     * @param {!Array.<!WebInspector.ServiceWorkerCacheModel.CacheId>} cacheIds
+     */
+    _updateCacheNames: function(securityOrigin, cacheIds)
+    {
+        /**
+         * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
+         * @return {string}
+         */
+        function cacheIdToName(cacheId)
+        {
+            return cacheId.cacheName;
+        }
+        /**
+         * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
+         * @param {string} serializedId
+         * @this {WebInspector.ServiceWorkerCacheModel}
+         */
+        function deleteAndSaveForSecurityOrigin(cacheId, serializedId)
+        {
+            if (cacheId.securityOrigin == securityOrigin) {
+                oldCacheNames.add(cacheId.cacheName);
+                this._caches.delete(serializedId);
+            }
+        }
+
+        /** @type {!Set<string>} */
+        var newCacheNames = new Set(cacheIds.map(cacheIdToName));
+        /** @type {!Set<string>} */
+        var oldCacheNames = new Set();
+        this._caches.forEach(deleteAndSaveForSecurityOrigin, this);
+
+        for (var cacheId of cacheIds)
+            this._caches.set(JSON.stringify(cacheId), cacheId);
+
+        for (var oldCacheName of oldCacheNames) {
+            if (!newCacheNames.has(oldCacheName))
+                this._cacheRemoved(new WebInspector.ServiceWorkerCacheModel.CacheId(securityOrigin, oldCacheName));
+        }
+        for (var newCacheName of newCacheNames) {
+            if (!oldCacheNames.has(newCacheName))
+                this._cacheAdded(new WebInspector.ServiceWorkerCacheModel.CacheId(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 {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
+     */
+    _cacheAdded: function(cacheId)
+    {
         this.dispatchEventToListeners(WebInspector.ServiceWorkerCacheModel.EventTypes.CacheAdded, cacheId);
     },
 
     /**
-     * @param {string} cacheName
+     * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
      */
-    _cacheRemoved: function(cacheName)
+    _cacheRemoved: function(cacheId)
     {
-        var cacheId = new WebInspector.ServiceWorkerCacheModel.CacheId(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)
+    _requestEntries: function(cacheId, 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);
+                console.error("ServiceWorkerCacheAgent error while requesting entries: ", error);
                 return;
             }
-
-            if (!this._cacheNames)
-                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, skipCount, pageSize, innerCallback);
     },
 
     __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} name
+ * @param {string} securityOrigin
+ * @param {string} cacheName
  */
-WebInspector.ServiceWorkerCacheModel.CacheId = function(name)
+WebInspector.ServiceWorkerCacheModel.CacheId = function(securityOrigin, cacheName)
 {
-    this.name = name;
+    this.securityOrigin = securityOrigin;
+    this.cacheName = cacheName;
 }
 
 WebInspector.ServiceWorkerCacheModel.CacheId.prototype = {
     /**
      * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
      * @return {boolean}
      */
     equals: function(cacheId)
     {
-        return this.name === cacheId.name;
+        return this.cacheName === cacheId.cacheName && this.securityOrigin === cacheId.securityOrigin;
+    },
+
+    /**
+     * @override
+     * @return {string}
+     */
+    toString: function()
+    {
+        return this.securityOrigin + this.cacheName;
     }
 }
 
 /**
  * @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];
 }