Bug 965872 - Storage Inspector - actor for cookies, local storage and session storage, r=jwalker

browser/devtools/commandline/BuiltinCommands.jsm

@@ -957,7 +957,7 @@ XPCOMUtils.defineLazyModuleGetter(this, "Task",
       return host == null;
     }
     if (cookie.host.startsWith(".")) {
-      return cookie.host === "." + host;
+      return host.endsWith(cookie.host);
     }
     else {
       return cookie.host == host;

toolkit/devtools/server/actors/root.js

@@ -185,6 +185,10 @@ RootActor.prototype = {
         // tooltips for instance
         urlToImageDataResolver: true,
         networkMonitor: true,
+        // Wether the storage inspector actor to inspect cookies, etc.
+        storageInspector: true,
+        // Wether storage inspector is read only
+        storageInspectorReadOnly: true,
       }
     };
   },

toolkit/devtools/server/main.js

@@ -391,6 +391,7 @@ var DebuggerServer = {
     this.registerModule("devtools/server/actors/webgl");
     this.registerModule("devtools/server/actors/stylesheets");
     this.registerModule("devtools/server/actors/styleeditor");
+    this.registerModule("devtools/server/actors/storage");
     this.registerModule("devtools/server/actors/gcli");
     this.registerModule("devtools/server/actors/tracer");
     this.registerModule("devtools/server/actors/memory");

toolkit/devtools/server/moz.build

@@ -4,6 +4,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
+BROWSER_CHROME_MANIFESTS += ['tests/browser/browser.ini']
 MOCHITEST_CHROME_MANIFESTS += ['tests/mochitest/chrome.ini']
 XPCSHELL_TESTS_MANIFESTS += ['tests/unit/xpcshell.ini']
 

toolkit/devtools/server/tests/browser/browser.ini

@@ -0,0 +1,12 @@
+[DEFAULT]
+support-files =
+  head.js
+  storage-dynamic-windows.html
+  storage-listings.html
+  storage-unsecured-iframe.html
+  storage-updates.html
+  storage-secured-iframe.html
+
+[browser_storage_dynamic_windows.js]
+[browser_storage_listings.js]
+[browser_storage_updates.js]

toolkit/devtools/server/tests/browser/browser_storage_dynamic_windows.js

@@ -0,0 +1,289 @@
+const Cu = Components.utils;
+Cu.import("resource://gre/modules/Services.jsm");
+let tempScope = {};
+Cu.import("resource://gre/modules/devtools/dbg-client.jsm", tempScope);
+Cu.import("resource://gre/modules/devtools/dbg-server.jsm", tempScope);
+Cu.import("resource://gre/modules/Promise.jsm", tempScope);
+let {DebuggerServer, DebuggerClient, Promise} = tempScope;
+tempScope = null;
+
+const {StorageFront} = require("devtools/server/actors/storage");
+let gFront;
+
+const beforeReload = {
+  cookies: {
+    "test1.example.org": ["c1", "cs2", "c3", "uc1"],
+    "sectest1.example.org": ["uc1", "cs2"]
+  },
+  localStorage: {
+    "http://test1.example.org": ["ls1", "ls2"],
+    "http://sectest1.example.org": ["iframe-u-ls1"]
+  },
+  sessionStorage: {
+    "http://test1.example.org": ["ss1"],
+    "http://sectest1.example.org": ["iframe-u-ss1", "iframe-u-ss2"]
+  }
+};
+
+// Always log packets when running tests.
+Services.prefs.setBoolPref("devtools.debugger.log", true);
+registerCleanupFunction(function() {
+  Services.prefs.clearUserPref("devtools.debugger.log");
+});
+
+function finishTests(client) {
+  client.close(() => {
+    DebuggerServer.destroy();
+    DebuggerClient = DebuggerServer = gFront = null;
+    finish();
+  });
+}
+
+function testStores(data, client) {
+  testWindowsBeforeReload(data);
+  testReload().then(() =>
+  testAddIframe()).then(() =>
+  testRemoveIframe()).then(() =>
+  finishTests(client));
+}
+
+function testWindowsBeforeReload(data) {
+  for (let storageType in beforeReload) {
+    ok(data[storageType], storageType + " storage actor is present");
+    is(Object.keys(data[storageType].hosts).length,
+       Object.keys(beforeReload[storageType]).length,
+       "Number of hosts for " + storageType + "match");
+    for (let host in beforeReload[storageType]) {
+      ok(data[storageType].hosts[host], "Host " + host + " is present");
+    }
+  }
+}
+
+function markOutMatched(toBeEmptied, data, deleted) {
+  if (!Object.keys(toBeEmptied).length) {
+    info("Object empty")
+    return;
+  }
+  ok(Object.keys(data).length,
+     "Atleast some storage types should be present in deleted");
+  for (let storageType in toBeEmptied) {
+    if (!data[storageType]) {
+      continue;
+    }
+    info("Testing for " + storageType);
+    for (let host in data[storageType]) {
+      ok(toBeEmptied[storageType][host], "Host " + host + " found");
+      if (!deleted) {
+        for (let item of data[storageType][host]) {
+          let index = toBeEmptied[storageType][host].indexOf(item);
+          ok(index > -1, "Item found - " + item);
+          if (index > -1) {
+            toBeEmptied[storageType][host].splice(index, 1);
+          }
+        }
+        if (!toBeEmptied[storageType][host].length) {
+          delete toBeEmptied[storageType][host];
+        }
+      }
+      else {
+        delete toBeEmptied[storageType][host];
+      }
+    }
+    if (!Object.keys(toBeEmptied[storageType]).length) {
+      delete toBeEmptied[storageType];
+    }
+  }
+}
+
+function testReload() {
+  info("Testing if reload works properly");
+
+  let shouldBeEmptyFirst = Cu.cloneInto(beforeReload,  {});
+  let shouldBeEmptyLast = Cu.cloneInto(beforeReload,  {});
+  let reloaded = Promise.defer();
+
+  let onStoresUpdate = data => {
+    info("in stores update of testReload");
+    // This might be second time stores update is happening, in which case,
+    // data.deleted will be null
+    if (data.deleted) {
+      markOutMatched(shouldBeEmptyFirst, data.deleted, true);
+    }
+
+    if (!Object.keys(shouldBeEmptyFirst).length) {
+      info("shouldBeEmptyFirst is empty now");
+    }
+    else if (!data.added || !Object.keys(data.added).length) {
+      ok(false, "deleted object should have something if an added object " +
+         "does not have anything");
+      endTestReloaded();
+    }
+
+    // stores-update call might not have data.added for the first time on slow
+    // machines, in which case, data.added will be null
+    if (data.added) {
+      markOutMatched(shouldBeEmptyLast, data.added);
+    }
+
+    if (!Object.keys(shouldBeEmptyLast).length) {
+      info("Everything to be received is received.");
+      endTestReloaded();
+    }
+  };
+
+  let endTestReloaded = () => {
+    gFront.off("stores-update", onStoresUpdate);
+    reloaded.resolve();
+  };
+
+  gFront.on("stores-update", onStoresUpdate);
+
+  content.location.reload();
+  return reloaded.promise;
+}
+
+function testAddIframe() {
+  info("Testing if new iframe addition works properly");
+  let reloaded = Promise.defer();
+
+  let shouldBeEmpty = {
+    localStorage: {
+      "https://sectest1.example.org": ["iframe-s-ls1"]
+    },
+    sessionStorage: {
+      "https://sectest1.example.org": ["iframe-s-ss1"]
+    },
+    cookies: {
+      "sectest1.example.org": ["sc1"]
+    }
+  };
+
+  let onStoresUpdate = data => {
+    info("checking if the hosts list is correct for this iframe addition");
+
+    markOutMatched(shouldBeEmpty, data.added);
+
+    ok(!data.changed || !data.changed.cookies ||
+       !data.changed.cookies["https://sectest1.example.org"],
+       "Nothing got changed for cookies");
+    ok(!data.changed || !data.changed.localStorage ||
+       !data.changed.localStorage["https://sectest1.example.org"],
+       "Nothing got changed for local storage");
+    ok(!data.changed || !data.changed.sessionStorage ||
+       !data.changed.sessionStorage["https://sectest1.example.org"],
+       "Nothing got changed for session storage");
+
+    ok(!data.deleted || !data.deleted.cookies ||
+       !data.deleted.cookies["https://sectest1.example.org"],
+       "Nothing got deleted for cookies");
+    ok(!data.deleted || !data.deleted.localStorage ||
+       !data.deleted.localStorage["https://sectest1.example.org"],
+       "Nothing got deleted for local storage");
+    ok(!data.deleted || !data.deleted.sessionStorage ||
+       !data.deleted.sessionStorage["https://sectest1.example.org"],
+       "Nothing got deleted for session storage");
+
+    if (!Object.keys(shouldBeEmpty).length) {
+      info("Everything to be received is received.");
+      endTestReloaded();
+    }
+  };
+
+  let endTestReloaded = () => {
+    gFront.off("stores-update", onStoresUpdate);
+    reloaded.resolve();
+  };
+
+  gFront.on("stores-update", onStoresUpdate);
+
+  let iframe = content.document.createElement("iframe");
+  iframe.src = ALT_DOMAIN_SECURED + "storage-secured-iframe.html";
+  content.document.querySelector("body").appendChild(iframe);
+  return reloaded.promise;
+}
+
+function testRemoveIframe() {
+  info("Testing if iframe removal works properly");
+  let reloaded = Promise.defer();
+
+  let shouldBeEmpty = {
+    localStorage: {
+      "http://sectest1.example.org": []
+    },
+    sessionStorage: {
+      "http://sectest1.example.org": []
+    }
+  };
+
+  let onStoresUpdate = data => {
+    info("checking if the hosts list is correct for this iframe deletion");
+
+    markOutMatched(shouldBeEmpty, data.deleted, true);
+
+    ok(!data.deleted.cookies || !data.deleted.cookies["sectest1.example.org"],
+       "Nothing got deleted for Cookies as the same hostname is still present");
+
+    ok(!data.changed || !data.changed.cookies ||
+       !data.changed.cookies["http://sectest1.example.org"],
+       "Nothing got changed for cookies");
+    ok(!data.changed || !data.changed.localStorage ||
+       !data.changed.localStorage["http://sectest1.example.org"],
+       "Nothing got changed for local storage");
+    ok(!data.changed || !data.changed.sessionStorage ||
+       !data.changed.sessionStorage["http://sectest1.example.org"],
+       "Nothing got changed for session storage");
+
+    ok(!data.added || !data.added.cookies ||
+       !data.added.cookies["http://sectest1.example.org"],
+       "Nothing got added for cookies");
+    ok(!data.added || !data.added.localStorage ||
+       !data.added.localStorage["http://sectest1.example.org"],
+       "Nothing got added for local storage");
+    ok(!data.added || !data.added.sessionStorage ||
+       !data.added.sessionStorage["http://sectest1.example.org"],
+       "Nothing got added for session storage");
+
+    if (!Object.keys(shouldBeEmpty).length) {
+      info("Everything to be received is received.");
+      endTestReloaded();
+    }
+  };
+
+  let endTestReloaded = () => {
+    gFront.off("stores-update", onStoresUpdate);
+    reloaded.resolve();
+  };
+
+  gFront.on("stores-update", onStoresUpdate);
+
+  for (let iframe of content.document.querySelectorAll("iframe")) {
+    if (iframe.src.startsWith("http:")) {
+      iframe.remove();
+      break;
+    }
+  }
+  return reloaded.promise;
+}
+
+function test() {
+  waitForExplicitFinish();
+  addTab(MAIN_DOMAIN + "storage-dynamic-windows.html", function() {
+    try {
+      // Sometimes debugger server does not get destroyed correctly by previous
+      // tests.
+      DebuggerServer.destroy();
+    } catch (ex) { }
+    DebuggerServer.init(function () { return true; });
+    DebuggerServer.addBrowserActors();
+
+    let client = new DebuggerClient(DebuggerServer.connectPipe());
+    client.connect(function onConnect() {
+      client.listTabs(function onListTabs(aResponse) {
+        let form = aResponse.tabs[aResponse.selected];
+        gFront = StorageFront(client, form);
+
+        gFront.listStores().then(data => testStores(data, client));
+      });
+    });
+  })
+}

toolkit/devtools/server/tests/browser/browser_storage_listings.js

@@ -0,0 +1,291 @@
+const Cu = Components.utils;
+Cu.import("resource://gre/modules/Services.jsm");
+let tempScope = {};
+Cu.import("resource://gre/modules/devtools/dbg-client.jsm", tempScope);
+Cu.import("resource://gre/modules/devtools/dbg-server.jsm", tempScope);
+let {DebuggerServer, DebuggerClient} = tempScope;
+tempScope = null;
+
+const {StorageFront} = require("devtools/server/actors/storage");
+
+// Always log packets when running tests.
+Services.prefs.setBoolPref("devtools.debugger.log", true);
+registerCleanupFunction(function() {
+  Services.prefs.clearUserPref("devtools.debugger.log");
+});
+
+const storeMap = {
+  cookies: {
+    "test1.example.org": [
+      {
+        name: "c1",
+        value: "foobar",
+        expires: 2000000000000,
+        path: "/browser",
+        host: "test1.example.org",
+        isDomain: false,
+        isSecure: false,
+      },
+      {
+        name: "cs2",
+        value: "sessionCookie",
+        path: "/",
+        host: ".example.org",
+        expires: 0,
+        isDomain: true,
+        isSecure: false,
+      },
+      {
+        name: "c3",
+        value: "foobar-2",
+        expires: 2000000001000,
+        path: "/",
+        host: "test1.example.org",
+        isDomain: false,
+        isSecure: true,
+      },
+      {
+        name: "uc1",
+        value: "foobar",
+        host: ".example.org",
+        path: "/",
+        expires: 0,
+        isDomain: true,
+        isSecure: true,
+      }
+    ],
+    "sectest1.example.org": [
+      {
+        name: "uc1",
+        value: "foobar",
+        host: ".example.org",
+        path: "/",
+        expires: 0,
+        isDomain: true,
+        isSecure: true,
+      },
+      {
+        name: "cs2",
+        value: "sessionCookie",
+        path: "/",
+        host: ".example.org",
+        expires: 0,
+        isDomain: true,
+        isSecure: false,
+      },
+      {
+        name: "sc1",
+        value: "foobar",
+        path: "/browser/toolkit/devtools/server/tests/browser/",
+        host: "sectest1.example.org",
+        expires: 0,
+        isDomain: false,
+        isSecure: false,
+      }
+    ]
+  },
+  localStorage: {
+    "http://test1.example.org": [
+      {
+        name: "ls1",
+        value: "foobar"
+      },
+      {
+        name: "ls2",
+        value: "foobar-2"
+      }
+    ],
+    "http://sectest1.example.org": [
+      {
+        name: "iframe-u-ls1",
+        value: "foobar"
+      }
+    ],
+    "https://sectest1.example.org": [
+      {
+        name: "iframe-s-ls1",
+        value: "foobar"
+      }
+    ]
+  },
+  sessionStorage: {
+    "http://test1.example.org": [
+      {
+        name: "ss1",
+        value: "foobar-3"
+      }
+    ],
+    "http://sectest1.example.org": [
+      {
+        name: "iframe-u-ss1",
+        value: "foobar1"
+      },
+      {
+        name: "iframe-u-ss2",
+        value: "foobar2"
+      }
+    ],
+    "https://sectest1.example.org": [
+      {
+        name: "iframe-s-ss1",
+        value: "foobar-2"
+      }
+    ]
+  }
+};
+
+function finishTests(client) {
+  client.close(() => {
+    DebuggerServer.destroy();
+    DebuggerClient = DebuggerServer = null;
+    finish();
+  });
+}
+
+function testStores(data, client) {
+  ok(data.cookies, "Cookies storage actor is present");
+  ok(data.localStorage, "Local Storage storage actor is present");
+  ok(data.sessionStorage, "Session Storage storage actor is present");
+  testCookies(data.cookies).then(() =>
+  testLocalStorage(data.localStorage)).then(() =>
+  testSessionStorage(data.sessionStorage)).then(() =>
+  finishTests(client));
+}
+
+function testCookies(cookiesActor) {
+  is(Object.keys(cookiesActor.hosts).length, 2, "Correct number of host entries for cookies");
+  return testCookiesObjects(0, cookiesActor.hosts, cookiesActor);
+}
+
+function testCookiesObjects(index, hosts, cookiesActor) {
+  let host = Object.keys(hosts)[index];
+  let matchItems = data => {
+    is(data.total, storeMap.cookies[host].length,
+       "Number of cookies in host " + host + " matches");
+    for (let item of data.data) {
+      let found = false;
+      for (let toMatch of storeMap.cookies[host]) {
+        if (item.name == toMatch.name) {
+          found = true;
+          ok(true, "Found cookie " + item.name + " in response");
+          is(item.value.str, toMatch.value, "The value matches.");
+          is(item.expires, toMatch.expires, "The expiry time matches.");
+          is(item.path, toMatch.path, "The path matches.");
+          is(item.host, toMatch.host, "The host matches.");
+          is(item.isSecure, toMatch.isSecure, "The isSecure value matches.");
+          is(item.isDomain, toMatch.isDomain, "The isDomain value matches.");
+          break;
+        }
+      }
+      if (!found) {
+        ok(false, "cookie " + item.name + " should not exist in response;");
+      }
+    }
+  };
+
+  ok(!!storeMap.cookies[host], "Host is present in the list : " + host);
+  if (index == Object.keys(hosts).length - 1) {
+    return cookiesActor.getStoreObjects(host).then(matchItems);
+  }
+  return cookiesActor.getStoreObjects(host).then(matchItems).then(() => {
+    return testCookiesObjects(++index, hosts, cookiesActor);
+  });
+}
+
+function testLocalStorage(localStorageActor) {
+  is(Object.keys(localStorageActor.hosts).length, 3,
+     "Correct number of host entries for local storage");
+  return testLocalStorageObjects(0, localStorageActor.hosts, localStorageActor);
+}
+
+function testLocalStorageObjects(index, hosts, localStorageActor) {
+  let host = Object.keys(hosts)[index];
+  let matchItems = data => {
+    is(data.total, storeMap.localStorage[host].length,
+       "Number of local storage items in host " + host + " matches");
+    for (let item of data.data) {
+      let found = false;
+      for (let toMatch of storeMap.localStorage[host]) {
+        if (item.name == toMatch.name) {
+          found = true;
+          ok(true, "Found local storage item " + item.name + " in response");
+          is(item.value.str, toMatch.value, "The value matches.");
+          break;
+        }
+      }
+      if (!found) {
+        ok(false, "local storage item " + item.name +
+                  " should not exist in response;");
+      }
+    }
+  };
+
+  ok(!!storeMap.localStorage[host], "Host is present in the list : " + host);
+  if (index == Object.keys(hosts).length - 1) {
+    return localStorageActor.getStoreObjects(host).then(matchItems);
+  }
+  return localStorageActor.getStoreObjects(host).then(matchItems).then(() => {
+    return testLocalStorageObjects(++index, hosts, localStorageActor);
+  });
+}
+
+function testSessionStorage(sessionStorageActor) {
+  is(Object.keys(sessionStorageActor.hosts).length, 3,
+     "Correct number of host entries for session storage");
+  return testSessionStorageObjects(0, sessionStorageActor.hosts,
+                                   sessionStorageActor);
+}
+
+function testSessionStorageObjects(index, hosts, sessionStorageActor) {
+  let host = Object.keys(hosts)[index];
+  let matchItems = data => {
+    is(data.total, storeMap.sessionStorage[host].length,
+       "Number of session storage items in host " + host + " matches");
+    for (let item of data.data) {
+      let found = false;
+      for (let toMatch of storeMap.sessionStorage[host]) {
+        if (item.name == toMatch.name) {
+          found = true;
+          ok(true, "Found session storage item " + item.name + " in response");
+          is(item.value.str, toMatch.value, "The value matches.");
+          break;
+        }
+      }
+      if (!found) {
+        ok(false, "session storage item " + item.name +
+                  " should not exist in response;");
+      }
+    }
+  };
+
+  ok(!!storeMap.sessionStorage[host], "Host is present in the list : " + host);
+  if (index == Object.keys(hosts).length - 1) {
+    return sessionStorageActor.getStoreObjects(host).then(matchItems);
+  }
+  return sessionStorageActor.getStoreObjects(host).then(matchItems).then(() => {
+    return testSessionStorageObjects(++index, hosts, sessionStorageActor);
+  });
+}
+
+function test() {
+  waitForExplicitFinish();
+  addTab(MAIN_DOMAIN + "storage-listings.html", function() {
+    try {
+      // Sometimes debugger server does not get destroyed correctly by previous
+      // tests.
+      DebuggerServer.destroy();
+    } catch (ex) { }
+    DebuggerServer.init(function () { return true; });
+    DebuggerServer.addBrowserActors();
+
+    let client = new DebuggerClient(DebuggerServer.connectPipe());
+    client.connect(function onConnect() {
+      client.listTabs(function onListTabs(aResponse) {
+        let form = aResponse.tabs[aResponse.selected];
+        let front = StorageFront(client, form);
+
+        front.listStores().then(data => testStores(data, client));
+      });
+    });
+  })
+}

toolkit/devtools/server/tests/browser/browser_storage_updates.js

@@ -0,0 +1,258 @@
+const Cu = Components.utils;
+Cu.import("resource://gre/modules/Services.jsm");
+let tempScope = {};
+Cu.import("resource://gre/modules/devtools/dbg-client.jsm", tempScope);
+Cu.import("resource://gre/modules/devtools/dbg-server.jsm", tempScope);
+Cu.import("resource://gre/modules/Promise.jsm", tempScope);
+let {DebuggerServer, DebuggerClient, Promise} = tempScope;
+tempScope = null;
+
+const {StorageFront} = require("devtools/server/actors/storage");
+let gTests;
+let gExpected;
+let index = 0;
+
+const beforeReload = {
+  cookies: ["test1.example.org", "sectest1.example.org"],
+  localStorage: ["http://test1.example.org", "http://sectest1.example.org"],
+  sessionStorage: ["http://test1.example.org", "http://sectest1.example.org"],
+};
+
+// Always log packets when running tests.
+Services.prefs.setBoolPref("devtools.debugger.log", true);
+registerCleanupFunction(function() {
+  Services.prefs.clearUserPref("devtools.debugger.log");
+});
+
+function finishTests(client) {
+  client.close(() => {
+    DebuggerServer.destroy();
+    DebuggerClient = DebuggerServer = gTests = null;
+    finish();
+  });
+}
+
+function markOutMatched(toBeEmptied, data, deleted) {
+  if (!Object.keys(toBeEmptied).length) {
+    info("Object empty")
+    return;
+  }
+  ok(Object.keys(data).length,
+     "Atleast some storage types should be present in deleted");
+  for (let storageType in toBeEmptied) {
+    if (!data[storageType]) {
+      continue;
+    }
+    info("Testing for " + storageType);
+    for (let host in data[storageType]) {
+      ok(toBeEmptied[storageType][host], "Host " + host + " found");
+
+      for (let item of data[storageType][host]) {
+        let index = toBeEmptied[storageType][host].indexOf(item);
+        ok(index > -1, "Item found - " + item);
+        if (index > -1) {
+          toBeEmptied[storageType][host].splice(index, 1);
+        }
+      }
+      if (!toBeEmptied[storageType][host].length) {
+        delete toBeEmptied[storageType][host];
+      }
+    }
+    if (!Object.keys(toBeEmptied[storageType]).length) {
+      delete toBeEmptied[storageType];
+    }
+  }
+}
+
+function onStoresCleared(data) {
+  if (data.sessionStorage || data.localStorage) {
+    let hosts = data.sessionStorage || data.localStorage;
+    info("Stores cleared required for session storage");
+    is(hosts.length, 1, "number of hosts is 1");
+    is(hosts[0], "http://test1.example.org",
+       "host matches for " + Object.keys(data)[0]);
+    gTests.next();
+  }
+  else {
+    ok(false, "Stores cleared should only be for local and sesion storage");
+  }
+
+}
+
+function onStoresUpdate({added, changed, deleted}) {
+  info("inside stores update for index " + index);
+
+  // Here, added, changed and deleted might be null even if they are required as
+  // per gExpected. This is fine as they might come in the next stores-update
+  // call or have already come in the previous one.
+  if (added) {
+    info("matching added object for index " + index);
+    markOutMatched(gExpected.added, added);
+  }
+  if (changed) {
+    info("matching changed object for index " + index);
+    markOutMatched(gExpected.changed, changed);
+  }
+  if (deleted) {
+    info("matching deleted object for index " + index);
+    markOutMatched(gExpected.deleted, deleted);
+  }
+
+  if ((!gExpected.added || !Object.keys(gExpected.added).length) &&
+      (!gExpected.changed || !Object.keys(gExpected.changed).length) &&
+      (!gExpected.deleted || !Object.keys(gExpected.deleted).length)) {
+    info("Everything expected has been received for index " + index);
+    index++;
+    gTests.next();
+  }
+  else {
+    info("Still some updates pending for index " + index);
+  }
+}
+
+function* UpdateTests(front, win, client) {
+  front.on("stores-update", onStoresUpdate);
+
+  // index 0
+  gExpected = {
+    added: {
+      cookies: {
+        "test1.example.org": ["c1", "c2"]
+      },
+      localStorage: {
+        "http://test1.example.org": ["l1"]
+      }
+    }
+  };
+  win.addCookie("c1", "foobar1");
+  win.addCookie("c2", "foobar2");
+  win.localStorage.setItem("l1", "foobar1");
+  yield undefined;
+
+  // index 1
+  gExpected = {
+    changed: {
+      cookies: {
+        "test1.example.org": ["c1"]
+      }
+    },
+    added: {
+      localStorage: {
+        "http://test1.example.org": ["l2"]
+      }
+    }
+  };
+  win.addCookie("c1", "new_foobar1");
+  win.localStorage.setItem("l2", "foobar2");
+  yield undefined;
+
+  // index 2
+  gExpected = {
+    deleted: {
+      cookies: {
+        "test1.example.org": ["c2"]
+      },
+      localStorage: {
+        "http://test1.example.org": ["l1"]
+      }
+    },
+    added: {
+      localStorage: {
+        "http://test1.example.org": ["l3"]
+      }
+    }
+  };
+  win.removeCookie("c2");
+  win.localStorage.removeItem("l1");
+  win.localStorage.setItem("l3", "foobar3");
+  yield undefined;
+
+  // index 3
+  gExpected = {
+    added: {
+      cookies: {
+        "test1.example.org": ["c3"]
+      },
+      sessionStorage: {
+        "http://test1.example.org": ["s1", "s2"]
+      }
+    },
+    changed: {
+      localStorage: {
+        "http://test1.example.org": ["l3"]
+      }
+    },
+    deleted: {
+      cookies: {
+        "test1.example.org": ["c1"]
+      },
+      localStorage: {
+        "http://test1.example.org": ["l2"]
+      }
+    }
+  };
+  win.removeCookie("c1");
+  win.addCookie("c3", "foobar3");
+  win.localStorage.removeItem("l2");
+  win.sessionStorage.setItem("s1", "foobar1");
+  win.sessionStorage.setItem("s2", "foobar2");
+  win.localStorage.setItem("l3", "new_foobar3");
+  yield undefined;
+
+  // index 4
+  gExpected = {
+    deleted: {
+      sessionStorage: {
+        "http://test1.example.org": ["s1"]
+      }
+    }
+  };
+  win.sessionStorage.removeItem("s1");
+  yield undefined;
+
+  // index 5
+  gExpected = {
+    deleted: {
+      cookies: {
+        "test1.example.org": ["c3"]
+      }
+    }
+  };
+  front.on("stores-cleared", onStoresCleared);
+  win.clear();
+  yield undefined;
+  // Another 2 more yield undefined s so as to wait for the "stores-cleared" to
+  // fire. One for Local Storage and other for Session Storage
+  yield undefined;
+  yield undefined;
+
+  front.off("stores-cleared", onStoresCleared);
+  front.off("stores-update", onStoresUpdate);
+  finishTests(client);
+}
+
+
+function test() {
+  waitForExplicitFinish();
+  addTab(MAIN_DOMAIN + "storage-updates.html", function(doc) {
+    try {
+      // Sometimes debugger server does not get destroyed correctly by previous
+      // tests.
+      DebuggerServer.destroy();
+    } catch (ex) { }
+    DebuggerServer.init(function () { return true; });
+    DebuggerServer.addBrowserActors();
+
+    let client = new DebuggerClient(DebuggerServer.connectPipe());
+    client.connect(function onConnect() {
+      client.listTabs(function onListTabs(aResponse) {
+        let form = aResponse.tabs[aResponse.selected];
+        let front = StorageFront(client, form);
+        gTests = UpdateTests(front, doc.defaultView.wrappedJSObject,
+                             client);
+        // Make an initial call to initialize the actor
+        front.listStores().then(() => gTests.next());
+      });
+    });
+  })
+}

toolkit/devtools/server/tests/browser/head.js

@@ -0,0 +1,43 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+let tempScope = {};
+Cu.import("resource://gre/modules/devtools/Loader.jsm", tempScope);
+Cu.import("resource://gre/modules/devtools/Console.jsm", tempScope);
+const require = tempScope.devtools.require;
+const console = tempScope.console;
+tempScope = null;
+const PATH = "browser/toolkit/devtools/server/tests/browser/";
+const MAIN_DOMAIN = "http://test1.example.org/" + PATH;
+const ALT_DOMAIN = "http://sectest1.example.org/" + PATH;
+const ALT_DOMAIN_SECURED = "https://sectest1.example.org:443/" + PATH;
+
+/**
+ * Open a new tab at a URL and call a callback on load
+ */
+function addTab(aURL, aCallback)
+{
+  waitForExplicitFinish();
+
+  gBrowser.selectedTab = gBrowser.addTab();
+  content.location = aURL;
+
+  let tab = gBrowser.selectedTab;
+  let browser = gBrowser.getBrowserForTab(tab);
+
+  function onTabLoad(event) {
+    if (event.originalTarget.location.href != aURL) {
+      return;
+    }
+    browser.removeEventListener("load", onTabLoad, true);
+    aCallback(browser.contentDocument);
+  }
+
+  browser.addEventListener("load", onTabLoad, true);
+}
+
+registerCleanupFunction(function tearDown() {
+  while (gBrowser.tabs.length > 1) {
+    gBrowser.removeCurrentTab();
+  }
+});

toolkit/devtools/server/tests/browser/storage-dynamic-windows.html

@@ -0,0 +1,39 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Bug 965872 - Storage inspector actor with cookies, local storage and session storage.
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Storage inspector test for listing hosts and storages</title>
+</head>
+<body>
+<iframe src="http://sectest1.example.org/browser/toolkit/devtools/server/tests/browser/storage-unsecured-iframe.html"></iframe>
+<script>
+
+var partialHostname = location.hostname.match(/^[^.]+(\..*)$/)[1];
+var cookieExpiresTime1 = 2000000000000;
+var cookieExpiresTime2 = 2000000001000;
+// Setting up some cookies to eat.
+document.cookie = "c1=foobar; expires=" +
+  new Date(cookieExpiresTime1).toGMTString() + "; path=/browser";
+document.cookie = "cs2=sessionCookie; path=/; domain=" + partialHostname;
+document.cookie = "c3=foobar-2; expires=" +
+  new Date(cookieExpiresTime2).toGMTString() + "; path=/";
+// ... and some local storage items ..
+localStorage.setItem("ls1", "foobar");
+localStorage.setItem("ls2", "foobar-2");
+// ... and finally some session storage items too
+sessionStorage.setItem("ss1", "foobar-3");
+console.log("added cookies and stuff from main page");
+
+window.onunload = function() {
+  document.cookie = "c1=; expires=Thu, 01 Jan 1970 00:00:00 GMT";
+  document.cookie = "c3=; expires=Thu, 01 Jan 1970 00:00:00 GMT";
+  localStorage.clear();
+  sessionStorage.clear();
+  console.log("removed cookies and stuff from main page");
+}
+</script>
+</body>
+</html>

toolkit/devtools/server/tests/browser/storage-listings.html

@@ -0,0 +1,40 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Bug 965872 - Storage inspector actor with cookies, local storage and session storage.
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Storage inspector test for listing hosts and storages</title>
+</head>
+<body>
+<iframe src="http://sectest1.example.org/browser/toolkit/devtools/server/tests/browser/storage-unsecured-iframe.html"></iframe>
+<iframe src="https://sectest1.example.org:443/browser/toolkit/devtools/server/tests/browser/storage-secured-iframe.html"></iframe>
+<script>
+
+var partialHostname = location.hostname.match(/^[^.]+(\..*)$/)[1];
+var cookieExpiresTime1 = 2000000000000;
+var cookieExpiresTime2 = 2000000001000;
+// Setting up some cookies to eat.
+document.cookie = "c1=foobar; expires=" +
+  new Date(cookieExpiresTime1).toGMTString() + "; path=/browser";
+document.cookie = "cs2=sessionCookie; path=/; domain=" + partialHostname;
+document.cookie = "c3=foobar-2; secure=true; expires=" +
+  new Date(cookieExpiresTime2).toGMTString() + "; path=/";
+// ... and some local storage items ..
+localStorage.setItem("ls1", "foobar");
+localStorage.setItem("ls2", "foobar-2");
+// ... and finally some session storage items too
+sessionStorage.setItem("ss1", "foobar-3");
+console.log("added cookies and stuff from main page");
+
+window.onunload = function() {
+  document.cookie = "c1=; expires=Thu, 01 Jan 1970 00:00:00 GMT";
+  document.cookie = "c3=; expires=Thu, 01 Jan 1970 00:00:00 GMT";
+  localStorage.clear();
+  sessionStorage.clear();
+  console.log("removed cookies and stuff from main page");
+}
+</script>
+</body>
+</html>

toolkit/devtools/server/tests/browser/storage-secured-iframe.html

@@ -0,0 +1,24 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Iframe for testing multiple host detetion in storage actor
+-->
+<head>
+  <meta charset="utf-8">
+</head>
+<body>
+<script>
+
+document.cookie = "sc1=foobar;";
+localStorage.setItem("iframe-s-ls1", "foobar");
+sessionStorage.setItem("iframe-s-ss1", "foobar-2");
+console.log("added cookies and stuff from secured iframe");
+
+window.onunload = function() {
+  localStorage.clear();
+  sessionStorage.clear();
+  console.log("removed cookies and stuff from secured iframe");
+}
+</script>
+</body>
+</html>

toolkit/devtools/server/tests/browser/storage-unsecured-iframe.html

@@ -0,0 +1,25 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Iframe for testing multiple host detetion in storage actor
+-->
+<head>
+  <meta charset="utf-8">
+</head>
+<body>
+<script>
+
+document.cookie = "uc1=foobar; domain=.example.org; path=/; secure=true";
+localStorage.setItem("iframe-u-ls1", "foobar");
+sessionStorage.setItem("iframe-u-ss1", "foobar1");
+sessionStorage.setItem("iframe-u-ss2", "foobar2");
+console.log("added cookies and stuff from unsecured iframe");
+
+window.onunload = function() {
+  localStorage.clear();
+  sessionStorage.clear();
+  console.log("removed cookies and stuff from unsecured iframe");
+}
+</script>
+</body>
+</html>

toolkit/devtools/server/tests/browser/storage-updates.html

@@ -0,0 +1,44 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Bug 965872 - Storage inspector actor with cookies, local storage and session storage.
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Storage inspector blank html for tests</title>
+</head>
+<body>
+<script>
+
+window.addCookie = function(name, value, path, domain, expires, secure) {
+  var cookieString = name + "=" + value + ";";
+  if (path) {
+    cookieString += "path=" + path + ";";
+  }
+  if (domain) {
+    cookieString += "domain=" + domain + ";";
+  }
+  if (expires) {
+    cookieString += "expires=" + expires + ";";
+  }
+  if (secure) {
+    cookieString += "secure=true;";
+  }
+  document.cookie = cookieString;
+};
+
+window.removeCookie = function(name) {
+  document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
+}
+
+window.clear = function() {
+  var cookies = document.cookie;
+  for (var cookie of cookies.split(";")) {
+    removeCookie(cookie.split("=")[0]);
+  }
+  localStorage.clear();
+  sessionStorage.clear();
+}
+</script>
+</body>
+</html>