--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -1151,16 +1151,19 @@ pref("browser.newtab.preload", true);
 pref("browser.newtabpage.introShown", false);
 
 // Toggles the content of 'about:newtab'. Shows the grid when enabled.
 pref("browser.newtabpage.enabled", true);
 
 // Toggles the enhanced content of 'about:newtab'. Shows sponsored tiles.
 sticky_pref("browser.newtabpage.enhanced", true);
 
+// enables Activity Stream inspired layout
+pref("browser.newtabpage.compact", false);
+
 // number of rows of newtab grid
 pref("browser.newtabpage.rows", 3);
 
 // number of columns of newtab grid
 pref("browser.newtabpage.columns", 5);
 
 // directory tiles download URL
 pref("browser.newtabpage.directory.source", "https://tiles.services.mozilla.com/v3/links/fetch/%LOCALE%/%CHANNEL%");

--- a/browser/base/content/newtab/grid.js
+++ b/browser/base/content/newtab/grid.js
@@ -204,50 +204,52 @@ var gGrid = {
     // let's bail out to avoid caching zero heights and widths.
     // We'll be called again when DOMContentLoaded fires.
     // Same goes for the grid if that's not ready yet.
     if (!this.isDocumentLoaded || !this._ready) {
       return;
     }
 
     // Save the cell's computed height/width including margin and border
-    if (this._cellMargin === undefined) {
+    if (this._cellHeight === undefined) {
       let refCell = document.querySelector(".newtab-cell");
-      this._cellMargin = parseFloat(getComputedStyle(refCell).marginTop);
-      this._cellHeight = refCell.offsetHeight + this._cellMargin +
-        parseFloat(getComputedStyle(refCell).marginBottom);
-      this._cellWidth = refCell.offsetWidth + this._cellMargin;
+      let style = getComputedStyle(refCell);
+      this._cellHeight = refCell.offsetHeight +
+        parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+      this._cellWidth = refCell.offsetWidth +
+        parseFloat(style.marginLeft) + parseFloat(style.marginRight);
     }
 
     let searchContainer = document.querySelector("#newtab-search-container");
     // Save search-container margin height
-    if (this._searchContainerMargin  === undefined) {
-      this._searchContainerMargin = parseFloat(getComputedStyle(searchContainer).marginBottom) +
-                                    parseFloat(getComputedStyle(searchContainer).marginTop);
+    if (this._searchContainerMargin === undefined) {
+      let style = getComputedStyle(searchContainer);
+      this._searchContainerMargin = parseFloat(style.marginBottom) +
+                                    parseFloat(style.marginTop);
     }
 
     // Find the number of rows we can place into view port
-    let availHeight = document.documentElement.clientHeight - this._cellMargin -
+    let availHeight = document.documentElement.clientHeight -
                       searchContainer.offsetHeight - this._searchContainerMargin;
     let visibleRows = Math.floor(availHeight / this._cellHeight);
 
     // Find the number of columns that fit into view port
     let maxGridWidth = gGridPrefs.gridColumns * this._cellWidth + GRID_WIDTH_EXTRA;
     // available width is current grid width, but no greater than maxGridWidth
     let availWidth = Math.min(document.querySelector("#newtab-grid").clientWidth,
                               maxGridWidth);
     // finally get the number of columns we can fit into view port
-    let gridColumns =  Math.floor(availWidth / this._cellWidth);
+    let gridColumns = Math.floor(availWidth / this._cellWidth);
     // walk sites backwords until a pinned or history tile is found or visibleRows reached
     let tileIndex = Math.min(gGridPrefs.gridRows * gridColumns, this.sites.length) - 1;
     while (tileIndex >= visibleRows * gridColumns) {
       if (this._isHistoricalTile(tileIndex)) {
         break;
       }
-      tileIndex --;
+      tileIndex--;
     }
 
     // Compute the actual number of grid rows we will display (potentially
     // with a scroll bar). tileIndex now points to a historical tile with
     // heighest index or to the last index of the visible row, if none found
     // Dividing tileIndex by number of tiles in a column gives the rows
     let gridRows = Math.floor(tileIndex / gridColumns) + 1;
 

--- a/browser/base/content/newtab/newTab.css
+++ b/browser/base/content/newtab/newTab.css
@@ -131,16 +131,22 @@ input[type=button] {
 /* CELLS */
 .newtab-cell {
   display: -moz-box;
   height: 210px;
   margin: 20px 10px 35px;
   width: 290px;
 }
 
+body.compact .newtab-cell {
+  width: 110px;
+  height: 110px;
+  margin: 12px;
+}
+
 /* SITES */
 .newtab-site {
   position: relative;
   -moz-box-flex: 1;
   transition: 100ms ease-out;
   transition-property: top, left, opacity;
 }
 
@@ -174,20 +180,17 @@ input[type=button] {
   text-align: center;
 }
 
 .newtab-sponsored,
 .newtab-title {
   bottom: 0;
   white-space: nowrap;
   text-overflow: ellipsis;
-  font-size: 13px;
-  line-height: 30px;
   vertical-align: middle;
-  background-color: #F2F2F2;
 }
 
 .newtab-suggested {
   border: 1px solid transparent;
   border-radius: 2px;
   font-size: 12px;
   height: 17px;
   line-height: 17px;
@@ -203,18 +206,16 @@ input[type=button] {
 
 .newtab-suggested-bounds {
   max-height: 34px; /* 34 / 17 = 2 lines maximum */
 }
 
 .newtab-title {
   left: 0;
   padding: 0 4px;
-  border: 1px solid #FFFFFF;
-  border-radius: 0px 0px 8px 8px;
 }
 
 .newtab-sponsored {
   background-color: #FFFFFF;
   border: 1px solid #E2E2E2;
   border-radius: 3px;
   color: #4A4A4A;
   cursor: pointer;
@@ -282,17 +283,16 @@ input[type=button] {
   pointer-events: none;
   position: static;
   width: 18px;
 }
 
 /* CONTROLS */
 .newtab-control {
   position: absolute;
-  top: 4px;
   opacity: 0;
   transition: opacity 100ms ease-out;
 }
 
 .newtab-control:-moz-focusring,
 .newtab-cell:not([ignorehover]) > .newtab-site:hover > .newtab-control {
   opacity: 1;
 }
@@ -302,26 +302,16 @@ input[type=button] {
 }
 
 @media (-moz-touch-enabled) {
   .newtab-control {
     opacity: 1;
   }
 }
 
-.newtab-control-pin:dir(ltr),
-.newtab-control-block:dir(rtl) {
-  left: 4px;
-}
-
-.newtab-control-block:dir(ltr),
-.newtab-control-pin:dir(rtl) {
-  right: 4px;
-}
-
 /* DRAG & DROP */
 
 /*
  * This is just a temporary drag element used for dataTransfer.setDragImage()
  * so that we can use custom drag images and elements. It needs an opacity of
  * 0.01 so that the core code detects that it's in fact a visible element.
  */
 .newtab-drag {
@@ -334,16 +324,21 @@ input[type=button] {
 /* SEARCH */
 #newtab-search-container {
   display: -moz-box;
   position: relative;
   -moz-box-pack: center;
   margin: 40px 0 15px;
 }
 
+body.compact #newtab-search-container {
+  margin-top: 0;
+  margin-bottom: 80px;
+}
+
 #newtab-search-container[page-disabled] {
   opacity: 0;
   pointer-events: none;
 }
 
 #newtab-search-form {
   display: -moz-box;
   position: relative;

--- a/browser/base/content/newtab/page.js
+++ b/browser/base/content/newtab/page.js
@@ -114,23 +114,27 @@ var gPage = {
 
     this._initialized = true;
 
     // Set submit button label for when CSS background are disabled (e.g.
     // high contrast mode).
     document.getElementById("newtab-search-submit").value =
       document.body.getAttribute("dir") == "ltr" ? "\u25B6" : "\u25C0";
 
+    if (Services.prefs.getBoolPref("browser.newtabpage.compact")) {
+      document.body.classList.add("compact");
+    }
+
     // Initialize search.
     gSearch.init();
 
     if (document.hidden) {
       addEventListener("visibilitychange", this);
     } else {
-      setTimeout(_ => this.onPageFirstVisible());
+      setTimeout(() => this.onPageFirstVisible());
     }
 
     // Initialize and render the grid.
     gGrid.init();
 
     // Initialize the drop target shim.
     gDropTargetShim.init();
 

--- a/browser/base/content/test/newtab/browser_newtab_bug991210.js
+++ b/browser/base/content/test/newtab/browser_newtab_bug991210.js
@@ -15,18 +15,17 @@ add_task(function* () {
   NewTabUtils.links.addProvider(afterLoadProvider);
 
   // wait until about:newtab loads before calling provider callback
   yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:newtab");
 
   afterLoadProvider.callback([]);
 
   yield ContentTask.spawn(gBrowser.selectedBrowser, {}, function* () {
-    let {_cellMargin, _cellHeight, _cellWidth, node} = content.gGrid;
-    Assert.notEqual(_cellMargin, null, "grid has a computed cell margin");
+    let {_cellHeight, _cellWidth, node} = content.gGrid;
     Assert.notEqual(_cellHeight, null, "grid has a computed cell height");
     Assert.notEqual(_cellWidth, null, "grid has a computed cell width");
     let {height, maxHeight, maxWidth} = node.style;
     Assert.notEqual(height, "", "grid has a computed grid height");
     Assert.notEqual(maxHeight, "", "grid has a computed grid max-height");
     Assert.notEqual(maxWidth, "", "grid has a computed grid max-width");
   });
 

--- a/browser/themes/shared/newtab/newTab.inc.css
+++ b/browser/themes/shared/newtab/newTab.inc.css
@@ -96,99 +96,150 @@
   background-image: -moz-image-rect(url(chrome://browser/skin/newtab/controls.svg), 0, 64, 32, 32);
   background-color: #FFFFFF;
   border: solid 1px #CCCCCC;
   border-radius: 2px;
 }
 
 /* CELLS */
 .newtab-cell {
+  --cell-corner-radius: 8px;
   background-color: rgba(255,255,255,.2);
-  border-radius: 8px;
+  border-radius: var(--cell-corner-radius);
+}
+
+body.compact .newtab-cell {
+  --cell-corner-radius: 2px;
 }
 
 .newtab-cell:empty {
   outline: 2px dashed #c1c1c1;
-  -moz-outline-radius: 8px;
+  outline-offset: -2px;
+  -moz-outline-radius: var(--cell-corner-radius);
 }
 
 /* SITES */
-.newtab-site {
-  border-radius: inherit;
+body:not(.compact) .newtab-site {
+  border-radius: var(--cell-corner-radius);
   box-shadow: 0 1px 3px #c1c1c1;
   text-decoration: none;
   transition-property: top, left, opacity, box-shadow, background-color;
 }
 
-.newtab-cell:not([ignorehover]) .newtab-control:hover ~ .newtab-link,
-.newtab-cell:not([ignorehover]) .newtab-link:hover,
-.newtab-site[dragged] {
+body:not(.compact) .newtab-cell:not([ignorehover]) .newtab-control:hover ~ .newtab-link,
+body:not(.compact) .newtab-cell:not([ignorehover]) .newtab-link:hover,
+body:not(.compact) .newtab-site[dragged] {
   border: 2px solid white;
   box-shadow: 0 0 6px 1px #add6ff;
   margin: -2px;
 }
 
 .newtab-site[dragged] {
   transition-property: box-shadow, background-color;
   background-color: rgb(242,242,242);
 }
 
 /* LINKS */
 .newtab-link {
-  border-radius: 10px;
+  border-radius: var(--cell-corner-radius);
   overflow: hidden;
 }
 
 /***
  * If you change the sizes here, change them in newTab.css
  * and the preference values:
  * toolkit.pageThumbs.minWidth
  * toolkit.pageThumbs.minHeight
  */
 /* THUMBNAILS */
 .newtab-thumbnail {
   background-origin: padding-box;
   background-clip: padding-box;
   background-repeat: no-repeat;
   background-size: cover;
-  border-radius: 8px 8px 0px 0px;
   height: 180px;
   transition: opacity 100ms ease-out;
 }
 
+body.compact .newtab-thumbnail {
+  height: 100%;
+  border-radius: calc(var(--cell-corner-radius) + 1px);
+  outline: 1px solid hsla(0,0%,0%,.1);
+  -moz-outline-radius: var(--cell-corner-radius);
+  outline-offset: -1px;
+}
+
 .newtab-cell:not([ignorehover]) .newtab-site:hover .newtab-thumbnail.enhanced-content {
   opacity: 0;
 }
 
 .newtab-site[type=affiliate] .newtab-thumbnail,
 .newtab-site[type=enhanced] .newtab-thumbnail,
 .newtab-site[type=organic] .newtab-thumbnail,
 .newtab-site[type=sponsored] .newtab-thumbnail {
   background-position: center center;
+}
+
+.newtab-site[type=affiliate] .newtab-thumbnail,
+body:not(.compact) .newtab-site[type=enhanced] .newtab-thumbnail,
+body:not(.compact) .newtab-site[type=organic] .newtab-thumbnail,
+body:not(.compact) .newtab-site[type=sponsored] .newtab-thumbnail {
   background-size: auto;
 }
 
 /* TITLES */
-.newtab-sponsored,
+
+.newtab-title {
+  background-color: #F2F2F2;
+  font-size: 13px;
+  line-height: 30px;
+  border: 1px solid #fff;
+  border-radius: 0 0 var(--cell-corner-radius) var(--cell-corner-radius);
+}
+
+body.compact .newtab-title {
+  background-color: hsla(0,0%,100%,.8);
+  font-size: 12px;
+  line-height: 21px;
+}
+
 .newtab-title,
-.newtab-suggested  {
+.newtab-suggested {
   color: #5c5c5c;
 }
 
+body.compact .newtab-title,
+body.compact .newtab-suggested {
+  color: black;
+}
+
+body.compact .newtab-title {
+  border: 1px solid hsla(0,0%,80%,.8);
+  border-top-color: hsla(0,0%,0%,.1);
+  background-clip: padding-box;
+}
+
 .newtab-suggested[active] {
   background-color: rgba(51, 51, 51, 0.95);
   border: 0;
   color: white;
 }
 
-.newtab-site:hover .newtab-title {
+body:not(.compact) .newtab-site:hover .newtab-title {
   color: white;
   background-color: #333;
-  border: 1px solid #333;
-  border-top: 1px solid white;
+  border-color: #333;
+  border-top-color: white;
+}
+
+body.compact .newtab-site:hover .newtab-title {
+  color: white;
+  background-color: hsla(0,0%,20%,.8);
+  border-color: hsla(0,0%,0%,.8);
+  border-top-color: white;
 }
 
 .newtab-site[pinned] .newtab-title {
   padding-inline-start: 24px;
 }
 
 .newtab-site[pinned] .newtab-title::before {
   background-image: -moz-image-rect(url("chrome://browser/skin/newtab/controls.svg"), 7, 278, 28, 266);
@@ -209,16 +260,41 @@
 
 /* CONTROLS */
 .newtab-control {
   background-color: transparent;
   background-size: 24px;
   border: none;
   height: 24px;
   width: 24px;
+  top: 4px;
+}
+
+.newtab-control-pin:dir(ltr),
+.newtab-control-block:dir(rtl) {
+  left: 4px;
+}
+
+.newtab-control-block:dir(ltr),
+.newtab-control-pin:dir(rtl) {
+  right: 4px;
+}
+
+body.compact .newtab-control {
+  top: -8px;
+}
+
+body.compact .newtab-control-pin:dir(ltr),
+body.compact .newtab-control-block:dir(rtl) {
+  left: -8px;
+}
+
+body.compact .newtab-control-block:dir(ltr),
+body.compact .newtab-control-pin:dir(rtl) {
+  right: -8px;
 }
 
 .newtab-control-pin,
 .newtab-site[pinned] .newtab-control-pin:hover:active {
   background-image: -moz-image-rect(url(chrome://browser/skin/newtab/controls.svg), 0, 96, 32, 64);
 }
 
 .newtab-control-pin:hover,

--- a/build/build-clang/build-clang.py
+++ b/build/build-clang/build-clang.py
@@ -219,16 +219,17 @@ def build_one_stage(cc, cxx, src_dir, st
                   "-DLLVM_ENABLE_ASSERTIONS=%s" % ("ON" if assertions else "OFF"),
                   "-DPYTHON_EXECUTABLE=%s" % slashify_path(python_path),
                   "-DCMAKE_INSTALL_PREFIX=%s" % inst_dir,
                   "-DLLVM_TOOL_LIBCXX_BUILD=%s" % ("ON" if build_libcxx else "OFF"),
                   "-DLIBCXX_LIBCPPABI_VERSION=\"\"",
                   src_dir];
     if is_windows():
         cmake_args.insert(-1, "-DLLVM_EXPORT_SYMBOLS_FOR_PLUGINS=ON")
+        cmake_args.insert(-1, "-DLLVM_USE_CRT_RELEASE=MT")
     build_package(build_dir, cmake_args)
 
     if is_linux():
         install_libgcc(gcc_dir, inst_dir)
     # For some reasons the import library clang.lib of clang.exe is not
     # installed, so we copy it by ourselves.
     if is_windows():
         install_import_library(build_dir, inst_dir)

--- a/caps/nsPrincipal.cpp
+++ b/caps/nsPrincipal.cpp
@@ -178,19 +178,34 @@ nsPrincipal::GetOriginInternal(nsACStrin
   // nsIStandardURL.  So, we query to a nsIStandardURL, and fail if we aren't
   // an instance of an nsIStandardURL nsIStandardURLs have the good property
   // of escaping the '^' character in their specs, which means that we can be
   // sure that the caret character (which is reserved for delimiting the end
   // of the spec, and the beginning of the origin attributes) is not present
   // in the origin string
   nsCOMPtr<nsIStandardURL> standardURL = do_QueryInterface(origin);
   NS_ENSURE_TRUE(standardURL, NS_ERROR_FAILURE);
+
   rv = origin->GetAsciiSpec(aOrigin);
   NS_ENSURE_SUCCESS(rv, rv);
 
+  // The origin, when taken from the spec, should not contain the ref part of
+  // the URL.
+
+  int32_t pos = aOrigin.FindChar('?');
+  int32_t hashPos = aOrigin.FindChar('#');
+
+  if (hashPos != kNotFound && (pos == kNotFound || hashPos < pos)) {
+    pos = hashPos;
+  }
+
+  if (pos != kNotFound) {
+    aOrigin.Truncate(pos);
+  }
+
   return NS_OK;
 }
 
 bool
 nsPrincipal::SubsumesInternal(nsIPrincipal* aOther,
                               BasePrincipal::DocumentDomainConsideration aConsideration)
 {
   MOZ_ASSERT(aOther);

--- a/devtools/client/jar.mn
+++ b/devtools/client/jar.mn
@@ -5,19 +5,16 @@
 devtools.jar:
 %   content devtools %content/
     content/shared/vendor/d3.js (shared/vendor/d3.js)
     content/shared/vendor/dagre-d3.js (shared/vendor/dagre-d3.js)
     content/shared/widgets/widgets.css (shared/widgets/widgets.css)
     content/shared/widgets/VariablesView.xul (shared/widgets/VariablesView.xul)
     content/projecteditor/chrome/content/projecteditor.xul (projecteditor/chrome/content/projecteditor.xul)
     content/projecteditor/lib/helpers/readdir.js (projecteditor/lib/helpers/readdir.js)
-    content/projecteditor/chrome/content/projecteditor-loader.xul (projecteditor/chrome/content/projecteditor-loader.xul)
-    content/projecteditor/chrome/content/projecteditor-test.xul (projecteditor/chrome/content/projecteditor-test.xul)
-    content/projecteditor/chrome/content/projecteditor-loader.js (projecteditor/chrome/content/projecteditor-loader.js)
     content/netmonitor/netmonitor.xul (netmonitor/netmonitor.xul)
     content/netmonitor/netmonitor.js (netmonitor/netmonitor.js)
     content/webconsole/webconsole.xul (webconsole/webconsole.xul)
 *   content/scratchpad/scratchpad.xul (scratchpad/scratchpad.xul)
     content/scratchpad/scratchpad.js (scratchpad/scratchpad.js)
     content/shared/splitview.css (shared/splitview.css)
     content/shared/theme-switching.js (shared/theme-switching.js)
     content/shared/frame-script-utils.js (shared/frame-script-utils.js)
@@ -174,17 +171,16 @@ devtools.jar:
     skin/images/webconsole.svg (themes/images/webconsole.svg)
     skin/images/breadcrumbs-divider@2x.png (themes/images/breadcrumbs-divider@2x.png)
     skin/images/breadcrumbs-scrollbutton.png (themes/images/breadcrumbs-scrollbutton.png)
     skin/images/breadcrumbs-scrollbutton@2x.png (themes/images/breadcrumbs-scrollbutton@2x.png)
     skin/animationinspector.css (themes/animationinspector.css)
     skin/canvasdebugger.css (themes/canvasdebugger.css)
     skin/debugger.css (themes/debugger.css)
     skin/netmonitor.css (themes/netmonitor.css)
-    skin/dom.css (themes/dom.css)
     skin/performance.css (themes/performance.css)
     skin/memory.css (themes/memory.css)
     skin/scratchpad.css (themes/scratchpad.css)
     skin/shadereditor.css (themes/shadereditor.css)
     skin/storage.css (themes/storage.css)
     skin/splitview.css (themes/splitview.css)
     skin/styleeditor.css (themes/styleeditor.css)
     skin/webaudioeditor.css (themes/webaudioeditor.css)

deleted file mode 100644
--- a/devtools/client/projecteditor/chrome/content/projecteditor-loader.js
+++ /dev/null
@@ -1,176 +0,0 @@
-var Cu = Components.utils;
-const {require} = Cu.import("resource://devtools/shared/Loader.jsm", {});
-const {FileUtils} = Cu.import("resource://gre/modules/FileUtils.jsm", {});
-const {NetUtil} = Cu.import("resource://gre/modules/NetUtil.jsm", {});
-const promise = require("promise");
-const ProjectEditor = require("devtools/client/projecteditor/lib/projecteditor");
-
-const SAMPLE_PATH = buildTempDirectoryStructure();
-const SAMPLE_NAME = "DevTools Content Application Name";
-const SAMPLE_PROJECT_URL = "data:text/html;charset=utf-8,<body><h1>Project Overview</h1></body>";
-const SAMPLE_ICON = "chrome://devtools/skin/images/tool-debugger.svg";
-
-/**
- * Create a workspace for working on projecteditor, available at
- * chrome://devtools/content/projecteditor/chrome/content/projecteditor-loader.xul.
- * This emulates the integration points that the app manager uses.
- */
-var appManagerEditor;
-
-// Log a message to the project overview URL to make development easier
-function log(msg) {
-  if (!appManagerEditor) {
-    return;
-  }
-
-  let doc = appManagerEditor.iframe.contentDocument;
-  let el = doc.createElement("p");
-  el.textContent = msg;
-  doc.body.appendChild(el);
-}
-
-document.addEventListener("DOMContentLoaded", function onDOMReady(e) {
-  document.removeEventListener("DOMContentLoaded", onDOMReady, false);
-  let iframe = document.getElementById("projecteditor-iframe");
-  window.projecteditor = ProjectEditor.ProjectEditor(iframe);
-
-  projecteditor.on("onEditorCreated", (editor, a) => {
-    log("editor created: " + editor);
-    if (editor.label === "app-manager") {
-      appManagerEditor = editor;
-      appManagerEditor.on("load", function foo() {
-        appManagerEditor.off("load", foo);
-        log("Working on: " + SAMPLE_PATH);
-      });
-    }
-  });
-  projecteditor.on("onEditorDestroyed", (editor) => {
-    log("editor destroyed: " + editor);
-  });
-  projecteditor.on("onEditorSave", (editor, resource) => {
-    log("editor saved: " + editor, resource.path);
-  });
-  projecteditor.on("onTreeSelected", (resource) => {
-    log("tree selected: " + resource.path);
-  });
-  projecteditor.on("onEditorLoad", (editor) => {
-    log("editor loaded: " + editor);
-  });
-  projecteditor.on("onEditorActivated", (editor) => {
-    log("editor focused: " + editor);
-  });
-  projecteditor.on("onEditorDeactivated", (editor) => {
-    log("editor blur: " + editor);
-  });
-  projecteditor.on("onEditorChange", (editor) => {
-    log("editor changed: " + editor);
-  });
-  projecteditor.on("onCommand", (cmd) => {
-    log("Command: " + cmd);
-  });
-
-  projecteditor.loaded.then(() => {
-    projecteditor.setProjectToAppPath(SAMPLE_PATH, {
-      name: SAMPLE_NAME,
-      iconUrl: SAMPLE_ICON,
-      projectOverviewURL: SAMPLE_PROJECT_URL,
-      validationStatus: "valid"
-    }).then(() => {
-      let allResources = projecteditor.project.allResources();
-      console.log("All resources have been loaded", allResources, allResources.map(r=>r.basename).join("|"));
-    });
-
-  });
-
-}, false);
-
-/**
- * Build a temporary directory as a workspace for this loader
- * https://developer.mozilla.org/en-US/Add-ons/Code_snippets/File_I_O
- */
-function buildTempDirectoryStructure() {
-
-  // First create (and remove) the temp dir to discard any changes
-  let TEMP_DIR = FileUtils.getDir("TmpD", ["ProjectEditor"], true);
-  TEMP_DIR.remove(true);
-
-  // Now rebuild our fake project.
-  TEMP_DIR = FileUtils.getDir("TmpD", ["ProjectEditor"], true);
-
-  FileUtils.getDir("TmpD", ["ProjectEditor", "css"], true);
-  FileUtils.getDir("TmpD", ["ProjectEditor", "data"], true);
-  FileUtils.getDir("TmpD", ["ProjectEditor", "img", "icons"], true);
-  FileUtils.getDir("TmpD", ["ProjectEditor", "js"], true);
-
-  let htmlFile = FileUtils.getFile("TmpD", ["ProjectEditor", "index.html"]);
-  htmlFile.createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
-  writeToFile(htmlFile, [
-    "<!DOCTYPE html>",
-    '<html lang="en">',
-    " <head>",
-    '   <meta charset="utf-8" />',
-    "   <title>ProjectEditor Temp File</title>",
-    '   <link rel="stylesheet" href="style.css" />',
-    " </head>",
-    ' <body id="home">',
-    "   <p>ProjectEditor Temp File</p>",
-    " </body>",
-    "</html>"].join("\n")
-  );
-
-  let readmeFile = FileUtils.getFile("TmpD", ["ProjectEditor", "README.md"]);
-  readmeFile.createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
-  writeToFile(readmeFile, [
-    "## Readme"
-  ].join("\n")
-  );
-
-  let licenseFile = FileUtils.getFile("TmpD", ["ProjectEditor", "LICENSE"]);
-  licenseFile.createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
-  writeToFile(licenseFile, [
-    "/* 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/. */"
-  ].join("\n")
-  );
-
-  let cssFile = FileUtils.getFile("TmpD", ["ProjectEditor", "css", "styles.css"]);
-  cssFile.createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
-  writeToFile(cssFile, [
-    "body {",
-    " background: red;",
-    "}"
-  ].join("\n")
-  );
-
-  FileUtils.getFile("TmpD", ["ProjectEditor", "js", "script.js"]).createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
-
-  FileUtils.getFile("TmpD", ["ProjectEditor", "img", "fake.png"]).createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
-  FileUtils.getFile("TmpD", ["ProjectEditor", "img", "icons", "16x16.png"]).createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
-  FileUtils.getFile("TmpD", ["ProjectEditor", "img", "icons", "32x32.png"]).createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
-  FileUtils.getFile("TmpD", ["ProjectEditor", "img", "icons", "128x128.png"]).createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
-  FileUtils.getFile("TmpD", ["ProjectEditor", "img", "icons", "vector.svg"]).createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
-
-  return TEMP_DIR.path;
-}
-
-
-// https://developer.mozilla.org/en-US/Add-ons/Code_snippets/File_I_O#Writing_to_a_file
-function writeToFile(file, data) {
-
-  let defer = promise.defer();
-  var ostream = FileUtils.openSafeFileOutputStream(file);
-
-  var converter = Components.classes["@mozilla.org/intl/scriptableunicodeconverter"].
-                  createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
-  converter.charset = "UTF-8";
-  var istream = converter.convertToInputStream(data);
-
-  // The last argument (the callback) is optional.
-  NetUtil.asyncCopy(istream, ostream, function (status) {
-    if (!Components.isSuccessCode(status)) {
-      // Handle error!
-      console.log("ERROR WRITING TEMP FILE", status);
-    }
-  });
-}

deleted file mode 100644
--- a/devtools/client/projecteditor/chrome/content/projecteditor-loader.xul
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- 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/. -->
-<!DOCTYPE window [
-<!ENTITY % toolboxDTD SYSTEM "chrome://devtools/locale/toolbox.dtd" >
- %toolboxDTD;
-]>
-
-<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-
-<script type="application/javascript;version=1.8" src="projecteditor-loader.js"></script>
-
-  <commandset id="toolbox-commandset">
-    <command id="projecteditor-cmd-close" oncommand="window.close();"/>
-  </commandset>
-
-  <keyset id="projecteditor-keyset">
-    <key id="projecteditor-key-close"
-         key="&closeCmd.key;"
-         command="projecteditor-cmd-close"
-         modifiers="accel"/>
-  </keyset>
-
-  <iframe id="projecteditor-iframe" flex="1" forceOwnRefreshDriver=""></iframe>
-</window>

--- a/devtools/client/projecteditor/test/browser.ini
+++ b/devtools/client/projecteditor/test/browser.ini
@@ -1,15 +1,16 @@
 [DEFAULT]
 tags = devtools
 subsuite = devtools
 support-files =
   head.js
   helper_homepage.html
   helper_edits.js
+  projecteditor-test.xul
 
 [browser_projecteditor_app_options.js]
 [browser_projecteditor_confirm_unsaved.js]
 [browser_projecteditor_contextmenu_01.js]
 [browser_projecteditor_contextmenu_02.js]
 skip-if = true # Bug 1173950
 [browser_projecteditor_delete_file.js]
 skip-if = e10s # Frequent failures in e10s - Bug 1020027

--- a/devtools/client/projecteditor/test/browser_projecteditor_immediate_destroy.js
+++ b/devtools/client/projecteditor/test/browser_projecteditor_immediate_destroy.js
@@ -12,17 +12,17 @@ thisTestLeaksUncaughtRejectionsAndShould
 thisTestLeaksUncaughtRejectionsAndShouldBeFixed("TypeError: this.window is null");
 
 // Test that projecteditor can be destroyed in various states of loading
 // without causing any leaks or exceptions.
 
 add_task(function* () {
 
   info("Testing tab closure when projecteditor is in various states");
-  let loaderUrl = "chrome://devtools/content/projecteditor/chrome/content/projecteditor-test.xul";
+  let loaderUrl = "chrome://mochitests/content/browser/devtools/client/projecteditor/test/projecteditor-test.xul";
 
   yield addTab(loaderUrl).then(() => {
     let iframe = content.document.getElementById("projecteditor-iframe");
     ok(iframe, "Tab has placeholder iframe for projecteditor");
 
     info("Closing the tab without doing anything");
     gBrowser.removeCurrentTab();
   });

--- a/devtools/client/projecteditor/test/head.js
+++ b/devtools/client/projecteditor/test/head.js
@@ -104,17 +104,17 @@ function addProjectEditorTabForTempDirec
   return addProjectEditorTab(opts).then((projecteditor) => {
     return projecteditor.setProjectToAppPath(TEMP_PATH, customOpts).then(() => {
       return projecteditor;
     });
   });
 }
 
 function addProjectEditorTab(opts = {}) {
-  return addTab("chrome://devtools/content/projecteditor/chrome/content/projecteditor-test.xul").then(() => {
+  return addTab("chrome://mochitests/content/browser/devtools/client/projecteditor/test/projecteditor-test.xul").then(() => {
     let iframe = content.document.getElementById("projecteditor-iframe");
     if (opts.menubar !== false) {
       opts.menubar = content.document.querySelector("menubar");
     }
     let projecteditor = ProjectEditor.ProjectEditor(iframe, opts);
 
 
     ok(iframe, "Tab has placeholder iframe for projecteditor");

rename from devtools/client/projecteditor/chrome/content/projecteditor-test.xul
rename to devtools/client/projecteditor/test/projecteditor-test.xul

--- a/devtools/client/shims/moz.build
+++ b/devtools/client/shims/moz.build
@@ -6,13 +6,8 @@
 
 # Unlike most DevTools build files, this file does not use DevToolsModules
 # because these files are here for add-on compatibility, and so they must be
 # installed to previously defined locations.
 
 EXTRA_JS_MODULES.devtools += [
     'gDevTools.jsm',
 ]
-
-# Extra compatibility layer for transitional URLs used for part of 44 cycle
-EXTRA_JS_MODULES.devtools.client.framework += [
-    'gDevTools.jsm',
-]

deleted file mode 100644
--- a/devtools/client/themes/dom.css
+++ /dev/null
@@ -1,9 +0,0 @@
-/* vim:set ts=2 sw=2 sts=2 et: */
-/* 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/. */
-
-:root.theme-dark {
-}
-:root.theme-light {
-}

--- a/devtools/client/webconsole/test/browser.ini
+++ b/devtools/client/webconsole/test/browser.ini
@@ -71,16 +71,17 @@ support-files =
   test-console-assert.html
   test-console-clear.html
   test-console-count.html
   test-console-count-external-file.js
   test-console-extras.html
   test-console-replaced-api.html
   test-console-server-logging.sjs
   test-console-server-logging-array.sjs
+  test-console-server-logging-backtrace.sjs
   test-console.html
   test-console-workers.html
   test-console-table.html
   test-console-output-02.html
   test-console-output-03.html
   test-console-output-04.html
   test-console-output-dom-elements.html
   test-console-output-events.html

--- a/devtools/client/webconsole/test/browser_console_server_logging.js
+++ b/devtools/client/webconsole/test/browser_console_server_logging.js
@@ -60,15 +60,58 @@ add_task(function* () {
       severity: SEVERITY_LOG,
     }],
   });
   // Clean up filter
   hud.setFilterState("serverlog", false);
   yield updateServerLoggingListener(hud);
 });
 
+add_task(function* () {
+  const TEST_URI = "http://example.com/browser/devtools/client/webconsole/test/test-console-server-logging-backtrace.sjs";
+
+  yield loadTab(TEST_URI);
+
+  let hud = yield openConsole();
+
+  // Set logging filter and wait till it's set on the backend
+  hud.setFilterState("serverlog", true);
+  yield updateServerLoggingListener(hud);
+
+  BrowserReloadSkipCache();
+  // Note that the test is also checking out the (printf like)
+  // formatters and encoding of UTF8 characters (see the one at the end).
+  yield waitForMessages({
+    webconsole: hud,
+    messages: [{
+      text: "correct 1",
+      category: CATEGORY_SERVER,
+      severity: SEVERITY_ERROR,
+      source: {url: "/some/path/to/file.py", line: 33}
+    }, {
+      text: "correct 2",
+      category: CATEGORY_SERVER,
+      severity: SEVERITY_ERROR,
+      source: {url: "/some/path/to/file.py", line: 33}
+    }, {
+      text: "wrong 1",
+      category: CATEGORY_SERVER,
+      severity: SEVERITY_ERROR,
+      source: {url: "/some/path/to/file.py:33wrong"}
+    }, {
+      text: "wrong 2",
+      category: CATEGORY_SERVER,
+      severity: SEVERITY_ERROR,
+      source: {url: "/some/path/to/file.py"}
+    }],
+  });
+  // Clean up filter
+  hud.setFilterState("serverlog", false);
+  yield updateServerLoggingListener(hud);
+});
+
 function updateServerLoggingListener(hud) {
   let deferred = promise.defer();
   hud.ui._updateServerLoggingListener(response => {
     deferred.resolve(response);
   });
   return deferred.promise;
 }

new file mode 100644
--- /dev/null
+++ b/devtools/client/webconsole/test/test-console-server-logging-backtrace.sjs
@@ -0,0 +1,44 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function handleRequest(request, response)
+{
+  var page = "<!DOCTYPE html><html>" +
+    "<head><meta charset='utf-8'></head>" +
+    "<body><p>hello world!</p></body>" +
+    "</html>";
+
+  var data = {
+    "version": "4.1.0",
+    "columns": ["log", "backtrace", "type"],
+    "rows":[[
+      ["correct 1"],
+      "/some/path/to/file.py   :     33",
+      "error"
+    ], [
+      ["correct 2"],
+      "/some/path/to/file.py:33",
+      "error"
+    ], [
+      ["wrong 1"],
+      "/some/path/to/file.py:33wrong",
+      "error"
+    ], [
+      ["wrong 2"],
+      "/some/path/to/file.py",
+      "error"
+    ]],
+  };
+
+  // Put log into headers.
+  var value = b64EncodeUnicode(JSON.stringify(data));
+  response.setHeader("X-ChromeLogger-Data", value, false);
+
+  response.write(page);
+}
+
+function b64EncodeUnicode(str) {
+  return btoa(unescape(encodeURIComponent(str)));
+}

--- a/devtools/client/webide/test/chrome.ini
+++ b/devtools/client/webide/test/chrome.ini
@@ -43,16 +43,17 @@ support-files =
   templates.json
   ../../shared/test/browser_devices.json
   validator/*
 
 [test_basic.html]
 [test_newapp.html]
 skip-if = (os == "win" && os_version == "10.0") # Bug 1197053
 [test_import.html]
+skip-if = (os == "linux") # Bug 1024734 
 [test_duplicate_import.html]
 [test_runtime.html]
 [test_manifestUpdate.html]
 [test_addons.html]
 skip-if = true # Bug 1201392 - Update add-ons after migration
 [test_device_runtime.html]
 [test_autoconnect_runtime.html]
 [test_autoselect_project.html]

--- a/devtools/shared/apps/moz.build
+++ b/devtools/shared/apps/moz.build
@@ -1,10 +1,9 @@
 # vim: set filetype=python:
 # 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/.
 
 DevToolsModules(
     'app-actor-front.js',
-    'Devices.jsm',
-    'Simulator.jsm'
+    'Devices.jsm'
 )

deleted file mode 100644
--- a/devtools/shared/shims/Simulator.jsm
+++ /dev/null
@@ -1,34 +0,0 @@
-/* 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/. */
-
-"use strict";
-
-/**
- * This file only exists to support add-ons which import this module at a
- * specific path.
- */
-
-const Cu = Components.utils;
-
-const { Services } = Cu.import("resource://gre/modules/Services.jsm", {});
-
-const WARNING_PREF = "devtools.migration.warnings";
-if (Services.prefs.getBoolPref(WARNING_PREF)) {
-  const { Deprecated } = Cu.import("resource://gre/modules/Deprecated.jsm", {});
-  Deprecated.warning("This path to Simulator.jsm is deprecated.  Please use " +
-                     "Cu.import(\"resource://devtools/shared/" +
-                     "apps/Simulator.jsm\") to load this module.",
-                     "https://bugzil.la/912121");
-}
-
-this.EXPORTED_SYMBOLS = [
-  "Simulator",
-];
-
-const module =
-  Cu.import("resource://devtools/shared/apps/Simulator.jsm", {});
-
-for (let symbol of this.EXPORTED_SYMBOLS) {
-  this[symbol] = module[symbol];
-}

--- a/devtools/shared/shims/moz.build
+++ b/devtools/shared/shims/moz.build
@@ -12,20 +12,14 @@
 # /toolkit modules.  Disable any DIST_SUBDIR from parent files here.
 DIST_SUBDIR = ''
 
 EXTRA_JS_MODULES.devtools += [
     'Console.jsm',
     'dbg-client.jsm',
     'event-emitter.js',
     'Loader.jsm',
-    'Simulator.jsm',
 ]
 
 # Extra compatibility layer for transitional URLs used for part of 44 cycle
 EXTRA_JS_MODULES.devtools.shared += [
-    'Console.jsm',
     'Loader.jsm',
 ]
-
-EXTRA_JS_MODULES.devtools.shared.apps += [
-    'Simulator.jsm',
-]

--- a/devtools/shared/webconsole/server-logger.js
+++ b/devtools/shared/webconsole/server-logger.js
@@ -300,49 +300,33 @@ var ServerLoggingListener = Class({
         if (showLabel) {
           rawLogs.unshift(label);
         }
       }
 
       // If multiple logs come from the same line only the first log
       // has info about the backtrace. So, remember the last valid
       // location and use it for those that not set.
-      let location = this.parseBacktrace(backtrace);
+      let location = parseBacktrace(backtrace);
       if (location) {
         lastLocation = location;
       } else {
         location = lastLocation;
       }
 
       parsedMessage.push({
         logs: rawLogs,
         location: location,
         type: type
       });
     }
 
     return parsedMessage;
   },
 
-  parseBacktrace: function (backtrace) {
-    if (!backtrace) {
-      return null;
-    }
-
-    let result = backtrace.match(/\s*(\d+)$/);
-    if (!result || result.length < 2) {
-      return backtrace;
-    }
-
-    return {
-      url: backtrace.slice(0, -result[0].length),
-      line: result[1]
-    };
-  },
-
   getColumnMap: function (data) {
     let columnMap = new Map();
     let columnName;
 
     for (let key in data.columns) {
       columnName = data.columns[key];
       columnMap.set(columnName, key);
     }
@@ -498,17 +482,34 @@ function format(msg) {
     if (typeof log == "object") {
       delete log.___class_name;
     }
   }
 
   return msg;
 }
 
+function parseBacktrace(backtrace) {
+  if (!backtrace) {
+    return null;
+  }
+
+  let result = backtrace.match(/^(.+?)\s*:\s*(\d+)$/);
+  if (!result || result.length != 3) {
+    return { url: backtrace };
+  }
+
+  return {
+    url: result[1],
+    line: parseInt(result[2], 10)
+  };
+}
+
 // These helper are cloned from SDK to avoid loading to
 // much SDK modules just because of two functions.
 function getInnerId(win) {
   return win.QueryInterface(Ci.nsIInterfaceRequestor)
     .getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID;
 }
 
 // Exports from this module
 exports.ServerLoggingListener = ServerLoggingListener;
+exports.parseBacktrace = parseBacktrace;

--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/nsContentIterator.cpp
@@ -369,18 +369,18 @@ nsContentIterator::Init(nsIDOMRange* aDO
       // XXX: In the future, if start offset is after the last
       //      character in the cdata node, should we set mFirst to
       //      the next sibling?
 
       // If the node has no child, the child may be <br> or something.
       // So, we shouldn't skip the empty node if the start offset is 0.
       // In other words, if the offset is 1, the node should be ignored.
       if (!startIsData && startIndx) {
-        mFirst = GetNextSibling(startNode);
-        NS_WARNING_ASSERTION(mFirst, "GetNextSibling returned null");
+        mFirst = NextNode(startNode);
+        NS_WARNING_ASSERTION(mFirst, "NextNode returned null");
 
         // Does mFirst node really intersect the range?  The range could be
         // 'degenerate', i.e., not collapsed but still contain no content.
         if (mFirst &&
             NS_WARN_IF(!NodeIsInTraversalRange(mFirst, mPre, startNode,
                                                startIndx, endNode, endIndx))) {
           mFirst = nullptr;
         }
@@ -425,18 +425,18 @@ nsContentIterator::Init(nsIDOMRange* aDO
       if (NS_WARN_IF(!endNode->IsContent())) {
         // Not much else to do here...
         mLast = nullptr;
       } else {
         // If the end node is an empty element and the end offset is 0,
         // the last element should be the previous node (i.e., shouldn't
         // include the end node in the range).
         if (!endIsData && !endNode->HasChildren() && !endIndx) {
-          mLast = GetPrevSibling(endNode);
-          NS_WARNING_ASSERTION(mLast, "GetPrevSibling returned null");
+          mLast = PrevNode(endNode);
+          NS_WARNING_ASSERTION(mLast, "PrevNode returned null");
           if (NS_WARN_IF(!NodeIsInTraversalRange(mLast, mPre,
                                                  startNode, startIndx,
                                                  endNode, endIndx))) {
             mLast = nullptr;
           }
         } else {
           mLast = endNode->AsContent();
         }

--- a/dom/base/nsGlobalWindow.cpp
+++ b/dom/base/nsGlobalWindow.cpp
@@ -12,17 +12,17 @@
 
 // Local Includes
 #include "Navigator.h"
 #include "nsContentSecurityManager.h"
 #include "nsScreen.h"
 #include "nsHistory.h"
 #include "nsDOMNavigationTiming.h"
 #include "nsIDOMStorageManager.h"
-#include "mozilla/dom/DOMStorage.h"
+#include "mozilla/dom/Storage.h"
 #include "mozilla/dom/IdleRequest.h"
 #include "mozilla/dom/Performance.h"
 #include "mozilla/dom/StorageEvent.h"
 #include "mozilla/dom/StorageEventBinding.h"
 #include "mozilla/dom/Timeout.h"
 #include "mozilla/dom/TimeoutManager.h"
 #include "mozilla/IntegerPrintfMacros.h"
 #if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GONK)
@@ -10618,17 +10618,17 @@ nsGlobalWindow::GetComputedStyleHelper(E
                                        bool aDefaultStylesOnly,
                                        ErrorResult& aError)
 {
   FORWARD_TO_OUTER_OR_THROW(GetComputedStyleHelperOuter,
                             (aElt, aPseudoElt, aDefaultStylesOnly),
                             aError, nullptr);
 }
 
-DOMStorage*
+Storage*
 nsGlobalWindow::GetSessionStorage(ErrorResult& aError)
 {
   MOZ_RELEASE_ASSERT(IsInnerWindow());
 
   nsIPrincipal *principal = GetPrincipal();
   nsIDocShell* docShell = GetDocShell();
 
   if (!principal || !docShell || !Preferences::GetBool(kStorageEnabled)) {
@@ -10681,17 +10681,17 @@ nsGlobalWindow::GetSessionStorage(ErrorR
 
     nsCOMPtr<nsIDOMStorage> storage;
     aError = storageManager->CreateStorage(AsInner(), principal, documentURI,
                                            getter_AddRefs(storage));
     if (aError.Failed()) {
       return nullptr;
     }
 
-    mSessionStorage = static_cast<DOMStorage*>(storage.get());
+    mSessionStorage = static_cast<Storage*>(storage.get());
     MOZ_ASSERT(mSessionStorage);
 
     if (MOZ_LOG_TEST(gDOMLeakPRLog, LogLevel::Debug)) {
       PR_LogPrint("nsGlobalWindow %p tried to get a new sessionStorage %p", this, mSessionStorage.get());
     }
 
     if (!mSessionStorage) {
       aError.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
@@ -10701,17 +10701,17 @@ nsGlobalWindow::GetSessionStorage(ErrorR
 
   if (MOZ_LOG_TEST(gDOMLeakPRLog, LogLevel::Debug)) {
     PR_LogPrint("nsGlobalWindow %p returns %p sessionStorage", this, mSessionStorage.get());
   }
 
   return mSessionStorage;
 }
 
-DOMStorage*
+Storage*
 nsGlobalWindow::GetLocalStorage(ErrorResult& aError)
 {
   MOZ_RELEASE_ASSERT(IsInnerWindow());
 
   if (!Preferences::GetBool(kStorageEnabled)) {
     return nullptr;
   }
 
@@ -10749,17 +10749,17 @@ nsGlobalWindow::GetLocalStorage(ErrorRes
 
     nsCOMPtr<nsIDOMStorage> storage;
     aError = storageManager->CreateStorage(AsInner(), principal, documentURI,
                                            getter_AddRefs(storage));
     if (aError.Failed()) {
       return nullptr;
     }
 
-    mLocalStorage = static_cast<DOMStorage*>(storage.get());
+    mLocalStorage = static_cast<Storage*>(storage.get());
     MOZ_ASSERT(mLocalStorage);
   }
 
   return mLocalStorage;
 }
 
 IDBFactory*
 nsGlobalWindow::GetIndexedDB(ErrorResult& aError)
@@ -11580,17 +11580,17 @@ nsGlobalWindow::Observe(nsISupports* aSu
     nsIPrincipal *principal;
     nsresult rv;
 
     RefPtr<StorageEvent> event = static_cast<StorageEvent*>(aSubject);
     if (!event) {
       return NS_ERROR_FAILURE;
     }
 
-    RefPtr<DOMStorage> changingStorage = event->GetStorageArea();
+    RefPtr<Storage> changingStorage = event->GetStorageArea();
     if (!changingStorage) {
       return NS_ERROR_FAILURE;
     }
 
     nsCOMPtr<nsIDOMStorage> istorage = changingStorage.get();
 
     bool fireMozStorageChanged = false;
     nsAutoString eventType;
@@ -11606,17 +11606,17 @@ nsGlobalWindow::Observe(nsISupports* aSu
     if (NS_FAILED(rv)) {
       return rv;
     }
 
     MOZ_ASSERT((privateBrowsingId > 0) == isPrivateBrowsing);
 
     switch (changingStorage->GetType())
     {
-    case DOMStorage::SessionStorage:
+    case Storage::SessionStorage:
     {
       bool check = false;
 
       nsCOMPtr<nsIDOMStorageManager> storageManager = do_QueryInterface(GetDocShell());
       if (storageManager) {
         rv = storageManager->CheckStorage(principal, istorage, &check);
         if (NS_FAILED(rv)) {
           return rv;
@@ -11636,17 +11636,17 @@ nsGlobalWindow::Observe(nsISupports* aSu
 
       fireMozStorageChanged = mSessionStorage == changingStorage;
       if (fireMozStorageChanged) {
         eventType.AssignLiteral("MozSessionStorageChanged");
       }
       break;
     }
 
-    case DOMStorage::LocalStorage:
+    case Storage::LocalStorage:
     {
       // Allow event fire only for the same principal storages
       // XXX We have to use EqualsIgnoreDomain after bug 495337 lands
       nsIPrincipal* storagePrincipal = changingStorage->GetPrincipal();
 
       bool equals = false;
       rv = storagePrincipal->Equals(principal, &equals);
       NS_ENSURE_SUCCESS(rv, rv);
@@ -11774,24 +11774,24 @@ nsGlobalWindow::CloneStorageEvent(const 
 
   dict.mBubbles = aEvent->Bubbles();
   dict.mCancelable = aEvent->Cancelable();
   aEvent->GetKey(dict.mKey);
   aEvent->GetOldValue(dict.mOldValue);
   aEvent->GetNewValue(dict.mNewValue);
   aEvent->GetUrl(dict.mUrl);
 
-  RefPtr<DOMStorage> storageArea = aEvent->GetStorageArea();
+  RefPtr<Storage> storageArea = aEvent->GetStorageArea();
   MOZ_ASSERT(storageArea);
 
-  RefPtr<DOMStorage> storage;
-  if (storageArea->GetType() == DOMStorage::LocalStorage) {
+  RefPtr<Storage> storage;
+  if (storageArea->GetType() == Storage::LocalStorage) {
     storage = GetLocalStorage(aRv);
   } else {
-    MOZ_ASSERT(storageArea->GetType() == DOMStorage::SessionStorage);
+    MOZ_ASSERT(storageArea->GetType() == Storage::SessionStorage);
     storage = GetSessionStorage(aRv);
   }
 
   if (aRv.Failed() || !storage) {
     return nullptr;
   }
 
   MOZ_ASSERT(storage);

--- a/dom/base/nsGlobalWindow.h
+++ b/dom/base/nsGlobalWindow.h
@@ -990,18 +990,18 @@ public:
                       const mozilla::dom::Optional<int32_t>& aTimeout,
                       const mozilla::dom::Sequence<JS::Value>& /* unused */,
                       mozilla::ErrorResult& aError);
   void ClearInterval(int32_t aHandle);
   void Atob(const nsAString& aAsciiBase64String, nsAString& aBinaryData,
             mozilla::ErrorResult& aError);
   void Btoa(const nsAString& aBinaryData, nsAString& aAsciiBase64String,
             mozilla::ErrorResult& aError);
-  mozilla::dom::DOMStorage* GetSessionStorage(mozilla::ErrorResult& aError);
-  mozilla::dom::DOMStorage*
+  mozilla::dom::Storage* GetSessionStorage(mozilla::ErrorResult& aError);
+  mozilla::dom::Storage*
   GetLocalStorage(mozilla::ErrorResult& aError);
   mozilla::dom::Selection* GetSelectionOuter();
   mozilla::dom::Selection* GetSelection(mozilla::ErrorResult& aError);
   already_AddRefed<nsISelection> GetSelection() override;
   mozilla::dom::IDBFactory* GetIndexedDB(mozilla::ErrorResult& aError);
   already_AddRefed<nsICSSDeclaration>
     GetComputedStyle(mozilla::dom::Element& aElt, const nsAString& aPseudoElt,
                      mozilla::ErrorResult& aError) override;
@@ -1879,31 +1879,30 @@ protected:
   // We need to store an nsISupports pointer to this object because the
   // mozilla::dom::External class doesn't exist on b2g and using the type
   // forward declared here means that ~nsGlobalWindow wouldn't compile because
   // it wouldn't see the ~External function's declaration.
   nsCOMPtr<nsISupports>         mExternal;
 
   RefPtr<mozilla::dom::MozSelfSupport> mMozSelfSupport;
 
-  RefPtr<mozilla::dom::DOMStorage> mLocalStorage;
-  RefPtr<mozilla::dom::DOMStorage> mSessionStorage;
+  RefPtr<mozilla::dom::Storage> mLocalStorage;
+  RefPtr<mozilla::dom::Storage> mSessionStorage;
 
   // These member variable are used only on inner windows.
   RefPtr<mozilla::EventListenerManager> mListenerManager;
   RefPtr<mozilla::dom::Location> mLocation;
   RefPtr<nsHistory>           mHistory;
   RefPtr<mozilla::dom::CustomElementRegistry> mCustomElements;
 
   // These member variables are used on both inner and the outer windows.
   nsCOMPtr<nsIPrincipal> mDocumentPrincipal;
 
-  typedef nsTArray<RefPtr<mozilla::dom::StorageEvent>> nsDOMStorageEventArray;
-  nsDOMStorageEventArray mPendingStorageEvents;
-
+  typedef nsTArray<RefPtr<mozilla::dom::StorageEvent>> nsStorageEventArray;
+  nsStorageEventArray mPendingStorageEvents;
 
   uint32_t mSuspendDepth;
   uint32_t mFreezeDepth;
 
   // the method that was used to focus mFocusedNode
   uint32_t mFocusMethod;
 
   uint32_t mSerial;

--- a/dom/bindings/Bindings.conf
+++ b/dom/bindings/Bindings.conf
@@ -758,20 +758,16 @@ DOMInterfaces = {
     'headerFile': 'mozilla/dom/workers/bindings/SharedWorker.h',
     'implicitJSContext': [ 'constructor' ],
 },
 
 'SharedWorkerGlobalScope': {
     'headerFile': 'mozilla/dom/WorkerScope.h',
 },
 
-'Storage': {
-    'nativeType': 'mozilla::dom::DOMStorage',
-},
-
 'StyleSheet': {
     'nativeType': 'mozilla::StyleSheet',
     'headerFile': 'mozilla/StyleSheetInlines.h',
 },
 
 'SVGAnimatedLengthList': {
     'nativeType': 'mozilla::DOMSVGAnimatedLengthList',
     'headerFile': 'DOMSVGAnimatedLengthList.h',

--- a/dom/bindings/SimpleGlobalObject.cpp
+++ b/dom/bindings/SimpleGlobalObject.cpp
@@ -99,17 +99,23 @@ SimpleGlobalObject::Create(GlobalType gl
   JS::Rooted<JSObject*> global(RootingCx());
 
   { // Scope to ensure the AutoJSAPI destructor runs before we end up returning
     AutoJSAPI jsapi;
     jsapi.Init();
     JSContext* cx = jsapi.cx();
 
     JS::CompartmentOptions options;
-    options.creationOptions().setInvisibleToDebugger(true);
+    options.creationOptions()
+           .setInvisibleToDebugger(true)
+           // Put our SimpleGlobalObjects in the system zone, so we won't create
+           // lots of zones for what are probably very short-lived
+           // compartments.  This should help them be GCed quicker and take up
+           // less memory before they're GCed.
+          .setZone(JS::SystemZone);
 
     if (NS_IsMainThread()) {
       nsCOMPtr<nsIPrincipal> principal = nsNullPrincipal::Create();
       options.creationOptions().setTrace(xpc::TraceXPCGlobal);
       global = xpc::CreateGlobalObject(cx, js::Jsvalify(&SimpleGlobalClass),
                                        nsJSPrincipals::get(principal),
                                        options);
     } else {

--- a/dom/events/StorageEvent.cpp
+++ b/dom/events/StorageEvent.cpp
@@ -1,16 +1,16 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 #include "mozilla/dom/StorageEvent.h"
-#include "mozilla/dom/DOMStorage.h"
+#include "mozilla/dom/Storage.h"
 
 namespace mozilla {
 namespace dom {
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(StorageEvent)
 
 NS_IMPL_ADDREF_INHERITED(StorageEvent, Event)
 NS_IMPL_RELEASE_INHERITED(StorageEvent, Event)
@@ -80,17 +80,17 @@ StorageEvent::Constructor(const GlobalOb
 }
 
 void
 StorageEvent::InitStorageEvent(const nsAString& aType, bool aCanBubble,
                                bool aCancelable, const nsAString& aKey,
                                const nsAString& aOldValue,
                                const nsAString& aNewValue,
                                const nsAString& aURL,
-                               DOMStorage* aStorageArea)
+                               Storage* aStorageArea)
 {
   NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
 
   InitEvent(aType, aCanBubble, aCancelable);
   mKey = aKey;
   mOldValue = aOldValue;
   mNewValue = aNewValue;
   mUrl = aURL;

--- a/dom/events/StorageEvent.h
+++ b/dom/events/StorageEvent.h
@@ -11,34 +11,34 @@
 #include "mozilla/ErrorResult.h"
 #include "mozilla/dom/BindingUtils.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/StorageEventBinding.h"
 
 namespace mozilla {
 namespace dom {
 
-class DOMStorage;
+class Storage;
 
 class StorageEvent : public Event
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(StorageEvent, Event)
 
   explicit StorageEvent(EventTarget* aOwner);
 
 protected:
   virtual ~StorageEvent();
 
   nsString mKey;
   nsString mOldValue;
   nsString mNewValue;
   nsString mUrl;
-  RefPtr<DOMStorage> mStorageArea;
+  RefPtr<Storage> mStorageArea;
 
 public:
   virtual StorageEvent* AsStorageEvent();
 
   virtual JSObject* WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
 
   static already_AddRefed<StorageEvent>
   Constructor(EventTarget* aOwner, const nsAString& aType,
@@ -48,17 +48,17 @@ public:
   Constructor(const GlobalObject& aGlobal, const nsAString& aType,
               const StorageEventInit& aEventInitDict, ErrorResult& aRv);
 
   void InitStorageEvent(const nsAString& aType, bool aCanBubble,
                         bool aCancelable, const nsAString& aKey,
                         const nsAString& aOldValue,
                         const nsAString& aNewValue,
                         const nsAString& aURL,
-                        DOMStorage* aStorageArea);
+                        Storage* aStorageArea);
 
   void GetKey(nsString& aRetVal) const
   {
     aRetVal = mKey;
   }
 
   void GetOldValue(nsString& aRetVal) const
   {
@@ -70,17 +70,17 @@ public:
     aRetVal = mNewValue;
   }
 
   void GetUrl(nsString& aRetVal) const
   {
     aRetVal = mUrl;
   }
 
-  DOMStorage* GetStorageArea() const
+  Storage* GetStorageArea() const
   {
     return mStorageArea;
   }
 };
 
 } // namespace dom
 } // namespace mozilla
 

--- a/dom/fetch/InternalRequest.cpp
+++ b/dom/fetch/InternalRequest.cpp
@@ -437,35 +437,17 @@ InternalRequest::MapChannelToRequestMode
 RequestCredentials
 InternalRequest::MapChannelToRequestCredentials(nsIChannel* aChannel)
 {
   MOZ_ASSERT(aChannel);
 
   nsCOMPtr<nsILoadInfo> loadInfo;
   MOZ_ALWAYS_SUCCEEDS(aChannel->GetLoadInfo(getter_AddRefs(loadInfo)));
 
-
-  // TODO: Remove following code after stylesheet and image support cookie policy
-  if (loadInfo->GetSecurityMode() == nsILoadInfo::SEC_NORMAL) {
-    uint32_t loadFlags;
-    aChannel->GetLoadFlags(&loadFlags);
-
-    if (loadFlags & nsIRequest::LOAD_ANONYMOUS) {
-      return RequestCredentials::Omit;
-    } else {
-      bool includeCrossOrigin;
-      nsCOMPtr<nsIHttpChannelInternal> internalChannel = do_QueryInterface(aChannel);
-
-      internalChannel->GetCorsIncludeCredentials(&includeCrossOrigin);
-      if (includeCrossOrigin) {
-        return RequestCredentials::Include;
-      }
-    }
-    return RequestCredentials::Same_origin;
-  }
+  MOZ_DIAGNOSTIC_ASSERT(loadInfo->GetSecurityMode() != nsILoadInfo::SEC_NORMAL);
 
   uint32_t cookiePolicy = loadInfo->GetCookiePolicy();
 
   if (cookiePolicy == nsILoadInfo::SEC_COOKIES_INCLUDE) {
     return RequestCredentials::Include;
   } else if (cookiePolicy == nsILoadInfo::SEC_COOKIES_OMIT) {
     return RequestCredentials::Omit;
   } else if (cookiePolicy == nsILoadInfo::SEC_COOKIES_SAME_ORIGIN) {

--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -23,23 +23,23 @@
 #include "mozilla/devtools/HeapSnapshotTempFileHelperChild.h"
 #include "mozilla/docshell/OfflineCacheUpdateChild.h"
 #include "mozilla/dom/ContentBridgeChild.h"
 #include "mozilla/dom/ContentBridgeParent.h"
 #include "mozilla/dom/VideoDecoderManagerChild.h"
 #include "mozilla/dom/ContentParent.h"
 #include "mozilla/dom/DataTransfer.h"
 #include "mozilla/dom/DocGroup.h"
-#include "mozilla/dom/DOMStorageIPC.h"
 #include "mozilla/dom/ExternalHelperAppChild.h"
 #include "mozilla/dom/FlyWebPublishedServerIPC.h"
 #include "mozilla/dom/GetFilesHelper.h"
 #include "mozilla/dom/PCrashReporterChild.h"
 #include "mozilla/dom/ProcessGlobal.h"
 #include "mozilla/dom/PushNotifier.h"
+#include "mozilla/dom/StorageIPC.h"
 #include "mozilla/dom/TabGroup.h"
 #include "mozilla/dom/workers/ServiceWorkerManager.h"
 #include "mozilla/dom/nsIContentChild.h"
 #include "mozilla/dom/URLClassifierChild.h"
 #include "mozilla/dom/ipc/BlobChild.h"
 #include "mozilla/gfx/gfxVars.h"
 #include "mozilla/psm/PSMContentListener.h"
 #include "mozilla/hal_sandbox/PHalChild.h"
@@ -1947,17 +1947,17 @@ ContentChild::AllocPStorageChild()
 {
   MOZ_CRASH("We should never be manually allocating PStorageChild actors");
   return nullptr;
 }
 
 bool
 ContentChild::DeallocPStorageChild(PStorageChild* aActor)
 {
-  DOMStorageDBChild* child = static_cast<DOMStorageDBChild*>(aActor);
+  StorageDBChild* child = static_cast<StorageDBChild*>(aActor);
   child->ReleaseIPDLReference();
   return true;
 }
 
 PSpeechSynthesisChild*
 ContentChild::AllocPSpeechSynthesisChild()
 {
 #ifdef MOZ_WEBSPEECH

--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -36,28 +36,28 @@
 #include "mozilla/WindowsVersion.h"
 #endif
 #include "mozilla/ClearOnShutdown.h"
 #include "mozilla/StyleSheetInlines.h"
 #include "mozilla/DataStorage.h"
 #include "mozilla/devtools/HeapSnapshotTempFileHelperParent.h"
 #include "mozilla/docshell/OfflineCacheUpdateParent.h"
 #include "mozilla/dom/DataTransfer.h"
-#include "mozilla/dom/DOMStorageIPC.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/File.h"
 #include "mozilla/dom/ExternalHelperAppParent.h"
 #include "mozilla/dom/GetFilesHelper.h"
 #include "mozilla/dom/GeolocationBinding.h"
 #include "mozilla/dom/Notification.h"
 #include "mozilla/dom/PContentBridgeParent.h"
 #include "mozilla/dom/PContentPermissionRequestParent.h"
 #include "mozilla/dom/PCycleCollectWithLogsParent.h"
 #include "mozilla/dom/PMemoryReportRequestParent.h"
 #include "mozilla/dom/ServiceWorkerRegistrar.h"
+#include "mozilla/dom/StorageIPC.h"
 #include "mozilla/dom/devicestorage/DeviceStorageRequestParent.h"
 #include "mozilla/dom/power/PowerManagerService.h"
 #include "mozilla/dom/Permissions.h"
 #include "mozilla/dom/PresentationParent.h"
 #include "mozilla/dom/PPresentationParent.h"
 #include "mozilla/dom/PushNotifier.h"
 #include "mozilla/dom/FlyWebPublishedServerIPC.h"
 #include "mozilla/dom/quota/QuotaManagerService.h"
@@ -3035,23 +3035,23 @@ bool
 ContentParent::DeallocPMediaParent(media::PMediaParent *aActor)
 {
   return media::DeallocPMediaParent(aActor);
 }
 
 PStorageParent*
 ContentParent::AllocPStorageParent()
 {
-  return new DOMStorageDBParent();
+  return new StorageDBParent();
 }
 
 bool
 ContentParent::DeallocPStorageParent(PStorageParent* aActor)
 {
-  DOMStorageDBParent* child = static_cast<DOMStorageDBParent*>(aActor);
+  StorageDBParent* child = static_cast<StorageDBParent*>(aActor);
   child->ReleaseIPDLReference();
   return true;
 }
 
 PPresentationParent*
 ContentParent::AllocPPresentationParent()
 {
   RefPtr<PresentationParent> actor = new PresentationParent();

--- a/dom/storage/PStorage.ipdl
+++ b/dom/storage/PStorage.ipdl
@@ -4,42 +4,49 @@
  * 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/. */
 
 include protocol PContent;
 
 namespace mozilla {
 namespace dom {
 
-/* This protocol bridges async access to the database thread running on the parent process
- * and caches running on the child process.
+/* This protocol bridges async access to the database thread running on the
+ * parent process and caches running on the child process.
  */
 nested(upto inside_cpow) sync protocol PStorage
 {
   manager PContent;
 
 parent:
   async __delete__();
 
-  nested(inside_cpow) sync Preload(nsCString originSuffix, nsCString originNoSuffix, uint32_t alreadyLoadedCount)
+  nested(inside_cpow) sync Preload(nsCString originSuffix,
+                                   nsCString originNoSuffix,
+                                   uint32_t alreadyLoadedCount)
     returns (nsString[] keys, nsString[] values, nsresult rv);
 
-  async AsyncPreload(nsCString originSuffix, nsCString originNoSuffix, bool priority);
+  async AsyncPreload(nsCString originSuffix, nsCString originNoSuffix,
+                     bool priority);
   async AsyncGetUsage(nsCString scope);
-  async AsyncAddItem(nsCString originSuffix, nsCString originNoSuffix, nsString key, nsString value);
-  async AsyncUpdateItem(nsCString originSuffix, nsCString originNoSuffix, nsString key, nsString value);
-  async AsyncRemoveItem(nsCString originSuffix, nsCString originNoSuffix, nsString key);
+  async AsyncAddItem(nsCString originSuffix, nsCString originNoSuffix,
+                     nsString key, nsString value);
+  async AsyncUpdateItem(nsCString originSuffix, nsCString originNoSuffix,
+                        nsString key, nsString value);
+  async AsyncRemoveItem(nsCString originSuffix, nsCString originNoSuffix,
+                        nsString key);
   async AsyncClear(nsCString originSuffix, nsCString originNoSuffix);
   async AsyncFlush();
   
 child:
   async Observe(nsCString topic,
                 nsString originAttributesPattern,
                 nsCString originScope);
   async OriginsHavingData(nsCString[] origins);
-  async LoadItem(nsCString originSuffix, nsCString originNoSuffix, nsString key, nsString value);
+  async LoadItem(nsCString originSuffix, nsCString originNoSuffix, nsString key,
+                 nsString value);
   async LoadDone(nsCString originSuffix, nsCString originNoSuffix, nsresult rv);
   async LoadUsage(nsCString scope, int64_t usage);
   async Error(nsresult rv);
 };
 
 }
 }

rename from dom/storage/DOMStorage.cpp
rename to dom/storage/Storage.cpp
--- a/dom/storage/DOMStorage.cpp
+++ b/dom/storage/Storage.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
-#include "DOMStorage.h"
-#include "DOMStorageCache.h"
-#include "DOMStorageManager.h"
+#include "Storage.h"
+#include "StorageCache.h"
+#include "StorageManager.h"
 
 #include "nsIObserverService.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsIPermissionManager.h"
 #include "nsIPrincipal.h"
 #include "nsICookiePermission.h"
 
 #include "mozilla/dom/StorageBinding.h"
@@ -22,98 +22,98 @@
 #include "mozilla/EnumSet.h"
 #include "nsThreadUtils.h"
 #include "nsContentUtils.h"
 #include "nsServiceManagerUtils.h"
 
 namespace mozilla {
 namespace dom {
 
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(DOMStorage, mManager, mPrincipal, mWindow)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(Storage, mManager, mPrincipal, mWindow)
 
-NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMStorage)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMStorage)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(Storage)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(Storage)
 
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMStorage)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Storage)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMStorage)
   NS_INTERFACE_MAP_ENTRY(nsIDOMStorage)
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 NS_INTERFACE_MAP_END
 
-DOMStorage::DOMStorage(nsPIDOMWindowInner* aWindow,
-                       DOMStorageManager* aManager,
-                       DOMStorageCache* aCache,
-                       const nsAString& aDocumentURI,
-                       nsIPrincipal* aPrincipal)
-: mWindow(aWindow)
-, mManager(aManager)
-, mCache(aCache)
-, mDocumentURI(aDocumentURI)
-, mPrincipal(aPrincipal)
-, mIsSessionOnly(false)
+Storage::Storage(nsPIDOMWindowInner* aWindow,
+                 StorageManagerBase* aManager,
+                 StorageCache* aCache,
+                 const nsAString& aDocumentURI,
+                 nsIPrincipal* aPrincipal)
+  : mWindow(aWindow)
+  , mManager(aManager)
+  , mCache(aCache)
+  , mDocumentURI(aDocumentURI)
+  , mPrincipal(aPrincipal)
+  , mIsSessionOnly(false)
 {
   mCache->Preload();
 }
 
-DOMStorage::~DOMStorage()
+Storage::~Storage()
 {
   mCache->KeepAlive();
 }
 
 /* virtual */ JSObject*
-DOMStorage::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+Storage::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
   return StorageBinding::Wrap(aCx, this, aGivenProto);
 }
 
 uint32_t
-DOMStorage::GetLength(nsIPrincipal& aSubjectPrincipal,
-                      ErrorResult& aRv)
+Storage::GetLength(nsIPrincipal& aSubjectPrincipal,
+                   ErrorResult& aRv)
 {
   if (!CanUseStorage(aSubjectPrincipal)) {
     aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
     return 0;
   }
 
   uint32_t length;
   aRv = mCache->GetLength(this, &length);
   return length;
 }
 
 void
-DOMStorage::Key(uint32_t aIndex, nsAString& aResult,
-                nsIPrincipal& aSubjectPrincipal,
-                ErrorResult& aRv)
+Storage::Key(uint32_t aIndex, nsAString& aResult,
+             nsIPrincipal& aSubjectPrincipal,
+             ErrorResult& aRv)
 {
   if (!CanUseStorage(aSubjectPrincipal)) {
     aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
     return;
   }
 
   aRv = mCache->GetKey(this, aIndex, aResult);
 }
 
 void
-DOMStorage::GetItem(const nsAString& aKey, nsAString& aResult,
-                    nsIPrincipal& aSubjectPrincipal,
-                    ErrorResult& aRv)
+Storage::GetItem(const nsAString& aKey, nsAString& aResult,
+                 nsIPrincipal& aSubjectPrincipal,
+                 ErrorResult& aRv)
 {
   if (!CanUseStorage(aSubjectPrincipal)) {
     aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
     return;
   }
 
   aRv = mCache->GetItem(this, aKey, aResult);
 }
 
 void
-DOMStorage::SetItem(const nsAString& aKey, const nsAString& aData,
-                    nsIPrincipal& aSubjectPrincipal,
-                    ErrorResult& aRv)
+Storage::SetItem(const nsAString& aKey, const nsAString& aData,
+                 nsIPrincipal& aSubjectPrincipal,
+                 ErrorResult& aRv)
 {
   if (!CanUseStorage(aSubjectPrincipal)) {
     aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
     return;
   }
 
   nsString data;
   bool ok = data.Assign(aData, fallible);
@@ -129,19 +129,18 @@ DOMStorage::SetItem(const nsAString& aKe
   }
 
   if (!aRv.ErrorCodeIs(NS_SUCCESS_DOM_NO_OPERATION)) {
     BroadcastChangeNotification(aKey, old, aData);
   }
 }
 
 void
-DOMStorage::RemoveItem(const nsAString& aKey,
-                       nsIPrincipal& aSubjectPrincipal,
-                       ErrorResult& aRv)
+Storage::RemoveItem(const nsAString& aKey, nsIPrincipal& aSubjectPrincipal,
+                    ErrorResult& aRv)
 {
   if (!CanUseStorage(aSubjectPrincipal)) {
     aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
     return;
   }
 
   nsAutoString old;
   aRv = mCache->RemoveItem(this, aKey, old);
@@ -150,18 +149,17 @@ DOMStorage::RemoveItem(const nsAString& 
   }
 
   if (!aRv.ErrorCodeIs(NS_SUCCESS_DOM_NO_OPERATION)) {
     BroadcastChangeNotification(aKey, old, NullString());
   }
 }
 
 void
-DOMStorage::Clear(nsIPrincipal& aSubjectPrincipal,
-                  ErrorResult& aRv)
+Storage::Clear(nsIPrincipal& aSubjectPrincipal, ErrorResult& aRv)
 {
   if (!CanUseStorage(aSubjectPrincipal)) {
     aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
     return;
   }
 
   aRv = mCache->Clear(this);
   if (NS_WARN_IF(aRv.Failed())) {
@@ -204,19 +202,19 @@ StorageNotifierRunnable::Run()
                                      mType);
   }
   return NS_OK;
 }
 
 } // namespace
 
 void
-DOMStorage::BroadcastChangeNotification(const nsSubstring& aKey,
-                                        const nsSubstring& aOldValue,
-                                        const nsSubstring& aNewValue)
+Storage::BroadcastChangeNotification(const nsSubstring& aKey,
+                                     const nsSubstring& aOldValue,
+                                     const nsSubstring& aNewValue)
 {
   StorageEventInit dict;
   dict.mBubbles = false;
   dict.mCancelable = false;
   dict.mKey = aKey;
   dict.mNewValue = aNewValue;
   dict.mOldValue = aOldValue;
   dict.mStorageArea = this;
@@ -235,17 +233,17 @@ DOMStorage::BroadcastChangeNotification(
                                 IsPrivate());
   NS_DispatchToMainThread(r);
 }
 
 static const char kPermissionType[] = "cookie";
 static const char kStorageEnabled[] = "dom.storage.enabled";
 
 bool
-DOMStorage::CanUseStorage(nsIPrincipal& aSubjectPrincipal)
+Storage::CanUseStorage(nsIPrincipal& aSubjectPrincipal)
 {
   // This method is responsible for correct setting of mIsSessionOnly.
 
   if (!mozilla::Preferences::GetBool(kStorageEnabled)) {
     return false;
   }
 
   nsContentUtils::StorageAccess access =
@@ -254,57 +252,58 @@ DOMStorage::CanUseStorage(nsIPrincipal& 
   if (access == nsContentUtils::StorageAccess::eDeny) {
     return false;
   }
 
   mIsSessionOnly = access <= nsContentUtils::StorageAccess::eSessionScoped;
   return CanAccess(&aSubjectPrincipal);
 }
 
-DOMStorage::StorageType
-DOMStorage::GetType() const
+Storage::StorageType
+Storage::GetType() const
 {
   return mManager->Type();
 }
 
 nsIPrincipal*
-DOMStorage::GetPrincipal()
+Storage::GetPrincipal()
 {
   return mPrincipal;
 }
 
-// Defined in DOMStorageManager.cpp
+// Defined in StorageManager.cpp
 extern bool
-PrincipalsEqual(nsIPrincipal* aObjectPrincipal, nsIPrincipal* aSubjectPrincipal);
+PrincipalsEqual(nsIPrincipal* aObjectPrincipal,
+                nsIPrincipal* aSubjectPrincipal);
 
 bool
-DOMStorage::PrincipalEquals(nsIPrincipal* aPrincipal)
+Storage::PrincipalEquals(nsIPrincipal* aPrincipal)
 {
   return PrincipalsEqual(mPrincipal, aPrincipal);
 }
 
 bool
-DOMStorage::IsPrivate() const
+Storage::IsPrivate() const
 {
   uint32_t privateBrowsingId = 0;
   nsresult rv = mPrincipal->GetPrivateBrowsingId(&privateBrowsingId);
   if (NS_FAILED(rv)) {
     return false;
   }
   return privateBrowsingId > 0;
 }
 
 bool
-DOMStorage::CanAccess(nsIPrincipal* aPrincipal)
+Storage::CanAccess(nsIPrincipal* aPrincipal)
 {
   return !aPrincipal || aPrincipal->Subsumes(mPrincipal);
 }
 
 void
-DOMStorage::GetSupportedNames(nsTArray<nsString>& aKeys)
+Storage::GetSupportedNames(nsTArray<nsString>& aKeys)
 {
   if (!CanUseStorage(*nsContentUtils::SubjectPrincipal())) {
     // return just an empty array
     aKeys.Clear();
     return;
   }
 
   mCache->GetKeys(this, aKeys);

rename from dom/storage/DOMStorage.h
rename to dom/storage/Storage.h
--- a/dom/storage/DOMStorage.h
+++ b/dom/storage/Storage.h
@@ -1,74 +1,75 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
-#ifndef nsDOMStorage_h___
-#define nsDOMStorage_h___
+#ifndef mozilla_dom_Storage_h
+#define mozilla_dom_Storage_h
 
 #include "mozilla/Attributes.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/Maybe.h"
 #include "nsIDOMStorage.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsWeakReference.h"
 #include "nsWrapperCache.h"
 #include "nsISupports.h"
 
 class nsIPrincipal;
 class nsPIDOMWindowInner;
 
 namespace mozilla {
 namespace dom {
 
-class DOMStorageManager;
-class DOMStorageCache;
+class StorageManagerBase;
+class StorageCache;
 
-class DOMStorage final
+class Storage final
   : public nsIDOMStorage
   , public nsSupportsWeakReference
   , public nsWrapperCache
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(DOMStorage,
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(Storage,
                                                          nsIDOMStorage)
 
   enum StorageType {
     LocalStorage = 1,
     SessionStorage = 2
   };
 
   StorageType GetType() const;
 
-  DOMStorageManager* GetManager() const
+  StorageManagerBase* GetManager() const
   {
     return mManager;
   }
 
-  DOMStorageCache const* GetCache() const
+  StorageCache const* GetCache() const
   {
     return mCache;
   }
 
   nsIPrincipal* GetPrincipal();
   bool PrincipalEquals(nsIPrincipal* aPrincipal);
   bool CanAccess(nsIPrincipal* aPrincipal);
 
-  DOMStorage(nsPIDOMWindowInner* aWindow,
-             DOMStorageManager* aManager,
-             DOMStorageCache* aCache,
-             const nsAString& aDocumentURI,
-             nsIPrincipal* aPrincipal);
+  Storage(nsPIDOMWindowInner* aWindow,
+          StorageManagerBase* aManager,
+          StorageCache* aCache,
+          const nsAString& aDocumentURI,
+          nsIPrincipal* aPrincipal);
 
   // WebIDL
-  JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
 
   nsPIDOMWindowInner* GetParentObject() const
   {
     return mWindow;
   }
 
   uint32_t GetLength(nsIPrincipal& aSubjectPrincipal,
                      ErrorResult& aRv);
@@ -116,53 +117,53 @@ public:
   }
 
   void Clear(nsIPrincipal& aSubjectPrincipal,
              ErrorResult& aRv);
 
   bool IsPrivate() const;
   bool IsSessionOnly() const { return mIsSessionOnly; }
 
-  bool IsForkOf(const DOMStorage* aOther) const
+  bool IsForkOf(const Storage* aOther) const
   {
     MOZ_ASSERT(aOther);
     return mCache == aOther->mCache;
   }
 
 protected:
   // The method checks whether the caller can use a storage.
   // CanUseStorage is called before any DOM initiated operation
   // on a storage is about to happen and ensures that the storage's
   // session-only flag is properly set according the current settings.
   // It is an optimization since the privileges check and session only
   // state determination are complex and share the code (comes hand in
   // hand together).
   bool CanUseStorage(nsIPrincipal& aSubjectPrincipal);
 
 private:
-  ~DOMStorage();
+  ~Storage();
 
-  friend class DOMStorageManager;
-  friend class DOMStorageCache;
+  friend class StorageManagerBase;
+  friend class StorageCache;
 
   nsCOMPtr<nsPIDOMWindowInner> mWindow;
-  RefPtr<DOMStorageManager> mManager;
-  RefPtr<DOMStorageCache> mCache;
+  RefPtr<StorageManagerBase> mManager;
+  RefPtr<StorageCache> mCache;
   nsString mDocumentURI;
 
-  // Principal this DOMStorage (i.e. localStorage or sessionStorage) has
+  // Principal this Storage (i.e. localStorage or sessionStorage) has
   // been created for
   nsCOMPtr<nsIPrincipal> mPrincipal;
 
   // Whether storage is set to persist data only per session, may change
   // dynamically and is set by CanUseStorage function that is called
   // before any operation on the storage.
   bool mIsSessionOnly : 1;
 
   void BroadcastChangeNotification(const nsSubstring& aKey,
                                    const nsSubstring& aOldValue,
                                    const nsSubstring& aNewValue);
 };
 
 } // namespace dom
 } // namespace mozilla
 
-#endif /* nsDOMStorage_h___ */
+#endif // mozilla_dom_Storage_h

rename from dom/storage/DOMStorageCache.cpp
rename to dom/storage/StorageCache.cpp
--- a/dom/storage/DOMStorageCache.cpp
+++ b/dom/storage/StorageCache.cpp
@@ -1,36 +1,36 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
-#include "DOMStorageCache.h"
+#include "StorageCache.h"
 
-#include "DOMStorage.h"
-#include "DOMStorageDBThread.h"
-#include "DOMStorageIPC.h"
-#include "DOMStorageManager.h"
+#include "Storage.h"
+#include "StorageDBThread.h"
+#include "StorageIPC.h"
+#include "StorageManager.h"
 
 #include "nsAutoPtr.h"
 #include "nsDOMString.h"
 #include "nsXULAppAPI.h"
 #include "mozilla/Unused.h"
 #include "nsProxyRelease.h"
 #include "nsThreadUtils.h"
 
 namespace mozilla {
 namespace dom {
 
 #define DOM_STORAGE_CACHE_KEEP_ALIVE_TIME_MS 20000
 
 // static
-DOMStorageDBBridge* DOMStorageCache::sDatabase = nullptr;
-bool DOMStorageCache::sDatabaseDown = false;
+StorageDBBridge* StorageCache::sDatabase = nullptr;
+bool StorageCache::sDatabaseDown = false;
 
 namespace {
 
 const uint32_t kDefaultSet = 0;
 const uint32_t kPrivateSet = 1;
 const uint32_t kSessionSet = 2;
 
 inline uint32_t
@@ -43,94 +43,94 @@ GetDataSetIndex(bool aPrivate, bool aSes
   if (aSessionOnly) {
     return kSessionSet;
   }
 
   return kDefaultSet;
 }
 
 inline uint32_t
-GetDataSetIndex(const DOMStorage* aStorage)
+GetDataSetIndex(const Storage* aStorage)
 {
   return GetDataSetIndex(aStorage->IsPrivate(), aStorage->IsSessionOnly());
 }
 
 } // namespace
 
-// DOMStorageCacheBridge
+// StorageCacheBridge
 
-NS_IMPL_ADDREF(DOMStorageCacheBridge)
+NS_IMPL_ADDREF(StorageCacheBridge)
 
 // Since there is no consumer of return value of Release, we can turn this 
-// method to void to make implementation of asynchronous DOMStorageCache::Release
+// method to void to make implementation of asynchronous StorageCache::Release
 // much simpler.
-NS_IMETHODIMP_(void) DOMStorageCacheBridge::Release(void)
+NS_IMETHODIMP_(void) StorageCacheBridge::Release(void)
 {
   MOZ_ASSERT(int32_t(mRefCnt) > 0, "dup release");
   nsrefcnt count = --mRefCnt;
-  NS_LOG_RELEASE(this, count, "DOMStorageCacheBridge");
+  NS_LOG_RELEASE(this, count, "StorageCacheBridge");
   if (0 == count) {
     mRefCnt = 1; /* stabilize */
     /* enable this to find non-threadsafe destructors: */
     /* NS_ASSERT_OWNINGTHREAD(_class); */
     delete (this);
   }
 }
 
-// DOMStorageCache
+// StorageCache
 
-DOMStorageCache::DOMStorageCache(const nsACString* aOriginNoSuffix)
-: mOriginNoSuffix(*aOriginNoSuffix)
-, mMonitor("DOMStorageCache")
-, mLoaded(false)
-, mLoadResult(NS_OK)
-, mInitialized(false)
-, mPersistent(false)
-, mSessionOnlyDataSetActive(false)
-, mPreloadTelemetryRecorded(false)
+StorageCache::StorageCache(const nsACString* aOriginNoSuffix)
+  : mOriginNoSuffix(*aOriginNoSuffix)
+  , mMonitor("StorageCache")
+  , mLoaded(false)
+  , mLoadResult(NS_OK)
+  , mInitialized(false)
+  , mPersistent(false)
+  , mSessionOnlyDataSetActive(false)
+  , mPreloadTelemetryRecorded(false)
 {
-  MOZ_COUNT_CTOR(DOMStorageCache);
+  MOZ_COUNT_CTOR(StorageCache);
 }
 
-DOMStorageCache::~DOMStorageCache()
+StorageCache::~StorageCache()
 {
   if (mManager) {
     mManager->DropCache(this);
   }
 
-  MOZ_COUNT_DTOR(DOMStorageCache);
+  MOZ_COUNT_DTOR(StorageCache);
 }
 
 NS_IMETHODIMP_(void)
-DOMStorageCache::Release(void)
+StorageCache::Release(void)
 {
   // We must actually release on the main thread since the cache removes it
   // self from the manager's hash table.  And we don't want to lock access to
   // that hash table.
   if (NS_IsMainThread()) {
-    DOMStorageCacheBridge::Release();
+    StorageCacheBridge::Release();
     return;
   }
 
-  RefPtr<nsRunnableMethod<DOMStorageCacheBridge, void, false> > event =
-    NewNonOwningRunnableMethod(static_cast<DOMStorageCacheBridge*>(this),
-                               &DOMStorageCacheBridge::Release);
+  RefPtr<nsRunnableMethod<StorageCacheBridge, void, false> > event =
+    NewNonOwningRunnableMethod(static_cast<StorageCacheBridge*>(this),
+                               &StorageCacheBridge::Release);
 
   nsresult rv = NS_DispatchToMainThread(event);
   if (NS_FAILED(rv)) {
-    NS_WARNING("DOMStorageCache::Release() on a non-main thread");
-    DOMStorageCacheBridge::Release();
+    NS_WARNING("StorageCache::Release() on a non-main thread");
+    StorageCacheBridge::Release();
   }
 }
 
 void
-DOMStorageCache::Init(DOMStorageManager* aManager,
-                      bool aPersistent,
-                      nsIPrincipal* aPrincipal,
-                      const nsACString& aQuotaOriginScope)
+StorageCache::Init(StorageManagerBase* aManager,
+                   bool aPersistent,
+                   nsIPrincipal* aPrincipal,
+                   const nsACString& aQuotaOriginScope)
 {
   if (mInitialized) {
     return;
   }
 
   mInitialized = true;
   mPrincipal = aPrincipal;
   aPrincipal->OriginAttributesRef().CreateSuffix(mOriginSuffix);
@@ -151,31 +151,31 @@ DOMStorageCache::Init(DOMStorageManager*
   MOZ_ASSERT(StringBeginsWith(mQuotaOriginScope, mOriginSuffix));
   MOZ_ASSERT(mOriginSuffix.IsEmpty() != StringBeginsWith(mQuotaOriginScope, 
                                                          NS_LITERAL_CSTRING("^")));
 
   mUsage = aManager->GetOriginUsage(mQuotaOriginScope);
 }
 
 inline bool
-DOMStorageCache::Persist(const DOMStorage* aStorage) const
+StorageCache::Persist(const Storage* aStorage) const
 {
   return mPersistent &&
          !aStorage->IsSessionOnly() &&
          !aStorage->IsPrivate();
 }
 
 const nsCString
-DOMStorageCache::Origin() const
+StorageCache::Origin() const
 {
-  return DOMStorageManager::CreateOrigin(mOriginSuffix, mOriginNoSuffix);
+  return StorageManagerBase::CreateOrigin(mOriginSuffix, mOriginNoSuffix);
 }
 
-DOMStorageCache::Data&
-DOMStorageCache::DataSet(const DOMStorage* aStorage)
+StorageCache::Data&
+StorageCache::DataSet(const Storage* aStorage)
 {
   uint32_t index = GetDataSetIndex(aStorage);
 
   if (index == kSessionSet && !mSessionOnlyDataSetActive) {
     // Session only data set is demanded but not filled with
     // current data set, copy to session only set now.
 
     WaitForPreload(Telemetry::LOCALDOMSTORAGE_SESSIONONLY_PRELOAD_BLOCKING_MS);
@@ -193,48 +193,48 @@ DOMStorageCache::DataSet(const DOMStorag
     // for all session only data
     ProcessUsageDelta(kSessionSet, defaultSet.mOriginQuotaUsage);
   }
 
   return mData[index];
 }
 
 bool
-DOMStorageCache::ProcessUsageDelta(const DOMStorage* aStorage, int64_t aDelta)
+StorageCache::ProcessUsageDelta(const Storage* aStorage, int64_t aDelta)
 {
   return ProcessUsageDelta(GetDataSetIndex(aStorage), aDelta);
 }
 
 bool
-DOMStorageCache::ProcessUsageDelta(uint32_t aGetDataSetIndex, const int64_t aDelta)
+StorageCache::ProcessUsageDelta(uint32_t aGetDataSetIndex, const int64_t aDelta)
 {
   // Check if we are in a low disk space situation
   if (aDelta > 0 && mManager && mManager->IsLowDiskSpace()) {
     return false;
   }
 
   // Check limit per this origin
   Data& data = mData[aGetDataSetIndex];
   uint64_t newOriginUsage = data.mOriginQuotaUsage + aDelta;
-  if (aDelta > 0 && newOriginUsage > DOMStorageManager::GetQuota()) {
+  if (aDelta > 0 && newOriginUsage > StorageManagerBase::GetQuota()) {
     return false;
   }
 
   // Now check eTLD+1 limit
   if (mUsage && !mUsage->CheckAndSetETLD1UsageDelta(aGetDataSetIndex, aDelta)) {
     return false;
   }
 
   // Update size in our data set
   data.mOriginQuotaUsage = newOriginUsage;
   return true;
 }
 
 void
-DOMStorageCache::Preload()
+StorageCache::Preload()
 {
   if (mLoaded || !mPersistent) {
     return;
   }
 
   if (!StartDatabase()) {
     mLoaded = true;
     mLoadResult = NS_ERROR_FAILURE;
@@ -243,87 +243,92 @@ DOMStorageCache::Preload()
 
   sDatabase->AsyncPreload(this);
 }
 
 namespace {
 
 // This class is passed to timer as a tick observer.  It refers the cache
 // and keeps it alive for a time.
-class DOMStorageCacheHolder : public nsITimerCallback
+class StorageCacheHolder : public nsITimerCallback
 {
-  virtual ~DOMStorageCacheHolder() {}
+  virtual ~StorageCacheHolder() {}
 
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD
   Notify(nsITimer* aTimer) override
   {
     mCache = nullptr;
     return NS_OK;
   }
 
-  RefPtr<DOMStorageCache> mCache;
+  RefPtr<StorageCache> mCache;
 
 public:
-  explicit DOMStorageCacheHolder(DOMStorageCache* aCache) : mCache(aCache) {}
+  explicit StorageCacheHolder(StorageCache* aCache) : mCache(aCache) {}
 };
 
-NS_IMPL_ISUPPORTS(DOMStorageCacheHolder, nsITimerCallback)
+NS_IMPL_ISUPPORTS(StorageCacheHolder, nsITimerCallback)
 
 } // namespace
 
 void
-DOMStorageCache::KeepAlive()
+StorageCache::KeepAlive()
 {
   // Missing reference back to the manager means the cache is not responsible
   // for its lifetime.  Used for keeping sessionStorage live forever.
   if (!mManager) {
     return;
   }
 
   if (!NS_IsMainThread()) {
     // Timer and the holder must be initialized on the main thread.
-    NS_DispatchToMainThread(NewRunnableMethod(this, &DOMStorageCache::KeepAlive));
+    NS_DispatchToMainThread(NewRunnableMethod(this, &StorageCache::KeepAlive));
     return;
   }
 
   nsCOMPtr<nsITimer> timer = do_CreateInstance("@mozilla.org/timer;1");
   if (!timer) {
     return;
   }
 
-  RefPtr<DOMStorageCacheHolder> holder = new DOMStorageCacheHolder(this);
+  RefPtr<StorageCacheHolder> holder = new StorageCacheHolder(this);
   timer->InitWithCallback(holder, DOM_STORAGE_CACHE_KEEP_ALIVE_TIME_MS,
                           nsITimer::TYPE_ONE_SHOT);
 
   mKeepAliveTimer.swap(timer);
 }
 
 namespace {
 
 // The AutoTimer provided by telemetry headers is only using static,
 // i.e. compile time known ID, but here we know the ID only at run time.
 // Hence a new class.
 class TelemetryAutoTimer
 {
 public:
   explicit TelemetryAutoTimer(Telemetry::ID aId)
-    : id(aId), start(TimeStamp::Now()) {}
+    : id(aId), start(TimeStamp::Now())
+  {}
+
   ~TelemetryAutoTimer()
-    { Telemetry::AccumulateDelta_impl<Telemetry::Millisecond>::compute(id, start); }
+  {
+    Telemetry::AccumulateDelta_impl<Telemetry::Millisecond>::compute(id, start);
+  }
+
 private:
   Telemetry::ID id;
   const TimeStamp start;
 };
 
 } // namespace
 
 void
-DOMStorageCache::WaitForPreload(Telemetry::ID aTelemetryID)
+StorageCache::WaitForPreload(Telemetry::ID aTelemetryID)
 {
   if (!mPersistent) {
     return;
   }
 
   bool loaded = mLoaded;
 
   // Telemetry of rates of pending preloads
@@ -349,31 +354,32 @@ DOMStorageCache::WaitForPreload(Telemetr
 
   // No need to check sDatabase for being non-null since preload is either
   // done before we've shut the DB down or when the DB could not start,
   // preload has not even be started.
   sDatabase->SyncPreload(this);
 }
 
 nsresult
-DOMStorageCache::GetLength(const DOMStorage* aStorage, uint32_t* aRetval)
+StorageCache::GetLength(const Storage* aStorage, uint32_t* aRetval)
 {
   if (Persist(aStorage)) {
     WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETLENGTH_BLOCKING_MS);
     if (NS_FAILED(mLoadResult)) {
       return mLoadResult;
     }
   }
 
   *aRetval = DataSet(aStorage).mKeys.Count();
   return NS_OK;
 }
 
 nsresult
-DOMStorageCache::GetKey(const DOMStorage* aStorage, uint32_t aIndex, nsAString& aRetval)
+StorageCache::GetKey(const Storage* aStorage, uint32_t aIndex,
+                     nsAString& aRetval)
 {
   // XXX: This does a linear search for the key at index, which would
   // suck if there's a large numer of indexes. Do we care? If so,
   // maybe we need to have a lazily populated key array here or
   // something?
   if (Persist(aStorage)) {
     WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETKEY_BLOCKING_MS);
     if (NS_FAILED(mLoadResult)) {
@@ -389,34 +395,34 @@ DOMStorageCache::GetKey(const DOMStorage
     }
     aIndex--;
   }
 
   return NS_OK;
 }
 
 void
-DOMStorageCache::GetKeys(const DOMStorage* aStorage, nsTArray<nsString>& aKeys)
+StorageCache::GetKeys(const Storage* aStorage, nsTArray<nsString>& aKeys)
 {
   if (Persist(aStorage)) {
     WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETALLKEYS_BLOCKING_MS);
   }
 
   if (NS_FAILED(mLoadResult)) {
     return;
   }
 
   for (auto iter = DataSet(aStorage).mKeys.Iter(); !iter.Done(); iter.Next()) {
     aKeys.AppendElement(iter.Key());
   }
 }
 
 nsresult
-DOMStorageCache::GetItem(const DOMStorage* aStorage, const nsAString& aKey,
-                         nsAString& aRetval)
+StorageCache::GetItem(const Storage* aStorage, const nsAString& aKey,
+                      nsAString& aRetval)
 {
   if (Persist(aStorage)) {
     WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETVALUE_BLOCKING_MS);
     if (NS_FAILED(mLoadResult)) {
       return mLoadResult;
     }
   }
 
@@ -427,18 +433,18 @@ DOMStorageCache::GetItem(const DOMStorag
   }
 
   aRetval = value;
 
   return NS_OK;
 }
 
 nsresult
-DOMStorageCache::SetItem(const DOMStorage* aStorage, const nsAString& aKey,
-                         const nsString& aValue, nsString& aOld)
+StorageCache::SetItem(const Storage* aStorage, const nsAString& aKey,
+                      const nsString& aValue, nsString& aOld)
 {
   // Size of the cache that will change after this action.
   int64_t delta = 0;
 
   if (Persist(aStorage)) {
     WaitForPreload(Telemetry::LOCALDOMSTORAGE_SETVALUE_BLOCKING_MS);
     if (NS_FAILED(mLoadResult)) {
       return mLoadResult;
@@ -479,18 +485,18 @@ DOMStorageCache::SetItem(const DOMStorag
 
     return sDatabase->AsyncUpdateItem(this, aKey, aValue);
   }
 
   return NS_OK;
 }
 
 nsresult
-DOMStorageCache::RemoveItem(const DOMStorage* aStorage, const nsAString& aKey,
-                            nsString& aOld)
+StorageCache::RemoveItem(const Storage* aStorage, const nsAString& aKey,
+                         nsString& aOld)
 {
   if (Persist(aStorage)) {
     WaitForPreload(Telemetry::LOCALDOMSTORAGE_REMOVEKEY_BLOCKING_MS);
     if (NS_FAILED(mLoadResult)) {
       return mLoadResult;
     }
   }
 
@@ -515,17 +521,17 @@ DOMStorageCache::RemoveItem(const DOMSto
 
     return sDatabase->AsyncRemoveItem(this, aKey);
   }
 
   return NS_OK;
 }
 
 nsresult
-DOMStorageCache::Clear(const DOMStorage* aStorage)
+StorageCache::Clear(const Storage* aStorage)
 {
   bool refresh = false;
   if (Persist(aStorage)) {
     // We need to preload all data (know the size) before we can proceeed
     // to correctly decrease cached usage number.
     // XXX as in case of unload, this is not technically needed now, but
     // after super-scope quota introduction we have to do this.  Get telemetry
     // right now.
@@ -555,17 +561,17 @@ DOMStorageCache::Clear(const DOMStorage*
 
     return sDatabase->AsyncClear(this);
   }
 
   return hadData ? NS_OK : NS_SUCCESS_DOM_NO_OPERATION;
 }
 
 void
-DOMStorageCache::CloneFrom(const DOMStorageCache* aThat)
+StorageCache::CloneFrom(const StorageCache* aThat)
 {
   // This will never be called on anything else than SessionStorage.
   // This means mData will never be touched on any other thread than
   // the main thread and it never went through the loading process.
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!mPersistent);
   MOZ_ASSERT(!(bool)aThat->mLoaded);
 
@@ -577,28 +583,29 @@ DOMStorageCache::CloneFrom(const DOMStor
   for (uint32_t i = 0; i < kDataSetCount; ++i) {
     for (auto it = aThat->mData[i].mKeys.ConstIter(); !it.Done(); it.Next()) {
       mData[i].mKeys.Put(it.Key(), it.UserData());
     }
     ProcessUsageDelta(i, aThat->mData[i].mOriginQuotaUsage);
   }
 }
 
-// Defined in DOMStorageManager.cpp
+// Defined in StorageManager.cpp
 extern bool
-PrincipalsEqual(nsIPrincipal* aObjectPrincipal, nsIPrincipal* aSubjectPrincipal);
+PrincipalsEqual(nsIPrincipal* aObjectPrincipal,
+                nsIPrincipal* aSubjectPrincipal);
 
 bool
-DOMStorageCache::CheckPrincipal(nsIPrincipal* aPrincipal) const
+StorageCache::CheckPrincipal(nsIPrincipal* aPrincipal) const
 {
   return PrincipalsEqual(mPrincipal, aPrincipal);
 }
 
 void
-DOMStorageCache::UnloadItems(uint32_t aUnloadFlags)
+StorageCache::UnloadItems(uint32_t aUnloadFlags)
 {
   if (aUnloadFlags & kUnloadDefault) {
     // Must wait for preload to pass correct usage to ProcessUsageDelta
     // XXX this is not technically needed right now since there is just
     // per-origin isolated quota handling, but when we introduce super-
     // -scope quotas, we have to do this.  Better to start getting
     // telemetry right now.
     WaitForPreload(Telemetry::LOCALDOMSTORAGE_UNLOAD_BLOCKING_MS);
@@ -624,28 +631,28 @@ DOMStorageCache::UnloadItems(uint32_t aU
 
     mData[kDefaultSet].mKeys.Clear();
     mLoaded = false; // This is only used in testing code
     Preload();
   }
 #endif
 }
 
-// DOMStorageCacheBridge
+// StorageCacheBridge
 
 uint32_t
-DOMStorageCache::LoadedCount()
+StorageCache::LoadedCount()
 {
   MonitorAutoLock monitor(mMonitor);
   Data& data = mData[kDefaultSet];
   return data.mKeys.Count();
 }
 
 bool
-DOMStorageCache::LoadItem(const nsAString& aKey, const nsString& aValue)
+StorageCache::LoadItem(const nsAString& aKey, const nsString& aValue)
 {
   MonitorAutoLock monitor(mMonitor);
   if (mLoaded) {
     return false;
   }
 
   Data& data = mData[kDefaultSet];
   if (data.mKeys.Get(aKey, nullptr)) {
@@ -653,39 +660,39 @@ DOMStorageCache::LoadItem(const nsAStrin
   }
 
   data.mKeys.Put(aKey, aValue);
   data.mOriginQuotaUsage += aKey.Length() + aValue.Length();
   return true;
 }
 
 void
-DOMStorageCache::LoadDone(nsresult aRv)
+StorageCache::LoadDone(nsresult aRv)
 {
   // Keep the preloaded cache alive for a time
   KeepAlive();
 
   MonitorAutoLock monitor(mMonitor);
   mLoadResult = aRv;
   mLoaded = true;
   monitor.Notify();
 }
 
 void
-DOMStorageCache::LoadWait()
+StorageCache::LoadWait()
 {
   MonitorAutoLock monitor(mMonitor);
   while (!mLoaded) {
     monitor.Wait();
   }
 }
 
-// DOMStorageUsage
+// StorageUsage
 
-DOMStorageUsage::DOMStorageUsage(const nsACString& aOriginScope)
+StorageUsage::StorageUsage(const nsACString& aOriginScope)
   : mOriginScope(aOriginScope)
 {
   mUsage[kDefaultSet] = mUsage[kPrivateSet] = mUsage[kSessionSet] = 0LL;
 }
 
 namespace {
 
 class LoadUsageRunnable : public Runnable
@@ -701,106 +708,107 @@ private:
   int64_t mDelta;
 
   NS_IMETHOD Run() override { *mTarget = mDelta; return NS_OK; }
 };
 
 } // namespace
 
 void
-DOMStorageUsage::LoadUsage(const int64_t aUsage)
+StorageUsage::LoadUsage(const int64_t aUsage)
 {
   // Using kDefaultSet index since it is the index for the persitent data
   // stored in the database we have just loaded usage for.
   if (!NS_IsMainThread()) {
     // In single process scenario we get this call from the DB thread
     RefPtr<LoadUsageRunnable> r =
       new LoadUsageRunnable(mUsage + kDefaultSet, aUsage);
     NS_DispatchToMainThread(r);
   } else {
     // On a child process we get this on the main thread already
     mUsage[kDefaultSet] += aUsage;
   }
 }
 
 bool
-DOMStorageUsage::CheckAndSetETLD1UsageDelta(uint32_t aDataSetIndex, const int64_t aDelta)
+StorageUsage::CheckAndSetETLD1UsageDelta(uint32_t aDataSetIndex,
+                                         const int64_t aDelta)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   int64_t newUsage = mUsage[aDataSetIndex] + aDelta;
-  if (aDelta > 0 && newUsage > DOMStorageManager::GetQuota()) {
+  if (aDelta > 0 && newUsage > StorageManagerBase::GetQuota()) {
     return false;
   }
 
   mUsage[aDataSetIndex] = newUsage;
   return true;
 }
 
 
 // static
-DOMStorageDBBridge*
-DOMStorageCache::StartDatabase()
+StorageDBBridge*
+StorageCache::StartDatabase()
 {
   if (sDatabase || sDatabaseDown) {
     // When sDatabaseDown is at true, sDatabase is null.
     // Checking sDatabaseDown flag here prevents reinitialization of
     // the database after shutdown.
     return sDatabase;
   }
 
   if (XRE_IsParentProcess()) {
-    nsAutoPtr<DOMStorageDBThread> db(new DOMStorageDBThread());
+    nsAutoPtr<StorageDBThread> db(new StorageDBThread());
 
     nsresult rv = db->Init();
     if (NS_FAILED(rv)) {
       return nullptr;
     }
 
     sDatabase = db.forget();
   } else {
     // Use DOMLocalStorageManager::Ensure in case we're called from
     // DOMSessionStorageManager's initializer and we haven't yet initialized the
     // local storage manager.
-    RefPtr<DOMStorageDBChild> db = new DOMStorageDBChild(
+    RefPtr<StorageDBChild> db = new StorageDBChild(
         DOMLocalStorageManager::Ensure());
 
     nsresult rv = db->Init();
     if (NS_FAILED(rv)) {
       return nullptr;
     }
 
     db.forget(&sDatabase);
   }
 
   return sDatabase;
 }
 
 // static
-DOMStorageDBBridge*
-DOMStorageCache::GetDatabase()
+StorageDBBridge*
+StorageCache::GetDatabase()
 {
   return sDatabase;
 }
 
 // static
 nsresult
-DOMStorageCache::StopDatabase()
+StorageCache::StopDatabase()
 {
   if (!sDatabase) {
     return NS_OK;
   }
 
   sDatabaseDown = true;
 
   nsresult rv = sDatabase->Shutdown();
   if (XRE_IsParentProcess()) {
     delete sDatabase;
   } else {
-    DOMStorageDBChild* child = static_cast<DOMStorageDBChild*>(sDatabase);
+    StorageDBChild* child = static_cast<StorageDBChild*>(sDatabase);
     NS_RELEASE(child);
   }
 
   sDatabase = nullptr;
   return rv;
 }
 
 } // namespace dom

rename from dom/storage/DOMStorageCache.h
rename to dom/storage/StorageCache.h
--- a/dom/storage/DOMStorageCache.h
+++ b/dom/storage/StorageCache.h
@@ -1,49 +1,49 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
-#ifndef nsDOMStorageCache_h___
-#define nsDOMStorageCache_h___
+#ifndef mozilla_dom_StorageCache_h
+#define mozilla_dom_StorageCache_h
 
 #include "nsIPrincipal.h"
 #include "nsITimer.h"
 
 #include "nsString.h"
 #include "nsDataHashtable.h"
 #include "nsHashKeys.h"
 #include "mozilla/Monitor.h"
 #include "mozilla/Telemetry.h"
 #include "mozilla/Atomics.h"
 
 namespace mozilla {
 namespace dom {
 
-class DOMStorage;
-class DOMStorageUsage;
-class DOMStorageManager;
-class DOMStorageDBBridge;
+class Storage;
+class StorageUsage;
+class StorageManagerBase;
+class StorageDBBridge;
 
 // Interface class on which only the database or IPC may call.
 // Used to populate the cache with DB data.
-class DOMStorageCacheBridge
+class StorageCacheBridge
 {
 public:
   NS_IMETHOD_(MozExternalRefCountType) AddRef(void);
   NS_IMETHOD_(void) Release(void);
 
-  // The origin of the cache, result is concatenation of OriginNoSuffix() and OriginSuffix(),
-  // see below.
+  // The origin of the cache, result is concatenation of OriginNoSuffix() and
+  // OriginSuffix(), see below.
   virtual const nsCString Origin() const = 0;
 
-  // The origin attributes suffix alone, this is usually passed as an |aOriginSuffix|
-  // argument to various methods
+  // The origin attributes suffix alone, this is usually passed as an
+  // |aOriginSuffix| argument to various methods
   virtual const nsCString& OriginSuffix() const = 0;
 
   // The origin in the database usage format (reversed) and without the suffix
   virtual const nsCString& OriginNoSuffix() const = 0;
 
   // Whether the cache is already fully loaded
   virtual bool Loaded() = 0;
 
@@ -58,77 +58,81 @@ public:
   // to this cache
   virtual void LoadDone(nsresult aRv) = 0;
 
   // Use to synchronously wait until the cache gets fully loaded with data,
   // this method exits after LoadDone has been called
   virtual void LoadWait() = 0;
 
 protected:
-  virtual ~DOMStorageCacheBridge() {}
+  virtual ~StorageCacheBridge() {}
 
   ThreadSafeAutoRefCnt mRefCnt;
   NS_DECL_OWNINGTHREAD
 };
 
 // Implementation of scope cache that is responsible for preloading data
 // for persistent storage (localStorage) and hold data for non-private,
 // private and session-only cookie modes.  It is also responsible for
 // persisting data changes using the database, works as a write-back cache.
-class DOMStorageCache : public DOMStorageCacheBridge
+class StorageCache : public StorageCacheBridge
 {
 public:
   NS_IMETHOD_(void) Release(void);
 
   // Note: We pass aOriginNoSuffix through the ctor here, because 
-  // DOMStorageCacheHashKey's ctor is creating this class and 
+  // StorageCacheHashKey's ctor is creating this class and 
   // accepts reversed-origin-no-suffix as an argument - the hashing key.
-  explicit DOMStorageCache(const nsACString* aOriginNoSuffix);
+  explicit StorageCache(const nsACString* aOriginNoSuffix);
 
 protected:
-  virtual ~DOMStorageCache();
+  virtual ~StorageCache();
 
 public:
-  void Init(DOMStorageManager* aManager, bool aPersistent, nsIPrincipal* aPrincipal,
-            const nsACString& aQuotaOriginScope);
+  void Init(StorageManagerBase* aManager, bool aPersistent,
+            nsIPrincipal* aPrincipal, const nsACString& aQuotaOriginScope);
 
   // Copies all data from the other storage.
-  void CloneFrom(const DOMStorageCache* aThat);
+  void CloneFrom(const StorageCache* aThat);
 
   // Starts async preload of this cache if it persistent and not loaded.
   void Preload();
 
-  // Keeps the cache alive (i.e. present in the manager's hash table) for a time.
+  // Keeps the cache alive (i.e. present in the manager's hash table) for a
+  // time.
   void KeepAlive();
 
   // The set of methods that are invoked by DOM storage web API.
-  // We are passing the DOMStorage object just to let the cache
+  // We are passing the Storage object just to let the cache
   // read properties like mPrincipal and mSessionOnly.
   // Get* methods return error when load from the database has failed.
-  nsresult GetLength(const DOMStorage* aStorage, uint32_t* aRetval);
-  nsresult GetKey(const DOMStorage* aStorage, uint32_t index, nsAString& aRetval);
-  nsresult GetItem(const DOMStorage* aStorage, const nsAString& aKey, nsAString& aRetval);
-  nsresult SetItem(const DOMStorage* aStorage, const nsAString& aKey, const nsString& aValue, nsString& aOld);
-  nsresult RemoveItem(const DOMStorage* aStorage, const nsAString& aKey, nsString& aOld);
-  nsresult Clear(const DOMStorage* aStorage);
+  nsresult GetLength(const Storage* aStorage, uint32_t* aRetval);
+  nsresult GetKey(const Storage* aStorage, uint32_t index, nsAString& aRetval);
+  nsresult GetItem(const Storage* aStorage, const nsAString& aKey,
+                   nsAString& aRetval);
+  nsresult SetItem(const Storage* aStorage, const nsAString& aKey,
+                   const nsString& aValue, nsString& aOld);
+  nsresult RemoveItem(const Storage* aStorage, const nsAString& aKey,
+                      nsString& aOld);
+  nsresult Clear(const Storage* aStorage);
 
-  void GetKeys(const DOMStorage* aStorage, nsTArray<nsString>& aKeys);
+  void GetKeys(const Storage* aStorage, nsTArray<nsString>& aKeys);
 
   // Whether the principal equals principal the cache was created for
   bool CheckPrincipal(nsIPrincipal* aPrincipal) const;
   nsIPrincipal* Principal() const { return mPrincipal; }
 
   // Starts the database engine thread or the IPC bridge
-  static DOMStorageDBBridge* StartDatabase();
-  static DOMStorageDBBridge* GetDatabase();
+  static StorageDBBridge* StartDatabase();
+  static StorageDBBridge* GetDatabase();
 
   // Stops the thread and flushes all uncommited data
   static nsresult StopDatabase();
 
-  // DOMStorageCacheBridge
+  // StorageCacheBridge
 
   virtual const nsCString Origin() const;
   virtual const nsCString& OriginNoSuffix() const { return mOriginNoSuffix; }
   virtual const nsCString& OriginSuffix() const { return mOriginSuffix; }
   virtual bool Loaded() { return mLoaded; }
   virtual uint32_t LoadedCount();
   virtual bool LoadItem(const nsAString& aKey, const nsString& aValue);
   virtual void LoadDone(nsresult aRv);
@@ -147,17 +151,17 @@ public:
 
 public:
   // Number of data sets we keep: default, private, session
   static const uint32_t kDataSetCount = 3;
 
 private:
   // API to clear the cache data, this is invoked by chrome operations
   // like cookie deletion.
-  friend class DOMStorageManager;
+  friend class StorageManagerBase;
 
   static const uint32_t kUnloadDefault = 1 << 0;
   static const uint32_t kUnloadPrivate = 1 << 1;
   static const uint32_t kUnloadSession = 1 << 2;
   static const uint32_t kUnloadComplete =
     kUnloadDefault | kUnloadPrivate | kUnloadSession;
 
 #ifdef DOM_STORAGE_TESTS
@@ -166,44 +170,44 @@ private:
 
   void UnloadItems(uint32_t aUnloadFlags);
 
 private:
   // Synchronously blocks until the cache is fully loaded from the database
   void WaitForPreload(mozilla::Telemetry::ID aTelemetryID);
 
   // Helper to get one of the 3 data sets (regular, private, session)
-  Data& DataSet(const DOMStorage* aStorage);
+  Data& DataSet(const Storage* aStorage);
 
   // Whether the storage change is about to persist
-  bool Persist(const DOMStorage* aStorage) const;
+  bool Persist(const Storage* aStorage) const;
 
   // Changes the quota usage on the given data set if it fits the quota.
   // If not, then false is returned and no change to the set must be done.
   bool ProcessUsageDelta(uint32_t aGetDataSetIndex, const int64_t aDelta);
-  bool ProcessUsageDelta(const DOMStorage* aStorage, const int64_t aDelta);
+  bool ProcessUsageDelta(const Storage* aStorage, const int64_t aDelta);
 
 private:
   // When a cache is reponsible for its life time (in case of localStorage data
-  // cache) we need to refer our manager since removal of the cache from the hash
-  // table is handled in the destructor by call to the manager.
-  // Cache could potentially overlive the manager, hence the hard ref.
-  RefPtr<DOMStorageManager> mManager;
+  // cache) we need to refer our manager since removal of the cache from the
+  // hash table is handled in the destructor by call to the manager.  Cache
+  // could potentially overlive the manager, hence the hard ref.
+  RefPtr<StorageManagerBase> mManager;
 
   // Reference to the usage counter object we check on for eTLD+1 quota limit.
   // Obtained from the manager during initialization (Init method).
-  RefPtr<DOMStorageUsage> mUsage;
+  RefPtr<StorageUsage> mUsage;
 
   // Timer that holds this cache alive for a while after it has been preloaded.
   nsCOMPtr<nsITimer> mKeepAliveTimer;
 
-  // Principal the cache has been initially created for, this is used only
-  // for sessionStorage access checks since sessionStorage objects are strictly
-  // scoped by a principal.  localStorage objects on the other hand are scoped by
-  // origin only.
+  // Principal the cache has been initially created for, this is used only for
+  // sessionStorage access checks since sessionStorage objects are strictly
+  // scoped by a principal. localStorage objects on the other hand are scoped
+  // by origin only.
   nsCOMPtr<nsIPrincipal> mPrincipal;
 
   // The origin this cache belongs to in the "DB format", i.e. reversed
   nsCString mOriginNoSuffix;
 
   // The origin attributes suffix
   nsCString mOriginSuffix;
 
@@ -236,53 +240,54 @@ private:
   bool mPersistent : 1;
 
   // - False when the session-only data set was never used.
   // - True after access to session-only data has been made for the first time.
   // We also fill session-only data set with the default one at that moment.
   // Drops back to false when session-only data are cleared from chrome.
   bool mSessionOnlyDataSetActive : 1;
 
-  // Whether we have already captured state of the cache preload on our first access.
+  // Whether we have already captured state of the cache preload on our first
+  // access.
   bool mPreloadTelemetryRecorded : 1;
 
-  // DOMStorageDBThread on the parent or single process,
-  // DOMStorageDBChild on the child process.
-  static DOMStorageDBBridge* sDatabase;
+  // StorageDBThread on the parent or single process,
+  // StorageDBChild on the child process.
+  static StorageDBBridge* sDatabase;
 
   // False until we shut the database down.
   static bool sDatabaseDown;
 };
 
-// DOMStorageUsage
+// StorageUsage
 // Infrastructure to manage and check eTLD+1 quota
-class DOMStorageUsageBridge
+class StorageUsageBridge
 {
 public:
-  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DOMStorageUsageBridge)
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(StorageUsageBridge)
 
   virtual const nsCString& OriginScope() = 0;
   virtual void LoadUsage(const int64_t aUsage) = 0;
 
 protected:
   // Protected destructor, to discourage deletion outside of Release():
-  virtual ~DOMStorageUsageBridge() {}
+  virtual ~StorageUsageBridge() {}
 };
 
-class DOMStorageUsage : public DOMStorageUsageBridge
+class StorageUsage : public StorageUsageBridge
 {
 public:
-  explicit DOMStorageUsage(const nsACString& aOriginScope);
+  explicit StorageUsage(const nsACString& aOriginScope);
 
   bool CheckAndSetETLD1UsageDelta(uint32_t aDataSetIndex, int64_t aUsageDelta);
 
 private:
   virtual const nsCString& OriginScope() { return mOriginScope; }
   virtual void LoadUsage(const int64_t aUsage);
 
   nsCString mOriginScope;
-  int64_t mUsage[DOMStorageCache::kDataSetCount];
+  int64_t mUsage[StorageCache::kDataSetCount];
 };
 
 } // namespace dom
 } // namespace mozilla
 
-#endif
+#endif // mozilla_dom_StorageCache_h

rename from dom/storage/DOMStorageDBThread.cpp
rename to dom/storage/StorageDBThread.cpp
--- a/dom/storage/DOMStorageDBThread.cpp
+++ b/dom/storage/StorageDBThread.cpp
@@ -1,18 +1,18 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
-#include "DOMStorageDBThread.h"
-#include "DOMStorageDBUpdater.h"
-#include "DOMStorageCache.h"
-#include "DOMStorageManager.h"
+#include "StorageDBThread.h"
+#include "StorageDBUpdater.h"
+#include "StorageCache.h"
+#include "StorageManager.h"
 
 #include "nsIEffectiveTLDService.h"
 #include "nsDirectoryServiceUtils.h"
 #include "nsAppDirectoryServiceDefs.h"
 #include "nsThreadUtils.h"
 #include "nsProxyRelease.h"
 #include "mozStorageCID.h"
 #include "mozStorageHelper.h"
@@ -39,32 +39,33 @@
 // Current version of the database schema
 #define CURRENT_SCHEMA_VERSION 1
 
 namespace mozilla {
 namespace dom {
 
 namespace { // anon
 
-// This is only a compatibility code for schema version 0.  Returns the 'scope' key
-// in the schema version 0 format for the scope column.
+// This is only a compatibility code for schema version 0.  Returns the 'scope'
+// key in the schema version 0 format for the scope column.
 nsCString
-Scheme0Scope(DOMStorageCacheBridge* aCache)
+Scheme0Scope(StorageCacheBridge* aCache)
 {
   nsCString result;
 
   nsCString suffix = aCache->OriginSuffix();
 
   PrincipalOriginAttributes oa;
   if (!suffix.IsEmpty()) {
     DebugOnly<bool> success = oa.PopulateFromSuffix(suffix);
     MOZ_ASSERT(success);
   }
 
-  if (oa.mAppId != nsIScriptSecurityManager::NO_APP_ID || oa.mInIsolatedMozBrowser) {
+  if (oa.mAppId != nsIScriptSecurityManager::NO_APP_ID ||
+      oa.mInIsolatedMozBrowser) {
     result.AppendInt(oa.mAppId);
     result.Append(':');
     result.Append(oa.mInIsolatedMozBrowser ? 't' : 'f');
     result.Append(':');
   }
 
   // If there is more than just appid and/or inbrowser stored in origin
   // attributes, put it to the schema 0 scope as well.  We must do that
@@ -97,38 +98,38 @@ Scheme0Scope(DOMStorageCacheBridge* aCac
   result.Append(aCache->OriginNoSuffix());
 
   return result;
 }
 
 } // anon
 
 
-DOMStorageDBBridge::DOMStorageDBBridge()
+StorageDBBridge::StorageDBBridge()
 {
 }
 
 
-DOMStorageDBThread::DOMStorageDBThread()
-: mThread(nullptr)
-, mThreadObserver(new ThreadObserver())
-, mStopIOThread(false)
-, mWALModeEnabled(false)
-, mDBReady(false)
-, mStatus(NS_OK)
-, mWorkerStatements(mWorkerConnection)
-, mReaderStatements(mReaderConnection)
-, mDirtyEpoch(0)
-, mFlushImmediately(false)
-, mPriorityCounter(0)
+StorageDBThread::StorageDBThread()
+  : mThread(nullptr)
+  , mThreadObserver(new ThreadObserver())
+  , mStopIOThread(false)
+  , mWALModeEnabled(false)
+  , mDBReady(false)
+  , mStatus(NS_OK)
+  , mWorkerStatements(mWorkerConnection)
+  , mReaderStatements(mReaderConnection)
+  , mDirtyEpoch(0)
+  , mFlushImmediately(false)
+  , mPriorityCounter(0)
 {
 }
 
 nsresult
-DOMStorageDBThread::Init()
+StorageDBThread::Init()
 {
   nsresult rv;
 
   // Need to determine location on the main thread, since
   // NS_GetSpecialDirectory access the atom table that can
   // be accessed only on the main thread.
   rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
                               getter_AddRefs(mDatabaseFile));
@@ -141,28 +142,28 @@ DOMStorageDBThread::Init()
   nsCOMPtr<mozIStorageService> service =
     do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Need to keep the lock to avoid setting mThread later then
   // the thread body executes.
   MonitorAutoLock monitor(mThreadObserver->GetMonitor());
 
-  mThread = PR_CreateThread(PR_USER_THREAD, &DOMStorageDBThread::ThreadFunc, this,
-                            PR_PRIORITY_LOW, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD,
-                            262144);
+  mThread = PR_CreateThread(PR_USER_THREAD, &StorageDBThread::ThreadFunc, this,
+                            PR_PRIORITY_LOW, PR_GLOBAL_THREAD,
+                            PR_JOINABLE_THREAD, 262144);
   if (!mThread) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   return NS_OK;
 }
 
 nsresult
-DOMStorageDBThread::Shutdown()
+StorageDBThread::Shutdown()
 {
   if (!mThread) {
     return NS_ERROR_NOT_INITIALIZED;
   }
 
   Telemetry::AutoTimer<Telemetry::LOCALDOMSTORAGE_SHUTDOWN_DATABASE_MS> timer;
 
   {
@@ -176,31 +177,31 @@ DOMStorageDBThread::Shutdown()
 
   PR_JoinThread(mThread);
   mThread = nullptr;
 
   return mStatus;
 }
 
 void
-DOMStorageDBThread::SyncPreload(DOMStorageCacheBridge* aCache, bool aForceSync)
+StorageDBThread::SyncPreload(StorageCacheBridge* aCache, bool aForceSync)
 {
   PROFILER_LABEL_FUNC(js::ProfileEntry::Category::STORAGE);
   if (!aForceSync && aCache->LoadedCount()) {
     // Preload already started for this cache, just wait for it to finish.
     // LoadWait will exit after LoadDone on the cache has been called.
     SetHigherPriority();
     aCache->LoadWait();
     SetDefaultPriority();
     return;
   }
 
   // Bypass sync load when an update is pending in the queue to write, we would
-  // get incosistent data in the cache.  Also don't allow sync main-thread preload
-  // when DB open and init is still pending on the background thread.
+  // get incosistent data in the cache.  Also don't allow sync main-thread
+  // preload when DB open and init is still pending on the background thread.
   if (mDBReady && mWALModeEnabled) {
     bool pendingTasks;
     {
       MonitorAutoLock monitor(mThreadObserver->GetMonitor());
       pendingTasks = mPendingTasks.IsOriginUpdatePending(aCache->OriginSuffix(), aCache->OriginNoSuffix()) ||
                      mPendingTasks.IsOriginClearPending(aCache->OriginSuffix(), aCache->OriginNoSuffix());
     }
 
@@ -219,46 +220,46 @@ DOMStorageDBThread::SyncPreload(DOMStora
 
   // LoadWait exits after LoadDone of the cache has been called.
   if (NS_SUCCEEDED(rv)) {
     aCache->LoadWait();
   }
 }
 
 void
-DOMStorageDBThread::AsyncFlush()
+StorageDBThread::AsyncFlush()
 {
   MonitorAutoLock monitor(mThreadObserver->GetMonitor());
   mFlushImmediately = true;
   monitor.Notify();
 }
 
 bool
-DOMStorageDBThread::ShouldPreloadOrigin(const nsACString& aOrigin)
+StorageDBThread::ShouldPreloadOrigin(const nsACString& aOrigin)
 {
   MonitorAutoLock monitor(mThreadObserver->GetMonitor());
   return mOriginsHavingData.Contains(aOrigin);
 }
 
 void
-DOMStorageDBThread::GetOriginsHavingData(InfallibleTArray<nsCString>* aOrigins)
+StorageDBThread::GetOriginsHavingData(InfallibleTArray<nsCString>* aOrigins)
 {
   MonitorAutoLock monitor(mThreadObserver->GetMonitor());
   for (auto iter = mOriginsHavingData.Iter(); !iter.Done(); iter.Next()) {
     aOrigins->AppendElement(iter.Get()->GetKey());
   }
 }
 
 nsresult
-DOMStorageDBThread::InsertDBOp(DOMStorageDBThread::DBOperation* aOperation)
+StorageDBThread::InsertDBOp(StorageDBThread::DBOperation* aOperation)
 {
   MonitorAutoLock monitor(mThreadObserver->GetMonitor());
 
   // Sentinel to don't forget to delete the operation when we exit early.
-  nsAutoPtr<DOMStorageDBThread::DBOperation> opScope(aOperation);
+  nsAutoPtr<StorageDBThread::DBOperation> opScope(aOperation);
 
   if (NS_FAILED(mStatus)) {
     MonitorAutoUnlock unlock(mThreadObserver->GetMonitor());
     aOperation->Finalize(mStatus);
     return mStatus;
   }
 
   if (mStopIOThread) {
@@ -269,25 +270,26 @@ DOMStorageDBThread::InsertDBOp(DOMStorag
 
   switch (aOperation->Type()) {
   case DBOperation::opPreload:
   case DBOperation::opPreloadUrgent:
     if (mPendingTasks.IsOriginUpdatePending(aOperation->OriginSuffix(), aOperation->OriginNoSuffix())) {
       // If there is a pending update operation for the scope first do the flush
       // before we preload the cache.  This may happen in an extremely rare case
       // when a child process throws away its cache before flush on the parent
-      // has finished.  If we would preloaded the cache as a priority operation 
-      // before the pending flush, we would have got an inconsistent cache content.
+      // has finished.  If we would preloaded the cache as a priority operation
+      // before the pending flush, we would have got an inconsistent cache
+      // content.
       mFlushImmediately = true;
     } else if (mPendingTasks.IsOriginClearPending(aOperation->OriginSuffix(), aOperation->OriginNoSuffix())) {
       // The scope is scheduled to be cleared, so just quickly load as empty.
       // We need to do this to prevent load of the DB data before the scope has
       // actually been cleared from the database.  Preloads are processed
-      // immediately before update and clear operations on the database that
-      // are flushed periodically in batches.
+      // immediately before update and clear operations on the database that are
+      // flushed periodically in batches.
       MonitorAutoUnlock unlock(mThreadObserver->GetMonitor());
       aOperation->Finalize(NS_OK);
       return NS_OK;
     }
     MOZ_FALLTHROUGH;
 
   case DBOperation::opGetUsage:
     if (aOperation->Type() == DBOperation::opPreloadUrgent) {
@@ -315,43 +317,43 @@ DOMStorageDBThread::InsertDBOp(DOMStorag
     ScheduleFlush();
     break;
   }
 
   return NS_OK;
 }
 
 void
-DOMStorageDBThread::SetHigherPriority()
+StorageDBThread::SetHigherPriority()
 {
   ++mPriorityCounter;
   PR_SetThreadPriority(mThread, PR_PRIORITY_URGENT);
 }
 
 void
-DOMStorageDBThread::SetDefaultPriority()
+StorageDBThread::SetDefaultPriority()
 {
   if (--mPriorityCounter <= 0) {
     PR_SetThreadPriority(mThread, PR_PRIORITY_LOW);
   }
 }
 
 void
-DOMStorageDBThread::ThreadFunc(void* aArg)
+StorageDBThread::ThreadFunc(void* aArg)
 {
   PR_SetCurrentThreadName("localStorage DB");
   mozilla::IOInterposer::RegisterCurrentThread();
 
-  DOMStorageDBThread* thread = static_cast<DOMStorageDBThread*>(aArg);
+  StorageDBThread* thread = static_cast<StorageDBThread*>(aArg);
   thread->ThreadFunc();
   mozilla::IOInterposer::UnregisterCurrentThread();
 }
 
 void
-DOMStorageDBThread::ThreadFunc()
+StorageDBThread::ThreadFunc()
 {
   nsresult rv = InitDatabase();
 
   MonitorAutoLock lockMonitor(mThreadObserver->GetMonitor());
 
   if (NS_FAILED(rv)) {
     mStatus = rv;
     mStopIOThread = true;
@@ -412,47 +414,47 @@ DOMStorageDBThread::ThreadFunc()
   mStatus = ShutdownDatabase();
 
   if (threadInternal) {
     threadInternal->SetObserver(nullptr);
   }
 }
 
 
-NS_IMPL_ISUPPORTS(DOMStorageDBThread::ThreadObserver, nsIThreadObserver)
+NS_IMPL_ISUPPORTS(StorageDBThread::ThreadObserver, nsIThreadObserver)
 
 NS_IMETHODIMP
-DOMStorageDBThread::ThreadObserver::OnDispatchedEvent(nsIThreadInternal *thread)
+StorageDBThread::ThreadObserver::OnDispatchedEvent(nsIThreadInternal* aThread)
 {
   MonitorAutoLock lock(mMonitor);
   mHasPendingEvents = true;
   lock.Notify();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-DOMStorageDBThread::ThreadObserver::OnProcessNextEvent(nsIThreadInternal *thread,
-                                       bool mayWait)
+StorageDBThread::ThreadObserver::OnProcessNextEvent(nsIThreadInternal* aThread,
+                                                    bool mayWait)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
-DOMStorageDBThread::ThreadObserver::AfterProcessNextEvent(nsIThreadInternal *thread,
-                                          bool eventWasProcessed)
+StorageDBThread::ThreadObserver::AfterProcessNextEvent(nsIThreadInternal* aThread,
+                                                       bool eventWasProcessed)
 {
   return NS_OK;
 }
 
 
 extern void
 ReverseString(const nsCSubstring& aSource, nsCSubstring& aResult);
 
 nsresult
-DOMStorageDBThread::OpenDatabaseConnection()
+StorageDBThread::OpenDatabaseConnection()
 {
   nsresult rv;
 
   MOZ_ASSERT(!NS_IsMainThread());
 
   nsCOMPtr<mozIStorageService> service
       = do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
@@ -465,44 +467,44 @@ DOMStorageDBThread::OpenDatabaseConnecti
     rv = service->OpenUnsharedDatabase(mDatabaseFile, getter_AddRefs(mWorkerConnection));
   }
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
 
 nsresult
-DOMStorageDBThread::OpenAndUpdateDatabase()
+StorageDBThread::OpenAndUpdateDatabase()
 {
   nsresult rv;
 
   // Here we are on the worker thread. This opens the worker connection.
   MOZ_ASSERT(!NS_IsMainThread());
 
   rv = OpenDatabaseConnection();
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = TryJournalMode();
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
 
 nsresult
-DOMStorageDBThread::InitDatabase()
+StorageDBThread::InitDatabase()
 {
   nsresult rv;
 
   // Here we are on the worker thread. This opens the worker connection.
   MOZ_ASSERT(!NS_IsMainThread());
 
   rv = OpenAndUpdateDatabase();
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = DOMStorageDBUpdater::Update(mWorkerConnection);
+  rv = StorageDBUpdater::Update(mWorkerConnection);
   if (NS_FAILED(rv)) {
     // Update has failed, rather throw the database away and try
     // opening and setting it up again.
     rv = mWorkerConnection->Close();
     mWorkerConnection = nullptr;
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = mDatabaseFile->Remove(false);
@@ -512,24 +514,24 @@ DOMStorageDBThread::InitDatabase()
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   // Create a read-only clone
   (void)mWorkerConnection->Clone(true, getter_AddRefs(mReaderConnection));
   NS_ENSURE_TRUE(mReaderConnection, NS_ERROR_FAILURE);
 
   // Database open and all initiation operation are done.  Switching this flag
-  // to true allow main thread to read directly from the database.
-  // If we would allow this sooner, we would have opened a window where main thread
-  // read might operate on a totaly broken and incosistent database.
+  // to true allow main thread to read directly from the database.  If we would
+  // allow this sooner, we would have opened a window where main thread read
+  // might operate on a totally broken and incosistent database.
   mDBReady = true;
 
   // List scopes having any stored data
   nsCOMPtr<mozIStorageStatement> stmt;
-  // Note: result of this select must match DOMStorageManager::CreateOrigin()
+  // Note: result of this select must match StorageManager::CreateOrigin()
   rv = mWorkerConnection->CreateStatement(NS_LITERAL_CSTRING(
         "SELECT DISTINCT originAttributes || ':' || originKey FROM webappsstore2"),
         getter_AddRefs(stmt));
   NS_ENSURE_SUCCESS(rv, rv);
   mozStorageStatementScoper scope(stmt);
 
   bool exists;
   while (NS_SUCCEEDED(rv = stmt->ExecuteStep(&exists)) && exists) {
@@ -540,17 +542,17 @@ DOMStorageDBThread::InitDatabase()
     MonitorAutoLock monitor(mThreadObserver->GetMonitor());
     mOriginsHavingData.PutEntry(foundOrigin);
   }
 
   return NS_OK;
 }
 
 nsresult
-DOMStorageDBThread::SetJournalMode(bool aIsWal)
+StorageDBThread::SetJournalMode(bool aIsWal)
 {
   nsresult rv;
 
   nsAutoCString stmtString(
     MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA journal_mode = ");
   if (aIsWal) {
     stmtString.AppendLiteral("wal");
   } else {
@@ -576,17 +578,17 @@ DOMStorageDBThread::SetJournalMode(bool 
       (!aIsWal && !journalMode.EqualsLiteral("truncate"))) {
     return NS_ERROR_FAILURE;
   }
 
   return NS_OK;
 }
 
 nsresult
-DOMStorageDBThread::TryJournalMode()
+StorageDBThread::TryJournalMode()
 {
   nsresult rv;
 
   rv = SetJournalMode(true);
   if (NS_FAILED(rv)) {
     mWALModeEnabled = false;
 
     rv = SetJournalMode(false);
@@ -597,17 +599,17 @@ DOMStorageDBThread::TryJournalMode()
     rv = ConfigureWALBehavior();
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   return NS_OK;
 }
 
 nsresult
-DOMStorageDBThread::ConfigureWALBehavior()
+StorageDBThread::ConfigureWALBehavior()
 {
   // Get the DB's page size
   nsCOMPtr<mozIStorageStatement> stmt;
   nsresult rv = mWorkerConnection->CreateStatement(NS_LITERAL_CSTRING(
     MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA page_size"
   ), getter_AddRefs(stmt));
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -625,26 +627,27 @@ DOMStorageDBThread::ConfigureWALBehavior
   nsAutoCString thresholdPragma("PRAGMA wal_autocheckpoint = ");
   thresholdPragma.AppendInt(thresholdInPages);
   rv = mWorkerConnection->ExecuteSimpleSQL(thresholdPragma);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Set the maximum WAL log size to reduce footprint on mobile (large empty
   // WAL files will be truncated)
   nsAutoCString journalSizePragma("PRAGMA journal_size_limit = ");
-  // bug 600307: mak recommends setting this to 3 times the auto-checkpoint threshold
+  // bug 600307: mak recommends setting this to 3 times the auto-checkpoint
+  // threshold
   journalSizePragma.AppendInt(MAX_WAL_SIZE_BYTES * 3);
   rv = mWorkerConnection->ExecuteSimpleSQL(journalSizePragma);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
 
 nsresult
-DOMStorageDBThread::ShutdownDatabase()
+StorageDBThread::ShutdownDatabase()
 {
   // Has to be called on the worker thread.
   MOZ_ASSERT(!NS_IsMainThread());
 
   nsresult rv = mStatus;
 
   mDBReady = false;
 
@@ -663,38 +666,39 @@ DOMStorageDBThread::ShutdownDatabase()
     rv = mWorkerConnection->Close();
     mWorkerConnection = nullptr;
   }
 
   return rv;
 }
 
 void
-DOMStorageDBThread::ScheduleFlush()
+StorageDBThread::ScheduleFlush()
 {
   if (mDirtyEpoch) {
     return; // Already scheduled
   }
 
-  mDirtyEpoch = PR_IntervalNow() | 1; // Must be non-zero to indicate we are scheduled
+  // Must be non-zero to indicate we are scheduled
+  mDirtyEpoch = PR_IntervalNow() | 1;
 
   // Wake the monitor from indefinite sleep...
   (mThreadObserver->GetMonitor()).Notify();
 }
 
 void
-DOMStorageDBThread::UnscheduleFlush()
+StorageDBThread::UnscheduleFlush()
 {
   // We are just about to do the flush, drop flags
   mFlushImmediately = false;
   mDirtyEpoch = 0;
 }
 
 PRIntervalTime
-DOMStorageDBThread::TimeUntilFlush()
+StorageDBThread::TimeUntilFlush()
 {
   if (mFlushImmediately) {
     return 0; // Do it now regardless the timeout.
   }
 
   static_assert(PR_INTERVAL_NO_TIMEOUT != 0,
       "PR_INTERVAL_NO_TIMEOUT must be non-zero");
 
@@ -709,22 +713,22 @@ DOMStorageDBThread::TimeUntilFlush()
   if (age > kMaxAge) {
     return 0; // It is time.
   }
 
   return kMaxAge - age; // Time left, this is used to sleep the monitor
 }
 
 void
-DOMStorageDBThread::NotifyFlushCompletion()
+StorageDBThread::NotifyFlushCompletion()
 {
 #ifdef DOM_STORAGE_TESTS
   if (!NS_IsMainThread()) {
-    RefPtr<nsRunnableMethod<DOMStorageDBThread, void, false> > event =
-      NewNonOwningRunnableMethod(this, &DOMStorageDBThread::NotifyFlushCompletion);
+    RefPtr<nsRunnableMethod<StorageDBThread, void, false> > event =
+      NewNonOwningRunnableMethod(this, &StorageDBThread::NotifyFlushCompletion);
     NS_DispatchToMainThread(event);
     return;
   }
 
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
   if (obs) {
     obs->NotifyObservers(nullptr, "domstorage-test-flushed", nullptr);
   }
@@ -772,123 +776,123 @@ OriginAttrsPatternMatchSQLFunction::OnFu
   NS_ENSURE_SUCCESS(rv, rv);
 
   outVar.forget(aResult);
   return NS_OK;
 }
 
 } // namespace
 
-// DOMStorageDBThread::DBOperation
+// StorageDBThread::DBOperation
 
-DOMStorageDBThread::DBOperation::DBOperation(const OperationType aType,
-                                             DOMStorageCacheBridge* aCache,
-                                             const nsAString& aKey,
-                                             const nsAString& aValue)
+StorageDBThread::DBOperation::DBOperation(const OperationType aType,
+                                          StorageCacheBridge* aCache,
+                                          const nsAString& aKey,
+                                          const nsAString& aValue)
 : mType(aType)
 , mCache(aCache)
 , mKey(aKey)
 , mValue(aValue)
 {
   MOZ_ASSERT(mType == opPreload ||
              mType == opPreloadUrgent ||
              mType == opAddItem ||
              mType == opUpdateItem ||
              mType == opRemoveItem ||
              mType == opClear ||
              mType == opClearAll);
-  MOZ_COUNT_CTOR(DOMStorageDBThread::DBOperation);
+  MOZ_COUNT_CTOR(StorageDBThread::DBOperation);
 }
 
-DOMStorageDBThread::DBOperation::DBOperation(const OperationType aType,
-                                             DOMStorageUsageBridge* aUsage)
+StorageDBThread::DBOperation::DBOperation(const OperationType aType,
+                                          StorageUsageBridge* aUsage)
 : mType(aType)
 , mUsage(aUsage)
 {
   MOZ_ASSERT(mType == opGetUsage);
-  MOZ_COUNT_CTOR(DOMStorageDBThread::DBOperation);
+  MOZ_COUNT_CTOR(StorageDBThread::DBOperation);
 }
 
-DOMStorageDBThread::DBOperation::DBOperation(const OperationType aType,
-                                             const nsACString& aOriginNoSuffix)
+StorageDBThread::DBOperation::DBOperation(const OperationType aType,
+                                          const nsACString& aOriginNoSuffix)
 : mType(aType)
 , mCache(nullptr)
 , mOrigin(aOriginNoSuffix)
 {
   MOZ_ASSERT(mType == opClearMatchingOrigin);
-  MOZ_COUNT_CTOR(DOMStorageDBThread::DBOperation);
+  MOZ_COUNT_CTOR(StorageDBThread::DBOperation);
 }
 
-DOMStorageDBThread::DBOperation::DBOperation(const OperationType aType,
-                                             const OriginAttributesPattern& aOriginNoSuffix)
+StorageDBThread::DBOperation::DBOperation(const OperationType aType,
+                                          const OriginAttributesPattern& aOriginNoSuffix)
 : mType(aType)
 , mCache(nullptr)
 , mOriginPattern(aOriginNoSuffix)
 {
   MOZ_ASSERT(mType == opClearMatchingOriginAttributes);
-  MOZ_COUNT_CTOR(DOMStorageDBThread::DBOperation);
+  MOZ_COUNT_CTOR(StorageDBThread::DBOperation);
 }
 
-DOMStorageDBThread::DBOperation::~DBOperation()
+StorageDBThread::DBOperation::~DBOperation()
 {
-  MOZ_COUNT_DTOR(DOMStorageDBThread::DBOperation);
+  MOZ_COUNT_DTOR(StorageDBThread::DBOperation);
 }
 
 const nsCString
-DOMStorageDBThread::DBOperation::OriginNoSuffix() const
+StorageDBThread::DBOperation::OriginNoSuffix() const
 {
   if (mCache) {
     return mCache->OriginNoSuffix();
   }
 
   return EmptyCString();
 }
 
 const nsCString
-DOMStorageDBThread::DBOperation::OriginSuffix() const
+StorageDBThread::DBOperation::OriginSuffix() const
 {
   if (mCache) {
     return mCache->OriginSuffix();
   }
 
   return EmptyCString();
 }
 
 const nsCString
-DOMStorageDBThread::DBOperation::Origin() const
+StorageDBThread::DBOperation::Origin() const
 {
   if (mCache) {
     return mCache->Origin();
   }
 
   return mOrigin;
 }
 
 const nsCString
-DOMStorageDBThread::DBOperation::Target() const
+StorageDBThread::DBOperation::Target() const
 {
   switch (mType) {
     case opAddItem:
     case opUpdateItem:
     case opRemoveItem:
       return Origin() + NS_LITERAL_CSTRING("|") + NS_ConvertUTF16toUTF8(mKey);
 
     default:
       return Origin();
   }
 }
 
 void
-DOMStorageDBThread::DBOperation::PerformAndFinalize(DOMStorageDBThread* aThread)
+StorageDBThread::DBOperation::PerformAndFinalize(StorageDBThread* aThread)
 {
   Finalize(Perform(aThread));
 }
 
 nsresult
-DOMStorageDBThread::DBOperation::Perform(DOMStorageDBThread* aThread)
+StorageDBThread::DBOperation::Perform(StorageDBThread* aThread)
 {
   nsresult rv;
 
   switch (mType) {
   case opPreload:
   case opPreloadUrgent:
   {
     // Already loaded?
@@ -1095,27 +1099,28 @@ DOMStorageDBThread::DBOperation::Perform
 
     rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("scope"),
                                     mOrigin + NS_LITERAL_CSTRING("*"));
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = stmt->Execute();
     NS_ENSURE_SUCCESS(rv, rv);
 
-    // No need to selectively clear mOriginsHavingData here.  That hashtable only
-    // prevents preload for scopes with no data.  Leaving a false record in it has
-    // a negligible effect on performance.
+    // No need to selectively clear mOriginsHavingData here.  That hashtable
+    // only prevents preload for scopes with no data.  Leaving a false record in
+    // it has a negligible effect on performance.
     break;
   }
 
   case opClearMatchingOriginAttributes:
   {
     MOZ_ASSERT(!NS_IsMainThread());
 
-    // Register the ORIGIN_ATTRS_PATTERN_MATCH function, initialized with the pattern
+    // Register the ORIGIN_ATTRS_PATTERN_MATCH function, initialized with the
+    // pattern
     nsCOMPtr<mozIStorageFunction> patternMatchFunction(
       new OriginAttrsPatternMatchSQLFunction(mOriginPattern));
 
     rv = aThread->mWorkerConnection->CreateFunction(
       NS_LITERAL_CSTRING("ORIGIN_ATTRS_PATTERN_MATCH"), 1, patternMatchFunction);
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsCOMPtr<mozIStorageStatement> stmt = aThread->mWorkerStatements.GetCachedStatement(
@@ -1131,40 +1136,40 @@ DOMStorageDBThread::DBOperation::Perform
     }
 
     // Always remove the function
     aThread->mWorkerConnection->RemoveFunction(
       NS_LITERAL_CSTRING("ORIGIN_ATTRS_PATTERN_MATCH"));
 
     NS_ENSURE_SUCCESS(rv, rv);
 
-    // No need to selectively clear mOriginsHavingData here.  That hashtable only
-    // prevents preload for scopes with no data.  Leaving a false record in it has
-    // a negligible effect on performance.
+    // No need to selectively clear mOriginsHavingData here.  That hashtable
+    // only prevents preload for scopes with no data.  Leaving a false record in
+    // it has a negligible effect on performance.
     break;
   }
 
   default:
     NS_ERROR("Unknown task type");
     break;
   }
 
   return NS_OK;
 }
 
 void
-DOMStorageDBThread::DBOperation::Finalize(nsresult aRv)
+StorageDBThread::DBOperation::Finalize(nsresult aRv)
 {
   switch (mType) {
   case opPreloadUrgent:
   case opPreload:
     if (NS_FAILED(aRv)) {
       // When we are here, something failed when loading from the database.
-      // Notify that the storage is loaded to prevent deadlock of the main thread,
-      // even though it is actually empty or incomplete.
+      // Notify that the storage is loaded to prevent deadlock of the main
+      // thread, even though it is actually empty or incomplete.
       NS_WARNING("Failed to preload localStorage");
     }
 
     mCache->LoadDone(aRv);
     break;
 
   case opGetUsage:
     if (NS_FAILED(aRv)) {
@@ -1178,87 +1183,91 @@ DOMStorageDBThread::DBOperation::Finaliz
       NS_WARNING("localStorage update/clear operation failed,"
                  " data may not persist or clean up");
     }
 
     break;
   }
 }
 
-// DOMStorageDBThread::PendingOperations
+// StorageDBThread::PendingOperations
 
-DOMStorageDBThread::PendingOperations::PendingOperations()
+StorageDBThread::PendingOperations::PendingOperations()
 : mFlushFailureCount(0)
 {
 }
 
 bool
-DOMStorageDBThread::PendingOperations::HasTasks() const
+StorageDBThread::PendingOperations::HasTasks() const
 {
   return !!mUpdates.Count() || !!mClears.Count();
 }
 
 namespace {
 
-bool OriginPatternMatches(const nsACString& aOriginSuffix, const OriginAttributesPattern& aPattern)
+bool OriginPatternMatches(const nsACString& aOriginSuffix,
+                          const OriginAttributesPattern& aPattern)
 {
   PrincipalOriginAttributes oa;
   DebugOnly<bool> rv = oa.PopulateFromSuffix(aOriginSuffix);
   MOZ_ASSERT(rv);
   return aPattern.Matches(oa);
 }
 
 } // namespace
 
 bool
-DOMStorageDBThread::PendingOperations::CheckForCoalesceOpportunity(DBOperation* aNewOp,
-                                                                   DBOperation::OperationType aPendingType,
-                                                                   DBOperation::OperationType aNewType)
+StorageDBThread::PendingOperations::CheckForCoalesceOpportunity(DBOperation* aNewOp,
+                                                                DBOperation::OperationType aPendingType,
+                                                                DBOperation::OperationType aNewType)
 {
   if (aNewOp->Type() != aNewType) {
     return false;
   }
 
-  DOMStorageDBThread::DBOperation* pendingTask;
+  StorageDBThread::DBOperation* pendingTask;
   if (!mUpdates.Get(aNewOp->Target(), &pendingTask)) {
     return false;
   }
 
   if (pendingTask->Type() != aPendingType) {
     return false;
   }
 
   return true;
 }
 
 void
-DOMStorageDBThread::PendingOperations::Add(DOMStorageDBThread::DBOperation* aOperation)
+StorageDBThread::PendingOperations::Add(StorageDBThread::DBOperation* aOperation)
 {
   // Optimize: when a key to remove has never been written to disk
   // just bypass this operation.  A key is new when an operation scheduled
   // to write it to the database is of type opAddItem.
-  if (CheckForCoalesceOpportunity(aOperation, DBOperation::opAddItem, DBOperation::opRemoveItem)) {
+  if (CheckForCoalesceOpportunity(aOperation, DBOperation::opAddItem,
+                                  DBOperation::opRemoveItem)) {
     mUpdates.Remove(aOperation->Target());
     delete aOperation;
     return;
   }
 
   // Optimize: when changing a key that is new and has never been
   // written to disk, keep type of the operation to store it at opAddItem.
   // This allows optimization to just forget adding a new key when
   // it is removed from the storage before flush.
-  if (CheckForCoalesceOpportunity(aOperation, DBOperation::opAddItem, DBOperation::opUpdateItem)) {
+  if (CheckForCoalesceOpportunity(aOperation, DBOperation::opAddItem,
+                                  DBOperation::opUpdateItem)) {
     aOperation->mType = DBOperation::opAddItem;
   }
 
   // Optimize: to prevent lose of remove operation on a key when doing
   // remove/set/remove on a previously existing key we have to change
   // opAddItem to opUpdateItem on the new operation when there is opRemoveItem
   // pending for the key.
-  if (CheckForCoalesceOpportunity(aOperation, DBOperation::opRemoveItem, DBOperation::opAddItem)) {
+  if (CheckForCoalesceOpportunity(aOperation, DBOperation::opRemoveItem,
+                                  DBOperation::opAddItem)) {
     aOperation->mType = DBOperation::opUpdateItem;
   }
 
   switch (aOperation->Type())
   {
   // Operations on single keys
 
   case DBOperation::opAddItem:
@@ -1268,20 +1277,20 @@ DOMStorageDBThread::PendingOperations::A
     mUpdates.Put(aOperation->Target(), aOperation);
     break;
 
   // Clear operations
 
   case DBOperation::opClear:
   case DBOperation::opClearMatchingOrigin:
   case DBOperation::opClearMatchingOriginAttributes:
-    // Drop all update (insert/remove) operations for equivavelent or matching scope.
-    // We do this as an optimization as well as a must based on the logic,
-    // if we would not delete the update tasks, changes would have been stored
-    // to the database after clear operations have been executed.
+    // Drop all update (insert/remove) operations for equivavelent or matching
+    // scope.  We do this as an optimization as well as a must based on the
+    // logic, if we would not delete the update tasks, changes would have been
+    // stored to the database after clear operations have been executed.
     for (auto iter = mUpdates.Iter(); !iter.Done(); iter.Next()) {
       nsAutoPtr<DBOperation>& pendingTask = iter.Data();
 
       if (aOperation->Type() == DBOperation::opClear &&
           (pendingTask->OriginNoSuffix() != aOperation->OriginNoSuffix() ||
            pendingTask->OriginSuffix() != aOperation->OriginSuffix())) {
         continue;
       }
@@ -1311,17 +1320,17 @@ DOMStorageDBThread::PendingOperations::A
 
   default:
     MOZ_ASSERT(false);
     break;
   }
 }
 
 bool
-DOMStorageDBThread::PendingOperations::Prepare()
+StorageDBThread::PendingOperations::Prepare()
 {
   // Called under the lock
 
   // First collect clear operations and then updates, we can
   // do this since whenever a clear operation for a scope is
   // scheduled, we drop all updates matching that scope. So,
   // all scope-related update operations we have here now were
   // scheduled after the clear operations.
@@ -1334,42 +1343,42 @@ DOMStorageDBThread::PendingOperations::P
     mExecList.AppendElement(iter.Data().forget());
   }
   mUpdates.Clear();
 
   return !!mExecList.Length();
 }
 
 nsresult
-DOMStorageDBThread::PendingOperations::Execute(DOMStorageDBThread* aThread)
+StorageDBThread::PendingOperations::Execute(StorageDBThread* aThread)
 {
   // Called outside the lock
 
   mozStorageTransaction transaction(aThread->mWorkerConnection, false);
 
   nsresult rv;
 
   for (uint32_t i = 0; i < mExecList.Length(); ++i) {
-    DOMStorageDBThread::DBOperation* task = mExecList[i];
+    StorageDBThread::DBOperation* task = mExecList[i];
     rv = task->Perform(aThread);
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
 
   rv = transaction.Commit();
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   return NS_OK;
 }
 
 bool
-DOMStorageDBThread::PendingOperations::Finalize(nsresult aRv)
+StorageDBThread::PendingOperations::Finalize(nsresult aRv)
 {
   // Called under the lock
 
   // The list is kept on a failure to retry it
   if (NS_FAILED(aRv)) {
     // XXX Followup: we may try to reopen the database and flush these
     // pending tasks, however testing showed that even though I/O is actually
     // broken some amount of operations is left in sqlite+system buffers and
@@ -1386,47 +1395,48 @@ DOMStorageDBThread::PendingOperations::F
   mFlushFailureCount = 0;
   mExecList.Clear();
   return true;
 }
 
 namespace {
 
 bool
-FindPendingClearForOrigin(const nsACString& aOriginSuffix, const nsACString& aOriginNoSuffix,
-                         DOMStorageDBThread::DBOperation* aPendingOperation)
+FindPendingClearForOrigin(const nsACString& aOriginSuffix,
+                          const nsACString& aOriginNoSuffix,
+                          StorageDBThread::DBOperation* aPendingOperation)
 {
-  if (aPendingOperation->Type() == DOMStorageDBThread::DBOperation::opClearAll) {
+  if (aPendingOperation->Type() == StorageDBThread::DBOperation::opClearAll) {
     return true;
   }
 
-  if (aPendingOperation->Type() == DOMStorageDBThread::DBOperation::opClear &&
+  if (aPendingOperation->Type() == StorageDBThread::DBOperation::opClear &&
       aOriginNoSuffix == aPendingOperation->OriginNoSuffix() &&
       aOriginSuffix == aPendingOperation->OriginSuffix()) {
     return true;
   }
 
-  if (aPendingOperation->Type() == DOMStorageDBThread::DBOperation::opClearMatchingOrigin &&
+  if (aPendingOperation->Type() == StorageDBThread::DBOperation::opClearMatchingOrigin &&
       StringBeginsWith(aOriginNoSuffix, aPendingOperation->Origin())) {
     return true;
   }
 
-  if (aPendingOperation->Type() == DOMStorageDBThread::DBOperation::opClearMatchingOriginAttributes &&
+  if (aPendingOperation->Type() == StorageDBThread::DBOperation::opClearMatchingOriginAttributes &&
       OriginPatternMatches(aOriginSuffix, aPendingOperation->OriginPattern())) {
     return true;
   }
 
   return false;
 }
 
 } // namespace
 
 bool
-DOMStorageDBThread::PendingOperations::IsOriginClearPending(const nsACString& aOriginSuffix,
-                                                            const nsACString& aOriginNoSuffix) const
+StorageDBThread::PendingOperations::IsOriginClearPending(const nsACString& aOriginSuffix,
+                                                         const nsACString& aOriginNoSuffix) const
 {
   // Called under the lock
 
   for (auto iter = mClears.ConstIter(); !iter.Done(); iter.Next()) {
     if (FindPendingClearForOrigin(aOriginSuffix, aOriginNoSuffix, iter.UserData())) {
       return true;
     }
   }
@@ -1438,35 +1448,36 @@ DOMStorageDBThread::PendingOperations::I
   }
 
   return false;
 }
 
 namespace {
 
 bool
-FindPendingUpdateForOrigin(const nsACString& aOriginSuffix, const nsACString& aOriginNoSuffix,
-                           DOMStorageDBThread::DBOperation* aPendingOperation)
+FindPendingUpdateForOrigin(const nsACString& aOriginSuffix,
+                           const nsACString& aOriginNoSuffix,
+                           StorageDBThread::DBOperation* aPendingOperation)
 {
-  if ((aPendingOperation->Type() == DOMStorageDBThread::DBOperation::opAddItem ||
-       aPendingOperation->Type() == DOMStorageDBThread::DBOperation::opUpdateItem ||
-       aPendingOperation->Type() == DOMStorageDBThread::DBOperation::opRemoveItem) &&
+  if ((aPendingOperation->Type() == StorageDBThread::DBOperation::opAddItem ||
+       aPendingOperation->Type() == StorageDBThread::DBOperation::opUpdateItem ||
+       aPendingOperation->Type() == StorageDBThread::DBOperation::opRemoveItem) &&
        aOriginNoSuffix == aPendingOperation->OriginNoSuffix() &&
        aOriginSuffix == aPendingOperation->OriginSuffix()) {
     return true;
   }
 
   return false;
 }
 
 } // namespace
 
 bool
-DOMStorageDBThread::PendingOperations::IsOriginUpdatePending(const nsACString& aOriginSuffix,
-                                                             const nsACString& aOriginNoSuffix) const
+StorageDBThread::PendingOperations::IsOriginUpdatePending(const nsACString& aOriginSuffix,
+                                                          const nsACString& aOriginNoSuffix) const
 {
   // Called under the lock
 
   for (auto iter = mUpdates.ConstIter(); !iter.Done(); iter.Next()) {
     if (FindPendingUpdateForOrigin(aOriginSuffix, aOriginNoSuffix, iter.UserData())) {
       return true;
     }
   }