[Storage] Cache storage inspection on all the frames!

Source/devtools/front_end/sdk/ServiceWorkerCacheModel.js

Index: Source/devtools/front_end/sdk/ServiceWorkerCacheModel.js
diff --git a/Source/devtools/front_end/sdk/ServiceWorkerCacheModel.js b/Source/devtools/front_end/sdk/ServiceWorkerCacheModel.js
index 52af59c9decd71f00a6306b0d78371a188fb7b5e..3f2954f691bbff817df0a1df2d3b96ef5d1eef98 100644
--- a/Source/devtools/front_end/sdk/ServiceWorkerCacheModel.js
+++ b/Source/devtools/front_end/sdk/ServiceWorkerCacheModel.js
@@ -11,27 +11,38 @@ 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);
+        }
     },
 
     /**
@@ -39,6 +50,7 @@ WebInspector.ServiceWorkerCacheModel.prototype = {
      */
     deleteCache: function(cacheId)
     {
+        var securityOrigin = cacheId.securityOrigin;
         /**
          * @this {WebInspector.ServiceWorkerCacheModel}
          */
@@ -48,9 +60,16 @@ WebInspector.ServiceWorkerCacheModel.prototype = {
                 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));
     },
 
     /**
@@ -70,18 +89,44 @@ WebInspector.ServiceWorkerCacheModel.prototype = {
     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 = {};
+    },
+
+    _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];
     },
 
-    _loadCacheNames: function()
+    /**
+     * @param {string} securityOrigin
+     */
+    _loadCacheNames: function(securityOrigin)
     {
         /**
          * @param {?Protocol.Error} error
@@ -94,52 +139,71 @@ WebInspector.ServiceWorkerCacheModel.prototype = {
                 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);
     },
 
@@ -164,8 +228,7 @@ WebInspector.ServiceWorkerCacheModel.prototype = {
                 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) {
@@ -175,8 +238,7 @@ WebInspector.ServiceWorkerCacheModel.prototype = {
             }
             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
@@ -195,10 +257,12 @@ WebInspector.ServiceWorkerCacheModel.Entry = function(request, 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;
 }
 
@@ -209,7 +273,7 @@ WebInspector.ServiceWorkerCacheModel.CacheId.prototype = {
      */
     equals: function(cacheId)
     {
-        return this.name === cacheId.name;
+        return this.name === cacheId.name && this.securityOrigin === cacheId.securityOrigin;
     }
 }
 
@@ -220,4 +284,17 @@ WebInspector.ServiceWorkerCacheModel.CacheId.prototype = {
 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];
 }