diff -r 000000000000 -r 6474c204b198 dom/indexedDB/test/helpers.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/indexedDB/test/helpers.js	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,277 @@
+/**
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+var testGenerator = testSteps();
+var archiveReaderEnabled = false;
+
+// The test js is shared between xpcshell (which has no SpecialPowers object)
+// and content mochitests (where the |Components| object is accessible only as
+// SpecialPowers.Components). Expose Components if necessary here to make things
+// work everywhere.
+//
+// Even if the real |Components| doesn't exist, we might shim in a simple JS
+// placebo for compat. An easy way to differentiate this from the real thing
+// is whether the property is read-only or not.
+var c = Object.getOwnPropertyDescriptor(this, 'Components');
+if ((!c.value || c.writable) && typeof SpecialPowers === 'object')
+  Components = SpecialPowers.Components;
+
+function executeSoon(aFun)
+{
+  let comp = SpecialPowers.wrap(Components);
+
+  let thread = comp.classes["@mozilla.org/thread-manager;1"]
+                   .getService(comp.interfaces.nsIThreadManager)
+                   .mainThread;
+
+  thread.dispatch({
+    run: function() {
+      aFun();
+    }
+  }, Components.interfaces.nsIThread.DISPATCH_NORMAL);
+}
+
+function clearAllDatabases(callback) {
+  function runCallback() {
+    SimpleTest.executeSoon(function () { callback(); });
+  }
+
+  if (!SpecialPowers.isMainProcess()) {
+    runCallback();
+    return;
+  }
+
+  let comp = SpecialPowers.wrap(Components);
+
+  let quotaManager =
+    comp.classes["@mozilla.org/dom/quota/manager;1"]
+        .getService(comp.interfaces.nsIQuotaManager);
+
+  let uri = SpecialPowers.wrap(document).documentURIObject;
+
+  // We need to pass a JS callback to getUsageForURI. However, that callback
+  // takes an XPCOM URI object, which will cause us to throw when we wrap it
+  // for the content compartment. So we need to define the function in a
+  // privileged scope, which we do using a sandbox.
+  var sysPrin = SpecialPowers.Services.scriptSecurityManager.getSystemPrincipal();
+  var sb = new SpecialPowers.Cu.Sandbox(sysPrin);
+  sb.ok = ok;
+  sb.runCallback = runCallback;
+  var cb = SpecialPowers.Cu.evalInSandbox((function(uri, usage, fileUsage) {
+    if (usage) {
+      ok(false,
+         "getUsageForURI returned non-zero usage after clearing all " +
+         "storages!");
+    }
+    runCallback();
+  }).toSource(), sb);
+
+  quotaManager.clearStoragesForURI(uri);
+  quotaManager.getUsageForURI(uri, cb);
+}
+
+if (!window.runTest) {
+  window.runTest = function(limitedQuota)
+  {
+    SimpleTest.waitForExplicitFinish();
+
+    if (limitedQuota) {
+      denyUnlimitedQuota();
+    }
+    else {
+      allowUnlimitedQuota();
+    }
+
+    enableExperimental();
+    enableArchiveReader();
+
+    clearAllDatabases(function () { testGenerator.next(); });
+  }
+}
+
+function finishTest()
+{
+  resetUnlimitedQuota();
+  resetExperimental();
+  resetArchiveReader();
+  SpecialPowers.notifyObserversInParentProcess(null, "disk-space-watcher",
+                                               "free");
+
+  SimpleTest.executeSoon(function() {
+    testGenerator.close();
+    //clearAllDatabases(function() { SimpleTest.finish(); });
+    SimpleTest.finish();
+  });
+}
+
+function browserRunTest()
+{
+  testGenerator.next();
+}
+
+function browserFinishTest()
+{
+  setTimeout(function() { testGenerator.close(); }, 0);
+}
+
+function grabEventAndContinueHandler(event)
+{
+  testGenerator.send(event);
+}
+
+function continueToNextStep()
+{
+  SimpleTest.executeSoon(function() {
+    testGenerator.next();
+  });
+}
+
+function continueToNextStepSync()
+{
+  testGenerator.next();
+}
+
+function errorHandler(event)
+{
+  ok(false, "indexedDB error, '" + event.target.error.name + "'");
+  finishTest();
+}
+
+function browserErrorHandler(event)
+{
+  browserFinishTest();
+  throw new Error("indexedDB error (" + event.code + "): " + event.message);
+}
+
+function unexpectedSuccessHandler()
+{
+  ok(false, "Got success, but did not expect it!");
+  finishTest();
+}
+
+function expectedErrorHandler(name)
+{
+  return function(event) {
+    is(event.type, "error", "Got an error event");
+    is(event.target.error.name, name, "Expected error was thrown.");
+    event.preventDefault();
+    grabEventAndContinueHandler(event);
+  };
+}
+
+function ExpectError(name, preventDefault)
+{
+  this._name = name;
+  this._preventDefault = preventDefault;
+}
+ExpectError.prototype = {
+  handleEvent: function(event)
+  {
+    is(event.type, "error", "Got an error event");
+    is(event.target.error.name, this._name, "Expected error was thrown.");
+    if (this._preventDefault) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+    grabEventAndContinueHandler(event);
+  }
+};
+
+function compareKeys(k1, k2) {
+  let t = typeof k1;
+  if (t != typeof k2)
+    return false;
+
+  if (t !== "object")
+    return k1 === k2;
+
+  if (k1 instanceof Date) {
+    return (k2 instanceof Date) &&
+      k1.getTime() === k2.getTime();
+  }
+
+  if (k1 instanceof Array) {
+    if (!(k2 instanceof Array) ||
+        k1.length != k2.length)
+      return false;
+
+    for (let i = 0; i < k1.length; ++i) {
+      if (!compareKeys(k1[i], k2[i]))
+        return false;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+function addPermission(type, allow, url)
+{
+  if (!url) {
+    url = window.document;
+  }
+  SpecialPowers.addPermission(type, allow, url);
+}
+
+function removePermission(type, url)
+{
+  if (!url) {
+    url = window.document;
+  }
+  SpecialPowers.removePermission(type, url);
+}
+
+function setQuota(quota)
+{
+  SpecialPowers.setIntPref("dom.indexedDB.warningQuota", quota);
+}
+
+function allowUnlimitedQuota(url)
+{
+  addPermission("indexedDB-unlimited", true, url);
+}
+
+function denyUnlimitedQuota(url)
+{
+  addPermission("indexedDB-unlimited", false, url);
+}
+
+function resetUnlimitedQuota(url)
+{
+  removePermission("indexedDB-unlimited", url);
+}
+
+function enableArchiveReader()
+{
+  archiveReaderEnabled = SpecialPowers.getBoolPref("dom.archivereader.enabled");
+  SpecialPowers.setBoolPref("dom.archivereader.enabled", true);
+}
+
+function resetArchiveReader()
+{
+  SpecialPowers.setBoolPref("dom.archivereader.enabled", archiveReaderEnabled);
+}
+
+function enableExperimental()
+{
+  SpecialPowers.setBoolPref("dom.indexedDB.experimental", true);
+}
+
+function resetExperimental()
+{
+  SpecialPowers.clearUserPref("dom.indexedDB.experimental");
+}
+
+function gc()
+{
+  SpecialPowers.forceGC();
+  SpecialPowers.forceCC();
+}
+
+function scheduleGC()
+{
+  SpecialPowers.exactGC(window, continueToNextStep);
+}