[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();
 
-    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) {
+            this._loadCacheNames(securityOrigin);
+        }
     },
 
     /**
      * @param {!WebInspector.ServiceWorkerCacheModel.CacheId} cacheId
      */
     deleteCache: function(cacheId)
     {
         /**
          * @this {WebInspector.ServiceWorkerCacheModel}
          */
         function callback(error)
         {
             if (error) {
                 console.error("ServiceWorkerCacheAgent error: ", 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));
-        }
-        return result;
+        return new Array(this._caches.values());
     },
 
     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)
+    {
+        this._loadCacheNames(securityOrigin);
+    },
+
+    /**
+     * @param {string} securityOrigin
+     */
+    _removeOrigin: function(securityOrigin)
+    {
+        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} securityOrigin
+     */
+    _loadCacheNames: function(securityOrigin)
     {
         /**
          * @param {?Protocol.Error} error
-         * @param {!Array.<string>} cacheNames
+         * @param {!Array.<!WebInspector.ServiceWorkerCacheModel.CacheId>} cacheIds
          * @this {WebInspector.ServiceWorkerCacheModel}
          */
-        function callback(error, cacheNames)
+        function callback(error, cacheIds)
         {
             if (error) {
                 console.error("ServiceWorkerCacheAgent error: ", error);
                 return;
             }
-
-            if (!this._cacheNames)
-                return;
-            this._updateCacheNames(cacheNames);
+            this._updateCacheNames(securityOrigin, cacheIds);
         }
-
-        this._agent.requestCacheNames(callback.bind(this));
+        this._agent.requestCacheNames(securityOrigin, callback.bind(this));
     },
 
     /**
-     * @param {!Array.<string>} cacheNames
+     * @param {string} securityOrigin
+     * @param {!Array.<!WebInspector.ServiceWorkerCacheModel.CacheId>} cacheIds
      */
-    _updateCacheNames: function(cacheNames)
+    _updateCacheNames: function(securityOrigin, cacheIds)
     {
-        /** @type {!Set.<string>} */
-        var newCacheNames = new Set(cacheNames);
-        /** @type {!Set.<string>} */
-        var oldCacheNames = this._cacheNames;
+        /**
+         * @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);
+            }
+        }
 
-        this._cacheNames = new Set(cacheNames);
+        /** @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[oldCacheName])
-                this._cacheRemoved(oldCacheName);
+            if (!newCacheNames.has(oldCacheName))
+                this._cacheRemoved(new WebInspector.ServiceWorkerCacheModel.CacheId(securityOrigin, oldCacheName));
         }
         for (var newCacheName of newCacheNames) {
-            if (!oldCacheNames[newCacheName])
-                this._cacheAdded(newCacheName);
+            if (!oldCacheNames.has(newCacheName))
+                this._cacheAdded(new WebInspector.ServiceWorkerCacheModel.CacheId(securityOrigin, newCacheName));
         }
     },
 
     /**
-     * @param {string} cacheName
+     * @param {!WebInspector.Event} event
      */
-    _cacheAdded: function(cacheName)
+    _securityOriginAdded: function(event)
     {
-        var cacheId = new WebInspector.ServiceWorkerCacheModel.CacheId(cacheName);
+        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);
                 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];
 }