[Storage] Cache storage inspection on all the frames!

LayoutTests/http/tests/inspector/cache-storage/cache-storage-test.js

+var initialize_CacheStorageTest = function() {

[pfeldman, 2015/04/10 12:35:33]

Copyright, please also use Blink coding guidelines: 4 space indentation.

[dmurph, 2015/04/13 18:23:03]

Done.

+InspectorTest.preloadPanel("resources");
+
+// ###### CALLBACK SUPPORT ######
+var lastCallbackId = 0;

[pfeldman, 2015/04/10 12:35:33]

Section below is cryptic.

[dmurph, 2015/04/13 18:23:03]

Removed

+var callbacks = {};
+var callbackIdPrefix = "InspectorTest.CacheStorage_callback";
+var resolveId = "Resolve";
+var rejectId = "Reject";
+
+var generatePromiseCallbackCalls = function(callbackId) {
+  return "dispatchCallback.bind(this, \"" + callbackIdPrefix + callbackId + resolveId + "\"), dispatchCallback.bind(this, \"" + callbackIdPrefix + callbackId + rejectId + "\")";
+}
+
+var getAndDeleteCallbackFromId = function(callbackId) {

[pfeldman, 2015/04/10 12:35:33]

Lets move InspectorTest.evaluateWithPromise along with the helper methods into
inspector-test.js

[dmurph, 2015/04/13 18:23:03]

Done, as 'invokePageFunctionPromise'

+  callbackId = callbackId.substring(callbackIdPrefix.length);
+  var resolve = callbackId.indexOf(resolveId) !== -1;
+  console.assert(resolve || callbackId.indexOf(rejectId) !== -1);
+  var sizeOffEnd = resolve ? resolveId.length : rejectId.length;
+  callbackId = callbackId.substring(0, callbackId.length - sizeOffEnd);
+  var callbackOptions = callbacks[callbackId];
+  var callback = resolve ? callbackOptions.resolve : callbackOptions.reject;
+  delete callbacks[callbackId];
+  return callback;
+}
+
+InspectorTest.evaluateWithPromise = function(frameId, methodName, parameters)
+{
+    return new Promise(function(resolve, reject) {
+        InspectorTest._cacheStorageSniffer();
+        var callbackId = ++lastCallbackId;
+        callbacks[callbackId] = { 'resolve': resolve, 'reject': reject };
+        var parametersString = generatePromiseCallbackCalls(callbackId);
+        for (var i = 0; i < parameters.length; ++i)
+            parametersString += ", " + JSON.stringify(parameters[i]);
+        var requestString = methodName + "(" + parametersString + ")";
+        InspectorTest.evaluateInPage(requestString);
+    });
+};

[pfeldman, 2015/04/10 12:35:33]

drop ;

[dmurph, 2015/04/13 18:23:03]

Done.

+
+InspectorTest._cacheStorageSniffer = function()
+{
+    InspectorTest.addConsoleSniffer(consoleMessageOverride, false);
+    function consoleMessageOverride(msg)
+    {
+        var text = msg.messageText;
+        if (!text.startsWith(callbackIdPrefix)) {
+            InspectorTest.addConsoleSniffer(consoleMessageOverride, false);
+            return;
+        }
+        var callback = getAndDeleteCallbackFromId(text);
+        callback.call();
+    }
+};
+
+// ###### INSPECTOR STATE AND OPERATIONS ######
+
+InspectorTest.dumpCacheTree = function()
+{
+    WebInspector.panels.resources.cacheStorageListTreeElement.expand();
+    InspectorTest.addResult("Dumping CacheStorage tree:");
+    var cachesTreeElement = WebInspector.panels.resources.cacheStorageListTreeElement;
+    var promise = new Promise(function(resolve, reject) {
+        InspectorTest.addSnifferPromise(WebInspector.ServiceWorkerCacheModel.prototype, "_updateCacheNames").then(function() {
+            if (!cachesTreeElement.childCount()) {
+                InspectorTest.addResult("    (empty)");
+                return resolve();
+            }
+            function queryView(i) {
+                var cacheTreeElement = cachesTreeElement.childAt(i);
+                InspectorTest.addResult("    cache: " + cacheTreeElement.titleText);
+                function nextOrResolve() {
+                    var next = i + 1;
+                    if (next < cachesTreeElement.childCount()) {
+                        queryView(next);
+                    } else {
+                        resolve();
+                    }
+                }
+                function addDataResult() {
+                    if (view._entries.length == 0) {
+                        InspectorTest.addResult("        (cache empty)");
+                        nextOrResolve();
+                        return;
+                    }
+                    for (var entry of view._entries) {
+                        InspectorTest.addResult("        '" + entry.request._value + "': '" + entry.response._value + "'");
+                    }
+                    nextOrResolve();
+                }
+                var view = cacheTreeElement._view;
+                InspectorTest.addSniffer(WebInspector.ServiceWorkerCacheView.prototype, "_updateDataCallback", addDataResult, false);
+                if (!view) {

[pfeldman, 2015/04/10 12:35:33]

no {}

[dmurph, 2015/04/13 18:23:03]

Done.

+                    cacheTreeElement.onselect(false);
+                } else {
+                    view._updateData(true);
+                }
+                view = cacheTreeElement._view;
+            }
+            WebInspector.panels.resources.cacheStorageListTreeElement._refreshCaches();
+            queryView(0);
+        }).catch(reject);
+    });
+    WebInspector.panels.resources.cacheStorageListTreeElement._refreshCaches();
+    return promise;
+}
+
+InspectorTest.deleteCacheFromInspector = function(cacheName) {
+  WebInspector.panels.resources.cacheStorageListTreeElement.expand();
+  InspectorTest.addResult("Deleting CacheStorage cache " + cacheName);
+  var cachesTreeElement = WebInspector.panels.resources.cacheStorageListTreeElement;
+  var promise = new Promise(function(resolve, reject) {
+    InspectorTest.addSnifferPromise(WebInspector.ServiceWorkerCacheModel.prototype, "_updateCacheNames").then(function() {
+        if (!cachesTreeElement.childCount()) {
+            return resolve();
+        }
+        for (var i = 0; i < cachesTreeElement.childCount(); i++) {
+            var cacheTreeElement = cachesTreeElement.childAt(i);
+            var title = cacheTreeElement.titleText;
+            var elementCacheName = title.substring(0, title.lastIndexOf(" - "));
+            if (elementCacheName != cacheName) {
+              continue;
+            }
+            InspectorTest.addSniffer(WebInspector.ServiceWorkerCacheModel.prototype, "_cacheRemoved", resolve)
+            cacheTreeElement._clearCache();
+            return;
+        }
+        console.error("Could not find cache to delete.");
+        reject();
+    }).catch(reject);
+  });
+  WebInspector.panels.resources.cacheStorageListTreeElement._refreshCaches();
+  return promise;
+}
+
+//###### CACHE STORAGE OPERATIONS ######
+
+InspectorTest.createCache = function(frameId, cacheName)
+{
+    return InspectorTest.evaluateWithPromise(frameId, "createCache", [cacheName]);
+};
+
+InspectorTest.addCacheEntry = function(frameId, cacheName, requestUrl, responseText)
+{
+    return InspectorTest.evaluateWithPromise(frameId, "addCacheEntry", [cacheName, requestUrl, responseText]);
+};
+
+InspectorTest.deleteCache = function(frameId, cacheName)
+{
+    return InspectorTest.evaluateWithPromise(frameId, "deleteCache", [cacheName]);
+};
+};
+
+function dispatchCallback(callbackId)
+{
+    console.log(callbackId);

[pfeldman, 2015/04/10 12:35:33]

InspectorTest.addResult

[dmurph, 2015/04/13 18:23:03]

Removed.

+}
+
+function onCacheStorageError(reject, e)
+{
+    console.error("CacheStorage error: " + e);
+    reject();
+}
+
+function createCache(resolve, reject, cacheName)
+{
+    caches.open(cacheName).then(resolve).catch(onCacheStorageError.bind(this, reject));
+}
+
+function addCacheEntry(resolve, reject, cacheName, requestUrl, responseText)
+{
+    caches.open(cacheName).then(function(cache) {
+            var request = new Request(requestUrl);
+            var myBlob = new Blob();
+            var init = { "status" : 200 , "statusText" : responseText };
+            var response = new Response(myBlob, init);
+            return cache.put(request, response);
+        }).then(resolve)
+          .catch(onCacheStorageError.bind(this, reject));
+}
+
+function deleteCache(resolve, reject, cacheName) {
+    caches.delete(cacheName).then(function(success) {
+            if (success) {
+                resolve();
+            } else {
+                onCacheStorageError(reject, "Could not find cache " + cacheName);
+            }
+        }).catch(onCacheStorageError.bind(this, reject));;
+}