--- a/accessible/base/nsAccCache.h
+++ b/accessible/base/nsAccCache.h
@@ -20,26 +20,9 @@ UnbindCacheEntriesFromDocument(
   for (auto iter = aCache.Iter(); !iter.Done(); iter.Next()) {
     T* accessible = iter.Data();
     MOZ_ASSERT(accessible && !accessible->IsDefunct());
     accessible->Document()->UnbindFromDocument(accessible);
     iter.Remove();
   }
 }
 
-/**
- * Clear the cache and shutdown the accessibles.
- */
-template <class T>
-static void
-ClearCache(nsRefPtrHashtable<nsPtrHashKey<const void>, T>& aCache)
-{
-  for (auto iter = aCache.Iter(); !iter.Done(); iter.Next()) {
-    T* accessible = iter.Data();
-    MOZ_ASSERT(accessible);
-    if (accessible && !accessible->IsDefunct()) {
-      accessible->Shutdown();
-    }
-    iter.Remove();
-  }
-}
-
 #endif

--- a/accessible/generic/DocAccessible.cpp
+++ b/accessible/generic/DocAccessible.cpp
@@ -478,17 +478,27 @@ DocAccessible::Shutdown()
     mVirtualCursor = nullptr;
   }
 
   mPresShell->SetDocAccessible(nullptr);
   mPresShell = nullptr;  // Avoid reentrancy
 
   mDependentIDsHash.Clear();
   mNodeToAccessibleMap.Clear();
-  ClearCache(mAccessibleCache);
+
+  for (auto iter = mAccessibleCache.Iter(); !iter.Done(); iter.Next()) {
+    Accessible* accessible = iter.Data();
+    MOZ_ASSERT(accessible);
+    if (accessible && !accessible->IsDefunct()) {
+      // Unlink parent to avoid its cleaning overhead in shutdown.
+      accessible->mParent = nullptr;
+      accessible->Shutdown();
+    }
+    iter.Remove();
+  }
 
   HyperTextAccessibleWrap::Shutdown();
 
   GetAccService()->NotifyOfDocumentShutdown(this, kungFuDeathGripDoc);
 }
 
 nsIFrame*
 DocAccessible::GetFrame() const

--- a/browser/base/content/browser-feeds.js
+++ b/browser/base/content/browser-feeds.js
@@ -1,18 +1,143 @@
 /* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
  * 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/. */
 
+XPCOMUtils.defineLazyModuleGetter(this, "DeferredTask",
+                                  "resource://gre/modules/DeferredTask.jsm");
+
+const TYPE_MAYBE_FEED = "application/vnd.mozilla.maybe.feed";
+const TYPE_MAYBE_AUDIO_FEED = "application/vnd.mozilla.maybe.audio.feed";
+const TYPE_MAYBE_VIDEO_FEED = "application/vnd.mozilla.maybe.video.feed";
+
+const PREF_SHOW_FIRST_RUN_UI = "browser.feeds.showFirstRunUI";
+
+const PREF_SELECTED_APP = "browser.feeds.handlers.application";
+const PREF_SELECTED_WEB = "browser.feeds.handlers.webservice";
+const PREF_SELECTED_ACTION = "browser.feeds.handler";
+const PREF_SELECTED_READER = "browser.feeds.handler.default";
+
+const PREF_VIDEO_SELECTED_APP = "browser.videoFeeds.handlers.application";
+const PREF_VIDEO_SELECTED_WEB = "browser.videoFeeds.handlers.webservice";
+const PREF_VIDEO_SELECTED_ACTION = "browser.videoFeeds.handler";
+const PREF_VIDEO_SELECTED_READER = "browser.videoFeeds.handler.default";
+
+const PREF_AUDIO_SELECTED_APP = "browser.audioFeeds.handlers.application";
+const PREF_AUDIO_SELECTED_WEB = "browser.audioFeeds.handlers.webservice";
+const PREF_AUDIO_SELECTED_ACTION = "browser.audioFeeds.handler";
+const PREF_AUDIO_SELECTED_READER = "browser.audioFeeds.handler.default";
+
+const PREF_UPDATE_DELAY = 2000;
+
+const SETTABLE_PREFS = new Set([
+  PREF_VIDEO_SELECTED_ACTION,
+  PREF_AUDIO_SELECTED_ACTION,
+  PREF_SELECTED_ACTION,
+  PREF_VIDEO_SELECTED_READER,
+  PREF_AUDIO_SELECTED_READER,
+  PREF_SELECTED_READER,
+  PREF_VIDEO_SELECTED_WEB,
+  PREF_AUDIO_SELECTED_WEB,
+  PREF_SELECTED_WEB
+]);
+
+const EXECUTABLE_PREFS = new Set([
+  PREF_SELECTED_APP,
+  PREF_VIDEO_SELECTED_APP,
+  PREF_AUDIO_SELECTED_APP
+]);
+
+const VALID_ACTIONS = new Set(["ask", "reader", "bookmarks"]);
+const VALID_READERS = new Set(["web", "client", "default", "bookmarks"]);
+
+XPCOMUtils.defineLazyPreferenceGetter(this, "SHOULD_LOG",
+                                      "feeds.log", false);
+
+function LOG(str) {
+  if (SHOULD_LOG)
+    dump("*** Feeds: " + str + "\n");
+}
+
+function getPrefActionForType(t) {
+  switch (t) {
+    case Ci.nsIFeed.TYPE_VIDEO:
+      return PREF_VIDEO_SELECTED_ACTION;
+
+    case Ci.nsIFeed.TYPE_AUDIO:
+      return PREF_AUDIO_SELECTED_ACTION;
+
+    default:
+      return PREF_SELECTED_ACTION;
+  }
+}
+
+function getPrefReaderForType(t) {
+  switch (t) {
+    case Ci.nsIFeed.TYPE_VIDEO:
+      return PREF_VIDEO_SELECTED_READER;
+
+    case Ci.nsIFeed.TYPE_AUDIO:
+      return PREF_AUDIO_SELECTED_READER;
+
+    default:
+      return PREF_SELECTED_READER;
+  }
+}
+
+function getPrefWebForType(t) {
+  switch (t) {
+    case Ci.nsIFeed.TYPE_VIDEO:
+      return PREF_VIDEO_SELECTED_WEB;
+
+    case Ci.nsIFeed.TYPE_AUDIO:
+      return PREF_AUDIO_SELECTED_WEB;
+
+    default:
+      return PREF_SELECTED_WEB;
+  }
+}
+
+function getPrefAppForType(t) {
+  switch (t) {
+    case Ci.nsIFeed.TYPE_VIDEO:
+      return PREF_VIDEO_SELECTED_APP;
+
+    case Ci.nsIFeed.TYPE_AUDIO:
+      return PREF_AUDIO_SELECTED_APP;
+
+    default:
+      return PREF_SELECTED_APP;
+  }
+}
+
+/**
+ * Maps a feed type to a maybe-feed mimetype.
+ */
+function getMimeTypeForFeedType(aFeedType) {
+  switch (aFeedType) {
+    case Ci.nsIFeed.TYPE_VIDEO:
+      return TYPE_MAYBE_VIDEO_FEED;
+
+    case Ci.nsIFeed.TYPE_AUDIO:
+      return TYPE_MAYBE_AUDIO_FEED;
+
+    default:
+      return TYPE_MAYBE_FEED;
+  }
+}
+
 /**
  * The Feed Handler object manages discovery of RSS/ATOM feeds in web pages
  * and shows UI when they are discovered.
  */
 var FeedHandler = {
+  _prefChangeCallback: null,
+
   /** Called when the user clicks on the Subscribe to This Page... menu item,
    * or when the user clicks the feed button when the page contains multiple
    * feeds.
    * Builds a menu of unique feeds associated with the page, and if there
    * is only one, shows the feed inline in the browser window.
    * @param   container
    *          The feed list container (menupopup or subview) to be populated.
    * @param   isSubview
@@ -190,17 +315,18 @@ var FeedHandler = {
           } catch (e) {}
         }
         break;
     }
 
     return file.leafName;
   },
 
-  chooseClientApp(aTitle, aPrefName, aBrowser) {
+  _chooseClientApp(aTitle, aTypeName, aBrowser) {
+    const prefName = getPrefAppForType(aTypeName);
     let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
 
     fp.init(window, aTitle, Ci.nsIFilePicker.modeOpen);
     fp.appendFilters(Ci.nsIFilePicker.filterApps);
 
     fp.open((aResult) => {
       if (aResult == Ci.nsIFilePicker.returnOK) {
         let selectedApp = fp.file;
@@ -217,17 +343,17 @@ var FeedHandler = {
               appName = AppConstants.MOZ_MACBUNDLE_NAME;
               break;
             default:
               appName = AppConstants.MOZ_APP_NAME + "-bin";
               break;
           }
 
           if (fp.file.leafName != appName) {
-            Services.prefs.setComplexValue(aPrefName, Ci.nsILocalFile, selectedApp);
+            Services.prefs.setComplexValue(prefName, Ci.nsILocalFile, selectedApp);
             aBrowser.messageManager.sendAsyncMessage("FeedWriter:SetApplicationLauncherMenuItem",
                                                     { name: this._getFileDisplayName(selectedApp),
                                                       type: "SelectedAppMenuItem" });
           }
         }
       }
     });
 
@@ -272,76 +398,246 @@ var FeedHandler = {
       // nsIProcess instance
       let p = Cc["@mozilla.org/process/util;1"]
                 .createInstance(Ci.nsIProcess);
       p.init(clientApp);
       p.run(false, [aSpec], 1);
     }
   },
 
+  // nsISupports
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver,
+                                         Ci.nsISupportsWeakReference]),
+
+
   init() {
     window.messageManager.addMessageListener("FeedWriter:ChooseClientApp", this);
-    window.messageManager.addMessageListener("FeedWriter:RequestClientAppName", this);
-    window.messageManager.addMessageListener("FeedWriter:SetFeedCharPref", this);
-    window.messageManager.addMessageListener("FeedWriter:SetFeedComplexString", this);
+    window.messageManager.addMessageListener("FeedWriter:GetSubscriptionUI", this);
+    window.messageManager.addMessageListener("FeedWriter:SetFeedPrefsAndSubscribe", this);
     window.messageManager.addMessageListener("FeedWriter:ShownFirstRun", this);
 
     Services.ppmm.addMessageListener("FeedConverter:ExecuteClientApp", this);
+
+    const prefs = Services.prefs;
+    prefs.addObserver(PREF_SELECTED_ACTION, this, true);
+    prefs.addObserver(PREF_SELECTED_READER, this, true);
+    prefs.addObserver(PREF_SELECTED_WEB, this, true);
+    prefs.addObserver(PREF_VIDEO_SELECTED_ACTION, this, true);
+    prefs.addObserver(PREF_VIDEO_SELECTED_READER, this, true);
+    prefs.addObserver(PREF_VIDEO_SELECTED_WEB, this, true);
+    prefs.addObserver(PREF_AUDIO_SELECTED_ACTION, this, true);
+    prefs.addObserver(PREF_AUDIO_SELECTED_READER, this, true);
+    prefs.addObserver(PREF_AUDIO_SELECTED_WEB, this, true);
   },
 
   uninit() {
     Services.ppmm.removeMessageListener("FeedConverter:ExecuteClientApp", this);
+
+    this._prefChangeCallback = null;
+  },
+
+  // nsIObserver
+  observe(subject, topic, data) {
+    if (topic == "nsPref:changed") {
+      LOG(`Pref changed ${data}`)
+      if (this._prefChangeCallback) {
+        this._prefChangeCallback.disarm();
+      }
+      // Multiple prefs are set at the same time, debounce to reduce noise
+      // This can happen in one feed and we want to message all feed pages
+      this._prefChangeCallback = new DeferredTask(() => {
+        this._prefChanged(data);
+      }, PREF_UPDATE_DELAY);
+      this._prefChangeCallback.arm();
+    }
+  },
+
+  _prefChanged(prefName) {
+    // Don't observe for PREF_*SELECTED_APP as user likely just picked one
+    // That is also handled by SetApplicationLauncherMenuItem call
+    // Rather than the others which happen on subscription
+    switch (prefName) {
+      case PREF_SELECTED_READER:
+      case PREF_SELECTED_WEB:
+      case PREF_VIDEO_SELECTED_READER:
+      case PREF_VIDEO_SELECTED_WEB:
+      case PREF_AUDIO_SELECTED_READER:
+      case PREF_AUDIO_SELECTED_WEB:
+      case PREF_SELECTED_ACTION:
+      case PREF_VIDEO_SELECTED_ACTION:
+      case PREF_AUDIO_SELECTED_ACTION:
+        const response = {
+         default: this._getReaderForType(Ci.nsIFeed.TYPE_FEED),
+         [Ci.nsIFeed.TYPE_AUDIO]: this._getReaderForType(Ci.nsIFeed.TYPE_AUDIO),
+         [Ci.nsIFeed.TYPE_VIDEO]: this._getReaderForType(Ci.nsIFeed.TYPE_VIDEO)
+        };
+        Services.mm.broadcastAsyncMessage("FeedWriter:PreferenceUpdated",
+                                          response);
+        break;
+    }
+  },
+
+  _initSubscriptionUIResponse(feedType) {
+    const wccr = Cc["@mozilla.org/embeddor.implemented/web-content-handler-registrar;1"].
+               getService(Ci.nsIWebContentConverterService);
+    const handlersRaw = wccr.getContentHandlers(getMimeTypeForFeedType(feedType));
+    const handlers = [];
+    for (let handler of handlersRaw) {
+      LOG(`Handler found: ${handler}`);
+      handlers.push({
+        name: handler.name,
+        uri: handler.uri
+      });
+    }
+    let showFirstRunUI = true;
+    // eslint-disable-next-line mozilla/use-default-preference-values
+    try {
+      showFirstRunUI = Services.prefs.getBoolPref(PREF_SHOW_FIRST_RUN_UI);
+    } catch (ex) { }
+    const response = { handlers, showFirstRunUI };
+    let selectedClientApp;
+    const feedTypePref = getPrefAppForType(feedType);
+    try {
+      selectedClientApp = Services.prefs.getComplexValue(feedTypePref, Ci.nsILocalFile);
+    } catch (ex) {
+      // Just do nothing, then we won't bother populating
+    }
+
+    let defaultClientApp = null;
+    try {
+      // This can sometimes not exist
+      defaultClientApp = Cc["@mozilla.org/browser/shell-service;1"]
+                           .getService(Ci.nsIShellService)
+                           .defaultFeedReader;
+    } catch (ex) {
+      // Just do nothing, then we don't bother populating
+    }
+
+    if (selectedClientApp && selectedClientApp.exists()) {
+      if (defaultClientApp && selectedClientApp.path != defaultClientApp.path) {
+        // Only set the default menu item if it differs from the selected one
+        response.defaultMenuItem = this._getFileDisplayName(defaultClientApp);
+      }
+      response.selectedMenuItem = this._getFileDisplayName(selectedClientApp);
+    }
+    response.reader = this._getReaderForType(feedType);
+    return response;
+  },
+
+  _setPref(aPrefName, aPrefValue, aIsComplex = false) {
+    LOG(`FeedWriter._setPref ${aPrefName}`);
+    // Ensure we have a pref that is settable
+    if (aPrefName && SETTABLE_PREFS.has(aPrefName)) {
+      if (aIsComplex) {
+        Services.prefs.setStringPref(aPrefName, aPrefValue);
+      } else {
+        Services.prefs.setCharPref(aPrefName, aPrefValue);
+      }
+    } else {
+      LOG(`FeedWriter._setPref ${aPrefName} not allowed`);
+    }
+  },
+
+  _getReaderForType(feedType) {
+    let prefs = Services.prefs;
+    let handler = "bookmarks";
+    let url;
+    // eslint-disable-next-line mozilla/use-default-preference-values
+    try {
+      handler = prefs.getCharPref(getPrefReaderForType(feedType));
+    } catch (ex) { }
+
+    if (handler === "web") {
+      try {
+        url = prefs.getStringPref(getPrefWebForType(feedType));
+      } catch (ex) {
+        LOG("FeedWriter._setSelectedHandler: invalid or no handler in prefs");
+        url = null;
+      }
+    }
+    const alwaysUse = this._getAlwaysUseState(feedType);
+    const action = prefs.getCharPref(getPrefActionForType(feedType));
+    return { handler, url, alwaysUse, action };
+  },
+
+  _getAlwaysUseState(feedType) {
+    try {
+      return Services.prefs.getCharPref(getPrefActionForType(feedType)) != "ask";
+    } catch (ex) { }
+    return false;
   },
 
   receiveMessage(msg) {
+    let handler;
     switch (msg.name) {
-      case "FeedWriter:ChooseClientApp":
-        this.chooseClientApp(msg.data.title, msg.data.prefName, msg.target);
+      case "FeedWriter:GetSubscriptionUI":
+        const response = this._initSubscriptionUIResponse(msg.data.feedType);
+        msg.target.messageManager
+           .sendAsyncMessage("FeedWriter:GetSubscriptionUIResponse",
+                            response);
         break;
-      case "FeedWriter:RequestClientAppName":
-        let selectedClientApp;
-        try {
-          selectedClientApp = Services.prefs.getComplexValue(msg.data.feedTypePref, Ci.nsILocalFile);
-        } catch (ex) {
-          // Just do nothing, then we won't bother populating
-        }
-
-        let defaultClientApp = null;
-        try {
-          // This can sometimes not exist
-          defaultClientApp = Cc["@mozilla.org/browser/shell-service;1"]
-                               .getService(Ci.nsIShellService)
-                               .defaultFeedReader;
-        } catch (ex) {
-          // Just do nothing, then we don't bother populating
-        }
-
-        if (selectedClientApp && selectedClientApp.exists()) {
-          if (defaultClientApp && selectedClientApp.path != defaultClientApp.path) {
-            // Only set the default menu item if it differs from the selected one
-            msg.target.messageManager
-               .sendAsyncMessage("FeedWriter:SetApplicationLauncherMenuItem",
-                                { name: this._getFileDisplayName(defaultClientApp),
-                                  type: "DefaultAppMenuItem" });
-          }
-          msg.target.messageManager
-             .sendAsyncMessage("FeedWriter:SetApplicationLauncherMenuItem",
-                              { name: this._getFileDisplayName(selectedClientApp),
-                                type: "SelectedAppMenuItem" });
-        }
+      case "FeedWriter:ChooseClientApp":
+        this._chooseClientApp(msg.data.title, msg.data.feedType, msg.target);
         break;
       case "FeedWriter:ShownFirstRun":
-        Services.prefs.setBoolPref("browser.feeds.showFirstRunUI", false);
-        break;
-      case "FeedWriter:SetFeedCharPref":
-        Services.prefs.setCharPref(msg.data.pref, msg.data.value);
+        Services.prefs.setBoolPref(PREF_SHOW_FIRST_RUN_UI, false);
         break;
-      case "FeedWriter:SetFeedComplexString": {
-        Services.prefs.setStringPref(msg.data.pref, msg.data.value);
-        break;
-      }
+      case "FeedWriter:SetFeedPrefsAndSubscribe":
+        const settings = msg.data;
+        if (!settings.action || !VALID_ACTIONS.has(settings.action)) {
+          LOG(`Invalid action ${settings.action}`);
+          return;
+        }
+        if (!settings.reader || !VALID_READERS.has(settings.reader)) {
+          LOG(`Invalid reader ${settings.reader}`);
+          return;
+        }
+        const actionPref = getPrefActionForType(settings.feedType);
+        this._setPref(actionPref, settings.action);
+        const readerPref = getPrefReaderForType(settings.feedType);
+        this._setPref(readerPref, settings.reader);
+        handler = null;
+
+        switch (settings.reader) {
+          case "web":
+            // This is a web set URI by content using window.registerContentHandler()
+            // Lets make sure we know about it before setting it
+            const webPref = getPrefWebForType(settings.feedType);
+            let wccr = Cc["@mozilla.org/embeddor.implemented/web-content-handler-registrar;1"].
+                       getService(Ci.nsIWebContentConverterService);
+            // If the user provided an invalid web URL this function won't give us a reference
+            handler = wccr.getWebContentHandlerByURI(getMimeTypeForFeedType(settings.feedType), settings.uri);
+            if (handler) {
+              this._setPref(webPref, settings.uri, true);
+              if (settings.useAsDefault) {
+                wccr.setAutoHandler(getMimeTypeForFeedType(settings.feedType), handler);
+              }
+              msg.target.messageManager
+                 .sendAsyncMessage("FeedWriter:SetFeedPrefsAndSubscribeResponse",
+                                  { redirect: handler.getHandlerURI(settings.feedLocation) });
+            } else {
+              LOG(`No handler found for web ${settings.feedType} ${settings.uri}`);
+            }
+            break;
+          default:
+            const feedService = Cc["@mozilla.org/browser/feeds/result-service;1"].
+                                getService(Ci.nsIFeedResultService);
+
+            feedService.addToClientReader(settings.feedLocation,
+                                          settings.feedTitle,
+                                          settings.feedSubtitle,
+                                          settings.feedType,
+                                          settings.reader);
+         }
+         break;
       case "FeedConverter:ExecuteClientApp":
-        this.executeClientApp(msg.data.spec, msg.data.title,
-                              msg.data.subtitle, msg.data.feedHandler);
+        // Always check feedHandler is from a set array of executable prefs
+        if (EXECUTABLE_PREFS.has(msg.data.feedHandler)) {
+          this.executeClientApp(msg.data.spec, msg.data.title,
+                                msg.data.subtitle, msg.data.feedHandler);
+        } else {
+          LOG(`FeedConverter:ExecuteClientApp - Will not exec ${msg.data.feedHandler}`);
+        }
         break;
     }
   },
 };

--- a/browser/base/content/browser.js
+++ b/browser/base/content/browser.js
@@ -2566,18 +2566,23 @@ function URLBarSetURI(aURI) {
       } catch (ex) {
         value = "about:blank";
       }
     }
 
     valid = !isBlankPageURL(uri.spec);
   }
 
+  let isDifferentValidValue = valid && value != gURLBar.value;
   gURLBar.value = value;
   gURLBar.valueIsTyped = !valid;
+  if (isDifferentValidValue) {
+    gURLBar.selectionStart = gURLBar.selectionEnd = 0;
+  }
+
   SetPageProxyState(valid ? "valid" : "invalid");
 }
 
 function losslessDecodeURI(aURI) {
   let scheme = aURI.scheme;
   if (scheme == "moz-action")
     throw new Error("losslessDecodeURI should never get a moz-action URI");
 

--- a/browser/base/content/test/captivePortal/browser_CaptivePortalWatcher.js
+++ b/browser/base/content/test/captivePortal/browser_CaptivePortalWatcher.js
@@ -1,10 +1,14 @@
 "use strict";
 
+// Bug 1318389 - This test does a lot of window and tab manipulation,
+//               causing it to take a long time on debug.
+requestLongerTimeout(2);
+
 add_task(setupPrefsAndRecentWindowBehavior);
 
 // Each of the test cases below is run twice: once for login-success and once
 // for login-abort (aSuccess set to true and false respectively).
 let testCasesForBothSuccessAndAbort = [
   /**
    * A portal is detected when there's no browser window, then a browser
    * window is opened, then the portal is freed.

--- a/browser/base/content/test/popupNotifications/browser.ini
+++ b/browser/base/content/test/popupNotifications/browser.ini
@@ -8,17 +8,17 @@ skip-if = (os == "linux" && (debug || as
 skip-if = (os == "linux" && (debug || asan))
 [browser_popupNotification_2.js]
 skip-if = (os == "linux" && (debug || asan))
 [browser_popupNotification_3.js]
 skip-if = (os == "linux" && (debug || asan))
 [browser_popupNotification_4.js]
 skip-if = (os == "linux" && (debug || asan))
 [browser_popupNotification_5.js]
-skip-if = (os == "linux" && (debug || asan))
+skip-if = true # bug 1332646
 [browser_popupNotification_checkbox.js]
 skip-if = (os == "linux" && (debug || asan))
 [browser_popupNotification_keyboard.js]
 skip-if = (os == "linux" && (debug || asan))
 [browser_popupNotification_no_anchors.js]
 skip-if = (os == "linux" && (debug || asan))
 [browser_reshow_in_background.js]
 skip-if = (os == "linux" && (debug || asan))

--- a/browser/base/content/test/urlbar/browser_bug304198.js
+++ b/browser/base/content/test/urlbar/browser_bug304198.js
@@ -43,16 +43,19 @@ add_task(function* () {
 
   function urlbarBackspace() {
     return new Promise((resolve, reject) => {
       gBrowser.selectedBrowser.focus();
       gURLBar.addEventListener("input", function() {
         resolve();
       }, {once: true});
       gURLBar.focus();
+      if (gURLBar.selectionStart == gURLBar.selectionEnd) {
+        gURLBar.selectionStart = gURLBar.selectionEnd = gURLBar.textValue.length;
+      }
       EventUtils.synthesizeKey("VK_BACK_SPACE", {});
     });
   }
 
   function* prepareDeletedURLTab() {
     yield BrowserTestUtils.switchTab(gBrowser, deletedURLTab);
     is(gURLBar.textValue, testURL, "gURLBar.textValue should be testURL after initial switch to deletedURLTab");
 

--- a/browser/base/content/test/urlbar/browser_canonizeURL.js
+++ b/browser/base/content/test/urlbar/browser_canonizeURL.js
@@ -24,16 +24,18 @@ add_task(function*() {
   registerCleanupFunction(() => {
     Preferences.set("browser.urlbar.autoFill", autoFill);
   });
 
   for (let [inputValue, expectedURL, options] of testcases) {
     let promiseLoad = waitForDocLoadAndStopIt(expectedURL);
     gURLBar.focus();
     if (Object.keys(options).length > 0) {
+      gURLBar.selectionStart = gURLBar.selectionEnd =
+        gURLBar.inputField.value.length;
       gURLBar.inputField.value = inputValue.slice(0, -1);
       EventUtils.synthesizeKey(inputValue.slice(-1), {});
     } else {
       gURLBar.textValue = inputValue;
     }
     EventUtils.synthesizeKey("VK_RETURN", options);
     yield promiseLoad;
   }

--- a/browser/components/feeds/FeedConverter.js
+++ b/browser/components/feeds/FeedConverter.js
@@ -218,18 +218,17 @@ FeedConverter.prototype = {
               LOG("unexpected handler: " + handler);
               // fall through -- let feed service handle error
             case "bookmarks":
             case "client":
             case "default":
               try {
                 let title = feed.title ? feed.title.plainText() : "";
                 let desc = feed.subtitle ? feed.subtitle.plainText() : "";
-                let feedReader = safeGetCharPref(getPrefActionForType(feed.type), "bookmarks");
-                feedService.addToClientReader(result.uri.spec, title, desc, feed.type, feedReader);
+                feedService.addToClientReader(result.uri.spec, title, desc, feed.type, handler);
                 return;
               } catch (ex) { /* fallback to preview mode */ }
           }
         }
       }
 
       let ios =
           Cc["@mozilla.org/network/io-service;1"].

--- a/browser/components/feeds/FeedWriter.js
+++ b/browser/components/feeds/FeedWriter.js
@@ -39,93 +39,21 @@ function makeURI(aURLSpec, aCharset) {
   } catch (ex) { }
 
   return null;
 }
 
 const XML_NS = "http://www.w3.org/XML/1998/namespace";
 const HTML_NS = "http://www.w3.org/1999/xhtml";
 const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
-const TYPE_MAYBE_FEED = "application/vnd.mozilla.maybe.feed";
-const TYPE_MAYBE_AUDIO_FEED = "application/vnd.mozilla.maybe.audio.feed";
-const TYPE_MAYBE_VIDEO_FEED = "application/vnd.mozilla.maybe.video.feed";
 const URI_BUNDLE = "chrome://browser/locale/feeds/subscribe.properties";
 
-const PREF_SELECTED_APP = "browser.feeds.handlers.application";
-const PREF_SELECTED_WEB = "browser.feeds.handlers.webservice";
-const PREF_SELECTED_ACTION = "browser.feeds.handler";
-const PREF_SELECTED_READER = "browser.feeds.handler.default";
-
-const PREF_VIDEO_SELECTED_APP = "browser.videoFeeds.handlers.application";
-const PREF_VIDEO_SELECTED_WEB = "browser.videoFeeds.handlers.webservice";
-const PREF_VIDEO_SELECTED_ACTION = "browser.videoFeeds.handler";
-const PREF_VIDEO_SELECTED_READER = "browser.videoFeeds.handler.default";
-
-const PREF_AUDIO_SELECTED_APP = "browser.audioFeeds.handlers.application";
-const PREF_AUDIO_SELECTED_WEB = "browser.audioFeeds.handlers.webservice";
-const PREF_AUDIO_SELECTED_ACTION = "browser.audioFeeds.handler";
-const PREF_AUDIO_SELECTED_READER = "browser.audioFeeds.handler.default";
-
-const PREF_SHOW_FIRST_RUN_UI = "browser.feeds.showFirstRunUI";
-
 const TITLE_ID = "feedTitleText";
 const SUBTITLE_ID = "feedSubtitleText";
 
-function getPrefAppForType(t) {
-  switch (t) {
-    case Ci.nsIFeed.TYPE_VIDEO:
-      return PREF_VIDEO_SELECTED_APP;
-
-    case Ci.nsIFeed.TYPE_AUDIO:
-      return PREF_AUDIO_SELECTED_APP;
-
-    default:
-      return PREF_SELECTED_APP;
-  }
-}
-
-function getPrefWebForType(t) {
-  switch (t) {
-    case Ci.nsIFeed.TYPE_VIDEO:
-      return PREF_VIDEO_SELECTED_WEB;
-
-    case Ci.nsIFeed.TYPE_AUDIO:
-      return PREF_AUDIO_SELECTED_WEB;
-
-    default:
-      return PREF_SELECTED_WEB;
-  }
-}
-
-function getPrefActionForType(t) {
-  switch (t) {
-    case Ci.nsIFeed.TYPE_VIDEO:
-      return PREF_VIDEO_SELECTED_ACTION;
-
-    case Ci.nsIFeed.TYPE_AUDIO:
-      return PREF_AUDIO_SELECTED_ACTION;
-
-    default:
-      return PREF_SELECTED_ACTION;
-  }
-}
-
-function getPrefReaderForType(t) {
-  switch (t) {
-    case Ci.nsIFeed.TYPE_VIDEO:
-      return PREF_VIDEO_SELECTED_READER;
-
-    case Ci.nsIFeed.TYPE_AUDIO:
-      return PREF_AUDIO_SELECTED_READER;
-
-    default:
-      return PREF_SELECTED_READER;
-  }
-}
-
 /**
  * Converts a number of bytes to the appropriate unit that results in a
  * number that needs fewer than 4 digits
  *
  * @return a pair: [new value with 3 sig. figs., its unit]
   */
 function convertByteUnits(aBytes) {
   let units = ["bytes", "kilobyte", "megabyte", "gigabyte"];
@@ -148,19 +76,16 @@ function convertByteUnits(aBytes) {
 function FeedWriter() {
   this._selectedApp = undefined;
   this._selectedAppMenuItem = null;
   this._subscribeCallback = null;
   this._defaultHandlerMenuItem = null;
 }
 
 FeedWriter.prototype = {
-  _mimeSvc      : Cc["@mozilla.org/mime;1"].
-                  getService(Ci.nsIMIMEService),
-
   _getPropertyAsBag(container, property) {
     return container.fields.getProperty(property).
                      QueryInterface(Ci.nsIPropertyBag2);
   },
 
   _getPropertyAsString(container, property) {
     try {
       return container.fields.getPropertyAsAString(property);
@@ -221,28 +146,31 @@ FeedWriter.prototype = {
   _getFormattedString(key, params) {
     return this._bundle.formatStringFromName(key, params, params.length);
   },
 
   _getString(key) {
     return this._bundle.GetStringFromName(key);
   },
 
-  _setCheckboxCheckedState(aCheckbox, aValue) {
-    // see checkbox.xml, xbl bindings are not applied within the sandbox! TODO
-    let change = (aValue != (aCheckbox.getAttribute("checked") == "true"));
-    if (aValue)
-      aCheckbox.setAttribute("checked", "true");
-    else
-      aCheckbox.removeAttribute("checked");
+  _setCheckboxCheckedState(aValue) {
+    let checkbox = this._document.getElementById("alwaysUse");
+    if (checkbox) {
+      // see checkbox.xml, xbl bindings are not applied within the sandbox! TODO
+      let change = (aValue != (checkbox.getAttribute("checked") == "true"));
+      if (aValue)
+        checkbox.setAttribute("checked", "true");
+      else
+        checkbox.removeAttribute("checked");
 
-    if (change) {
-      let event = this._document.createEvent("Events");
-      event.initEvent("CheckboxStateChange", true, true);
-      aCheckbox.dispatchEvent(event);
+      if (change) {
+        let event = this._document.createEvent("Events");
+        event.initEvent("CheckboxStateChange", true, true);
+        checkbox.dispatchEvent(event);
+      }
     }
   },
 
    /**
    * Returns a date suitable for displaying in the feed preview.
    * If the date cannot be parsed, the return value is "false".
    * @param   dateString
    *          A date as extracted from a feed entry. (entry.updated)
@@ -286,32 +214,16 @@ FeedWriter.prototype = {
       this.__feedType = feed.type;
       return feed.type;
     } catch (ex) { }
 
     return Ci.nsIFeed.TYPE_FEED;
   },
 
   /**
-   * Maps a feed type to a maybe-feed mimetype.
-   */
-  _getMimeTypeForFeedType() {
-    switch (this._getFeedType()) {
-      case Ci.nsIFeed.TYPE_VIDEO:
-        return TYPE_MAYBE_VIDEO_FEED;
-
-      case Ci.nsIFeed.TYPE_AUDIO:
-        return TYPE_MAYBE_AUDIO_FEED;
-
-      default:
-        return TYPE_MAYBE_FEED;
-    }
-  },
-
-  /**
    * Writes the feed title into the preview document.
    * @param   container
    *          The feed container
    */
   _setTitleText(container) {
     if (container.title) {
       let title = container.title.plainText();
       this._setContentText(TITLE_ID, container.title);
@@ -486,27 +398,21 @@ FeedWriter.prototype = {
       enclosureDiv.setAttribute("class", "enclosure");
 
       let mozicon = "moz-icon://.txt?size=16";
       let type_text = null;
       let size_text = null;
 
       if (enc.hasKey("type")) {
         type_text = enc.get("type");
-        try {
-          let handlerInfoWrapper = this._mimeSvc.getFromTypeAndExtension(enc.get("type"), null);
-
-          if (handlerInfoWrapper)
-            type_text = handlerInfoWrapper.description;
+        if (enc.hasKey("typeDesc"))
+          type_text = enc.get("typeDesc");
 
-          if (type_text && type_text.length > 0)
-            mozicon = "moz-icon://goat?size=16&contentType=" + enc.get("type");
-
-        } catch (ex) { }
-
+        if (type_text && type_text.length > 0)
+          mozicon = "moz-icon://goat?size=16&contentType=" + enc.get("type");
       }
 
       if (enc.hasKey("length") && /^[0-9]+$/.test(enc.get("length"))) {
         let enc_size = convertByteUnits(parseInt(enc.get("length")));
 
         size_text = this._getFormattedString("enclosureSizeText",
                                              [enc_size[0],
                                              this._getString(enc_size[1])]);
@@ -591,29 +497,17 @@ FeedWriter.prototype = {
    * Displays a prompt from which the user may choose a (client) feed reader.
    * @param aCallback the callback method, passes in true if a feed reader was
    *        selected, false otherwise.
    */
   _chooseClientApp(aCallback) {
     this._subscribeCallback = aCallback;
     this._mm.sendAsyncMessage("FeedWriter:ChooseClientApp",
                               { title: this._getString("chooseApplicationDialogTitle"),
-                                prefName: getPrefAppForType(this._getFeedType()) });
-  },
-
-  _setAlwaysUseCheckedState(feedType) {
-    let checkbox = this._document.getElementById("alwaysUse");
-    if (checkbox) {
-      let alwaysUse = false;
-      try {
-        if (Services.prefs.getCharPref(getPrefActionForType(feedType)) != "ask")
-          alwaysUse = true;
-      } catch (ex) { }
-      this._setCheckboxCheckedState(checkbox, alwaysUse);
-    }
+                                feedType: this._getFeedType() });
   },
 
   _setSubscribeUsingLabel() {
     let stringLabel = "subscribeFeedUsing";
     switch (this._getFeedType()) {
       case Ci.nsIFeed.TYPE_VIDEO:
         stringLabel = "subscribeVideoPodcastUsing";
         break;
@@ -666,54 +560,44 @@ FeedWriter.prototype = {
 
     switch (event.type) {
       case "click":
         if (event.target.id == "subscribeButton") {
           this.subscribe();
         }
       break;
       case "change":
+        LOG("Change fired");
         if (event.target.selectedOptions[0].id == "chooseApplicationMenuItem") {
-          this._chooseClientApp((aResult) => {
-            if (!aResult) {
-              // Select the (per-prefs) selected handler if no application
-              // was selected
-              this._setSelectedHandler(this._getFeedType());
-            }
+          this._chooseClientApp(() => {
+            // Select the (per-prefs) selected handler if no application
+            // was selected
+            LOG("Selected handler after callback");
+            this._setAlwaysUseLabel();
           });
         } else {
           this._setAlwaysUseLabel();
         }
         break;
     }
   },
 
   _getWebHandlerElementsForURL(aURL) {
-    let menu = this._document.getElementById("handlersMenuList");
-    return menu.querySelectorAll('[webhandlerurl="' + aURL + '"]');
+    return this._handlersList.querySelectorAll('[webhandlerurl="' + aURL + '"]');
   },
 
-  _setSelectedHandler(feedType) {
-    let prefs = Services.prefs;
-    let handler = prefs.getCharPref(getPrefReaderForType(feedType), "bookmarks");
-
+  _setSelectedHandlerResponse(handler, url) {
+    LOG(`Selecting handler response ${handler} ${url}`);
     switch (handler) {
       case "web": {
         if (this._handlersList) {
-          let url;
-          try {
-            url = prefs.getStringPref(getPrefWebForType(feedType));
-          } catch (ex) {
-            LOG("FeedWriter._setSelectedHandler: invalid or no handler in prefs");
-            return;
-          }
           let handlers =
             this._getWebHandlerElementsForURL(url);
           if (handlers.length == 0) {
-            LOG("FeedWriter._setSelectedHandler: selected web handler isn't in the menulist")
+            LOG(`Selected web handler isn't in the menulist ${url}`);
             return;
           }
 
           handlers[0].selected = true;
         }
         break;
       }
       case "client":
@@ -724,20 +608,20 @@ FeedWriter.prototype = {
       default: {
         let liveBookmarksMenuItem = this._document.getElementById("liveBookmarksMenuItem");
         if (liveBookmarksMenuItem)
           liveBookmarksMenuItem.selected = true;
       }
     }
   },
 
-  _initSubscriptionUI() {
-    let handlersList = this._document.getElementById("handlersMenuList");
-    if (!handlersList)
+  _initSubscriptionUI(setupMessage) {
+    if (!this._handlersList)
       return;
+    LOG("UI init");
 
     let feedType = this._getFeedType();
 
     // change the background
     let header = this._document.getElementById("feedHeader");
     switch (feedType) {
       case Ci.nsIFeed.TYPE_VIDEO:
         header.className = "videoPodcastBackground";
@@ -758,83 +642,84 @@ FeedWriter.prototype = {
     menuItem.removeAttribute("selected");
     menuItem.setAttribute("id", "selectedAppMenuItem");
     menuItem.setAttribute("handlerType", "client");
 
     // Hide the menuitem until we select an app
     menuItem.style.display = "none";
     this._selectedAppMenuItem = menuItem;
 
-    handlersList.appendChild(this._selectedAppMenuItem);
+    this._handlersList.appendChild(this._selectedAppMenuItem);
 
     // Create the menuitem for the default reader, but don't show/populate it until
     // we get confirmation of what it is from the parent
     menuItem = liveBookmarksMenuItem.cloneNode(false);
     menuItem.removeAttribute("selected");
     menuItem.setAttribute("id", "defaultHandlerMenuItem");
     menuItem.setAttribute("handlerType", "client");
     menuItem.style.display = "none";
 
     this._defaultHandlerMenuItem = menuItem;
-    handlersList.appendChild(this._defaultHandlerMenuItem);
-
-    this._mm.sendAsyncMessage("FeedWriter:RequestClientAppName",
-                              { feedTypePref: getPrefAppForType(feedType) });
+    this._handlersList.appendChild(this._defaultHandlerMenuItem);
 
     // "Choose Application..." menuitem
     menuItem = liveBookmarksMenuItem.cloneNode(false);
     menuItem.removeAttribute("selected");
     menuItem.setAttribute("id", "chooseApplicationMenuItem");
     menuItem.textContent = this._getString("chooseApplicationMenuItem");
 
-    handlersList.appendChild(menuItem);
+    this._handlersList.appendChild(menuItem);
 
     // separator
     let chooseAppSep = liveBookmarksMenuItem.nextElementSibling.cloneNode(false);
     chooseAppSep.textContent = liveBookmarksMenuItem.nextElementSibling.textContent;
-    handlersList.appendChild(chooseAppSep);
+    this._handlersList.appendChild(chooseAppSep);
 
-    // List of web handlers
-    let wccr = Cc["@mozilla.org/embeddor.implemented/web-content-handler-registrar;1"].
-               getService(Ci.nsIWebContentConverterService);
-    let handlers = wccr.getContentHandlers(this._getMimeTypeForFeedType(feedType));
-    for (let handler of handlers) {
+    for (let handler of setupMessage.handlers) {
       if (!handler.uri) {
         LOG("Handler with name " + handler.name + " has no URI!? Skipping...");
         continue;
       }
       menuItem = liveBookmarksMenuItem.cloneNode(false);
       menuItem.removeAttribute("selected");
       menuItem.className = "menuitem-iconic";
       menuItem.textContent = handler.name;
       menuItem.setAttribute("handlerType", "web");
       menuItem.setAttribute("webhandlerurl", handler.uri);
-      handlersList.appendChild(menuItem);
+      this._handlersList.appendChild(menuItem);
     }
 
-    this._setSelectedHandler(feedType);
+    this._setSelectedHandlerResponse(setupMessage.reader.handler, setupMessage.reader.url);
+
+    if (setupMessage.defaultMenuItem) {
+      LOG(`Setting default menu item ${setupMessage.defaultMenuItem}`);
+      this._setApplicationLauncherMenuItem(this._defaultHandlerMenuItem, setupMessage.defaultMenuItem);
+    }
+    if (setupMessage.selectedMenuItem) {
+      LOG(`Setting selected menu item ${setupMessage.selectedMenuItem}`);
+      this._setApplicationLauncherMenuItem(this._selectedAppMenuItem, setupMessage.selectedMenuItem);
+    }
 
     // "Subscribe using..."
     this._setSubscribeUsingLabel();
 
     // "Always use..." checkbox initial state
-    this._setAlwaysUseCheckedState(feedType);
+    this._setCheckboxCheckedState(setupMessage.reader.alwaysUse);
     this._setAlwaysUseLabel();
 
     // We update the "Always use.." checkbox label whenever the selected item
     // in the list is changed
-    handlersList.addEventListener("change", this);
+    this._handlersList.addEventListener("change", this);
 
     // Set up the "Subscribe Now" button
     this._document.getElementById("subscribeButton")
         .addEventListener("click", this);
 
     // first-run ui
-    let showFirstRunUI = Services.prefs.getBoolPref(PREF_SHOW_FIRST_RUN_UI, true);
-    if (showFirstRunUI) {
+    if (setupMessage.showFirstRunUI) {
       let textfeedinfo1, textfeedinfo2;
       switch (feedType) {
         case Ci.nsIFeed.TYPE_VIDEO:
           textfeedinfo1 = "feedSubscriptionVideoPodcast1";
           textfeedinfo2 = "feedSubscriptionVideoPodcast2";
           break;
         case Ci.nsIFeed.TYPE_AUDIO:
           textfeedinfo1 = "feedSubscriptionAudioPodcast1";
@@ -910,63 +795,84 @@ FeedWriter.prototype = {
     this._handlersList = this._document.getElementById("handlersMenuList");
 
     let secman = Cc["@mozilla.org/scriptsecuritymanager;1"].
                  getService(Ci.nsIScriptSecurityManager);
     this._feedPrincipal = secman.createCodebasePrincipal(this._feedURI, {});
 
     LOG("Subscribe Preview: feed uri = " + this._window.location.href);
 
-    // Set up the subscription UI
-    this._initSubscriptionUI();
-    let prefs = Services.prefs;
-    prefs.addObserver(PREF_SELECTED_ACTION, this, false);
-    prefs.addObserver(PREF_SELECTED_READER, this, false);
-    prefs.addObserver(PREF_SELECTED_WEB, this, false);
-    prefs.addObserver(PREF_SELECTED_APP, this, false);
-    prefs.addObserver(PREF_VIDEO_SELECTED_ACTION, this, false);
-    prefs.addObserver(PREF_VIDEO_SELECTED_READER, this, false);
-    prefs.addObserver(PREF_VIDEO_SELECTED_WEB, this, false);
-    prefs.addObserver(PREF_VIDEO_SELECTED_APP, this, false);
 
-    prefs.addObserver(PREF_AUDIO_SELECTED_ACTION, this, false);
-    prefs.addObserver(PREF_AUDIO_SELECTED_READER, this, false);
-    prefs.addObserver(PREF_AUDIO_SELECTED_WEB, this, false);
-    prefs.addObserver(PREF_AUDIO_SELECTED_APP, this, false);
+    this._mm.addMessageListener("FeedWriter:PreferenceUpdated", this);
+    this._mm.addMessageListener("FeedWriter:SetApplicationLauncherMenuItem", this);
+    this._mm.addMessageListener("FeedWriter:GetSubscriptionUIResponse", this);
+    this._mm.addMessageListener("FeedWriter:SetFeedPrefsAndSubscribeResponse", this);
 
-    this._mm.addMessageListener("FeedWriter:SetApplicationLauncherMenuItem", this);
+    const feedType = this._getFeedType();
+    this._mm.sendAsyncMessage("FeedWriter:GetSubscriptionUI",
+                              { feedType });
   },
 
   receiveMessage(msg) {
+    if (!this._window) {
+      // this._window is null unless this.init was called with a trusted
+      // window object.
+      return;
+    }
+    LOG(`received message from parent ${msg.name}`);
     switch (msg.name) {
+      case "FeedWriter:PreferenceUpdated":
+        // This is called when browser-feeds.js spots a pref change
+        // This will happen when
+        // - about:preferences#applications changes
+        // - another feed reader page changes the preference
+        // - when this page itself changes the select and there isn't a redirect
+        //   bookmarks and launching an external app means the page stays open after subscribe
+        const feedType = this._getFeedType();
+        LOG(`Got prefChange! ${JSON.stringify(msg.data)} current type: ${feedType}`);
+        let feedTypePref = msg.data.default;
+        if (feedType in msg.data) {
+          feedTypePref = msg.data[feedType];
+        }
+        LOG(`Got pref ${JSON.stringify(feedTypePref)}`);
+        this._setCheckboxCheckedState(feedTypePref.alwaysUse);
+        this._setSelectedHandlerResponse(feedTypePref.handler, feedTypePref.url);
+        this._setAlwaysUseLabel();
+        break;
+      case "FeedWriter:SetFeedPrefsAndSubscribeResponse":
+        LOG(`FeedWriter:SetFeedPrefsAndSubscribeResponse - Redirecting ${msg.data.redirect}`);
+        this._window.location.href = msg.data.redirect;
+        break;
+      case "FeedWriter:GetSubscriptionUIResponse":
+        // Set up the subscription UI
+        this._initSubscriptionUI(msg.data);
+        break;
       case "FeedWriter:SetApplicationLauncherMenuItem":
-        let menuItem = null;
-
-        if (msg.data.type == "DefaultAppMenuItem") {
-          menuItem = this._defaultHandlerMenuItem;
-        } else {
-          // Most likely SelectedAppMenuItem
-          menuItem = this._selectedAppMenuItem;
-        }
-
-        menuItem.textContent = msg.data.name;
-        menuItem.style.display = "";
-        menuItem.selected = true;
-
+        LOG(`FeedWriter:SetApplicationLauncherMenuItem - picked ${msg.data.name}`);
+        this._setApplicationLauncherMenuItem(this._selectedAppMenuItem, msg.data.name);
         // Potentially a bit racy, but I don't think we can get into a state where this callback is set and
         // we're not coming back from ChooseClientApp in browser-feeds.js
         if (this._subscribeCallback) {
           this._subscribeCallback();
           this._subscribeCallback = null;
         }
-
         break;
     }
   },
 
+  _setApplicationLauncherMenuItem(menuItem, aName) {
+    /* unselect all handlers */
+    [...this._handlersList.children].forEach((option) => {
+      option.removeAttribute("selected");
+    });
+    menuItem.textContent = aName;
+    menuItem.style.display = "";
+    menuItem.selected = true;
+  },
+
   writeContent() {
     if (!this._window)
       return;
 
     try {
       // Set up the feed content
       let container = this._getContainer();
       if (!container)
@@ -978,34 +884,21 @@ FeedWriter.prototype = {
     } finally {
       this._removeFeedFromCache();
     }
   },
 
   close() {
     this._document.getElementById("subscribeButton")
         .removeEventListener("click", this);
-    this._document.getElementById("handlersMenuList")
+    this._handlersList
         .removeEventListener("change", this);
     this._document = null;
     this._window = null;
-    let prefs = Services.prefs;
-    prefs.removeObserver(PREF_SELECTED_ACTION, this);
-    prefs.removeObserver(PREF_SELECTED_READER, this);
-    prefs.removeObserver(PREF_SELECTED_WEB, this);
-    prefs.removeObserver(PREF_SELECTED_APP, this);
-    prefs.removeObserver(PREF_VIDEO_SELECTED_ACTION, this);
-    prefs.removeObserver(PREF_VIDEO_SELECTED_READER, this);
-    prefs.removeObserver(PREF_VIDEO_SELECTED_WEB, this);
-    prefs.removeObserver(PREF_VIDEO_SELECTED_APP, this);
-
-    prefs.removeObserver(PREF_AUDIO_SELECTED_ACTION, this);
-    prefs.removeObserver(PREF_AUDIO_SELECTED_READER, this);
-    prefs.removeObserver(PREF_AUDIO_SELECTED_WEB, this);
-    prefs.removeObserver(PREF_AUDIO_SELECTED_APP, this);
+    this._handlersList = null;
 
     this._removeFeedFromCache();
     this.__bundle = null;
     this._feedURI = null;
 
     this._selectedApp = undefined;
     this._selectedAppMenuItem = null;
     this._defaultHandlerMenuItem = null;
@@ -1015,90 +908,64 @@ FeedWriter.prototype = {
     if (this._feedURI) {
       let feedService = Cc["@mozilla.org/browser/feeds/result-service;1"].
                         getService(Ci.nsIFeedResultService);
       feedService.removeFeedResult(this._feedURI);
       this._feedURI = null;
     }
   },
 
-  setFeedCharPref(aPrefName, aPrefValue) {
-      this._mm.sendAsyncMessage("FeedWriter:SetFeedCharPref",
-                                { pref: aPrefName,
-                                  value: aPrefValue });
-  },
-
-  setFeedComplexString(aPrefName, aPrefValue) {
-      // This sends the string data across to the parent, which will use it in an nsISupportsString
-      // for a complex value pref.
-      this._mm.sendAsyncMessage("FeedWriter:SetFeedComplexString",
-                                { pref: aPrefName,
-                                  value: aPrefValue });
-  },
-
   subscribe() {
     let feedType = this._getFeedType();
 
     // Subscribe to the feed using the selected handler and save prefs
     let defaultHandler = "reader";
     let useAsDefault = this._document.getElementById("alwaysUse").getAttribute("checked");
 
-    let menuList = this._document.getElementById("handlersMenuList");
-    let selectedItem = menuList.selectedOptions[0];
+    let selectedItem = this._handlersList.selectedOptions[0];
     let subscribeCallback = () => {
+      let feedReader = null;
+      let settings = {
+        feedType,
+        useAsDefault,
+        // Pull the title and subtitle out of the document
+        feedTitle: this._document.getElementById(TITLE_ID).textContent,
+        feedSubtitle: this._document.getElementById(SUBTITLE_ID).textContent,
+        feedLocation: this._window.location.href
+      };
       if (selectedItem.hasAttribute("webhandlerurl")) {
-        let webURI = selectedItem.getAttribute("webhandlerurl");
-        this.setFeedCharPref(getPrefReaderForType(feedType), "web");
-        this.setFeedComplexString(getPrefWebForType(feedType), webURI);
-
-        let wccr = Cc["@mozilla.org/embeddor.implemented/web-content-handler-registrar;1"].
-                   getService(Ci.nsIWebContentConverterService);
-        let handler = wccr.getWebContentHandlerByURI(this._getMimeTypeForFeedType(feedType), webURI);
-        if (handler) {
-          if (useAsDefault) {
-            wccr.setAutoHandler(this._getMimeTypeForFeedType(feedType), handler);
-          }
-
-          this._window.location.href = handler.getHandlerURI(this._window.location.href);
-        }
+        feedReader = "web";
+        settings.uri = selectedItem.getAttribute("webhandlerurl");
       } else {
-        let feedReader = null;
         switch (selectedItem.id) {
           case "selectedAppMenuItem":
             feedReader = "client";
             break;
           case "defaultHandlerMenuItem":
             feedReader = "default";
             break;
           case "liveBookmarksMenuItem":
             defaultHandler = "bookmarks";
             feedReader = "bookmarks";
             break;
         }
-
-        this.setFeedCharPref(getPrefReaderForType(feedType), feedReader);
-
-        let feedService = Cc["@mozilla.org/browser/feeds/result-service;1"].
-                          getService(Ci.nsIFeedResultService);
-
-        // Pull the title and subtitle out of the document
-        let feedTitle = this._document.getElementById(TITLE_ID).textContent;
-        let feedSubtitle = this._document.getElementById(SUBTITLE_ID).textContent;
-        feedService.addToClientReader(this._window.location.href, feedTitle, feedSubtitle, feedType, feedReader);
       }
+      settings.reader = feedReader;
 
       // If "Always use..." is checked, we should set PREF_*SELECTED_ACTION
       // to either "reader" (If a web reader or if an application is selected),
       // or to "bookmarks" (if the live bookmarks option is selected).
       // Otherwise, we should set it to "ask"
-      if (useAsDefault) {
-        this.setFeedCharPref(getPrefActionForType(feedType), defaultHandler);
-      } else {
-        this.setFeedCharPref(getPrefActionForType(feedType), "ask");
+      if (!useAsDefault) {
+        defaultHandler = "ask";
       }
+      settings.action = defaultHandler;
+      LOG(`FeedWriter:SetFeedPrefsAndSubscribe - ${JSON.stringify(settings)}`);
+      this._mm.sendAsyncMessage("FeedWriter:SetFeedPrefsAndSubscribe",
+                                settings);
     }
 
     // Show the file picker before subscribing if the
     // choose application menuitem was chosen using the keyboard
     if (selectedItem.id == "chooseApplicationMenuItem") {
       this._chooseClientApp(function(aResult) {
         if (aResult) {
           selectedItem =
@@ -1106,47 +973,16 @@ FeedWriter.prototype = {
           subscribeCallback();
         }
       }.bind(this));
     } else {
       subscribeCallback();
     }
   },
 
-  // nsIObserver
-  observe(subject, topic, data) {
-    if (!this._window) {
-      // this._window is null unless this.init was called with a trusted
-      // window object.
-      return;
-    }
-
-    let feedType = this._getFeedType();
-
-    if (topic == "nsPref:changed") {
-      switch (data) {
-        case PREF_SELECTED_READER:
-        case PREF_SELECTED_WEB:
-        case PREF_SELECTED_APP:
-        case PREF_VIDEO_SELECTED_READER:
-        case PREF_VIDEO_SELECTED_WEB:
-        case PREF_VIDEO_SELECTED_APP:
-        case PREF_AUDIO_SELECTED_READER:
-        case PREF_AUDIO_SELECTED_WEB:
-        case PREF_AUDIO_SELECTED_APP:
-          this._setSelectedHandler(feedType);
-          break;
-        case PREF_SELECTED_ACTION:
-        case PREF_VIDEO_SELECTED_ACTION:
-        case PREF_AUDIO_SELECTED_ACTION:
-          this._setAlwaysUseCheckedState(feedType);
-      }
-    }
-  },
-
   get _mm() {
     let mm = this._window.QueryInterface(Ci.nsIInterfaceRequestor).
                           getInterface(Ci.nsIDocShell).
                           QueryInterface(Ci.nsIInterfaceRequestor).
                           getInterface(Ci.nsIContentFrameMessageManager);
     delete this._mm;
     return this._mm = mm;
   },

--- a/browser/extensions/e10srollout/bootstrap.js
+++ b/browser/extensions/e10srollout/bootstrap.js
@@ -14,17 +14,17 @@ Cu.import("resource://gre/modules/Update
 const TEST_THRESHOLD = {
   "beta"    : 0.5,  // 50%
   "release" : 1.0,  // 100%
   "esr"     : 1.0,  // 100%
 };
 
 const ADDON_ROLLOUT_POLICY = {
   "beta"    : "51alladdons", // Any WebExtension or addon except with mpc = false
-  "release" : "51set1",
+  "release" : "50allmpc",
   "esr"     : "esrA", // WebExtensions and Addons with mpc=true
 };
 
 const PREF_COHORT_SAMPLE       = "e10s.rollout.cohortSample";
 const PREF_COHORT_NAME         = "e10s.rollout.cohort";
 const PREF_E10S_OPTED_IN       = "browser.tabs.remote.autostart";
 const PREF_E10S_FORCE_ENABLED  = "browser.tabs.remote.force-enable";
 const PREF_E10S_FORCE_DISABLED = "browser.tabs.remote.force-disable";
@@ -68,17 +68,20 @@ function defineCohort() {
   if (updateChannel in ADDON_ROLLOUT_POLICY) {
     addonPolicy = ADDON_ROLLOUT_POLICY[updateChannel];
     Preferences.set(PREF_E10S_ADDON_POLICY, addonPolicy);
     // This is also the proper place to set the blocklist pref
     // in case it is necessary.
 
     Preferences.set(PREF_E10S_ADDON_BLOCKLIST,
                     // bug 1185672 - Tab Mix Plus
-                    "{dc572301-7619-498c-a57d-39143191b318};");
+                    "{dc572301-7619-498c-a57d-39143191b318};"
+                    // bug 1344345 - Mega
+                    + "firefox@mega.co.nz"
+                    );
   } else {
     Preferences.reset(PREF_E10S_ADDON_POLICY);
   }
 
   let userOptedOut = optedOut();
   let userOptedIn = optedIn();
   let disqualified = (Services.appinfo.multiprocessBlockPolicy != 0);
   let testGroup = (getUserSample() < TEST_THRESHOLD[updateChannel]);

--- a/browser/extensions/e10srollout/install.rdf.in
+++ b/browser/extensions/e10srollout/install.rdf.in
@@ -5,17 +5,17 @@
 
 #filter substitution
 
 <RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
      xmlns:em="http://www.mozilla.org/2004/em-rdf#">
 
   <Description about="urn:mozilla:install-manifest">
     <em:id>e10srollout@mozilla.org</em:id>
-    <em:version>1.11</em:version>
+    <em:version>1.12</em:version>
     <em:type>2</em:type>
     <em:bootstrap>true</em:bootstrap>
     <em:multiprocessCompatible>true</em:multiprocessCompatible>
 
     <!-- Target Application this theme can install into,
         with minimum and maximum supported versions. -->
     <em:targetApplication>
       <Description>

--- a/caps/nsJSPrincipals.cpp
+++ b/caps/nsJSPrincipals.cpp
@@ -130,26 +130,32 @@ ReadSuffixAndSpec(JSStructuredCloneReade
                   nsACString& aSpec)
 {
     uint32_t suffixLength, specLength;
     if (!JS_ReadUint32Pair(aReader, &suffixLength, &specLength)) {
         return false;
     }
 
     nsAutoCString suffix;
-    suffix.SetLength(suffixLength);
+    if (!suffix.SetLength(suffixLength, fallible)) {
+        return false;
+    }
+
     if (!JS_ReadBytes(aReader, suffix.BeginWriting(), suffixLength)) {
         return false;
     }
 
     if (!aAttrs.PopulateFromSuffix(suffix)) {
         return false;
     }
 
-    aSpec.SetLength(specLength);
+    if (!aSpec.SetLength(specLength, fallible)) {
+        return false;
+    }
+
     if (!JS_ReadBytes(aReader, aSpec.BeginWriting(), specLength)) {
         return false;
     }
 
     return true;
 }
 
 static bool
@@ -190,17 +196,17 @@ ReadPrincipalInfo(JSStructuredCloneReade
         aInfo = expanded;
     } else if (aTag == SCTAG_DOM_CONTENT_PRINCIPAL) {
         OriginAttributes attrs;
         nsAutoCString spec;
         if (!ReadSuffixAndSpec(aReader, attrs, spec)) {
             return false;
         }
 
-        aInfo = ContentPrincipalInfo(attrs, spec);
+        aInfo = ContentPrincipalInfo(attrs, void_t(), spec);
     } else {
         MOZ_CRASH("unexpected principal structured clone tag");
     }
 
     return true;
 }
 
 /* static */ bool

--- a/devtools/client/webconsole/test/browser.ini
+++ b/devtools/client/webconsole/test/browser.ini
@@ -176,17 +176,16 @@ skip-if = (os == 'linux' && bits == 32 &
 [browser_console_error_source_click.js]
 [browser_console_filters.js]
 [browser_console_iframe_messages.js]
 [browser_console_keyboard_accessibility.js]
 [browser_console_log_inspectable_object.js]
 [browser_console_native_getters.js]
 [browser_console_navigation_marker.js]
 [browser_console_netlogging.js]
-skip-if = true # Bug 1298364
 [browser_console_nsiconsolemessage.js]
 [browser_console_optimized_out_vars.js]
 [browser_console_private_browsing.js]
 skip-if = e10s # Bug 1042253 - webconsole e10s tests
 [browser_console_server_logging.js]
 [browser_console_variables_view.js]
 [browser_console_variables_view_filter.js]
 [browser_console_variables_view_dom_nodes.js]
@@ -333,16 +332,17 @@ skip-if = e10s # Bug 1042253 - webconsol
 [browser_webconsole_js_input_expansion.js]
 [browser_webconsole_jsterm.js]
 skip-if = e10s # Bug 1042253 - webconsole e10s tests (Linux debug timeout)
 [browser_webconsole_live_filtering_of_message_types.js]
 [browser_webconsole_live_filtering_on_search_strings.js]
 [browser_webconsole_message_node_id.js]
 [browser_webconsole_multiline_input.js]
 [browser_webconsole_netlogging.js]
+skip-if = true # Bug 1298364
 [browser_webconsole_netlogging_basic.js]
 [browser_webconsole_netlogging_panel.js]
 [browser_webconsole_netlogging_reset_filter.js]
 [browser_webconsole_notifications.js]
 [browser_webconsole_open-links-without-callback.js]
 [browser_webconsole_promise.js]
 [browser_webconsole_output_copy_newlines.js]
 subsuite = clipboard

--- a/devtools/server/actors/layout.js
+++ b/devtools/server/actors/layout.js
@@ -120,21 +120,26 @@ var LayoutActor = ActorClassWithSpec(lay
    * iterating below the given rootNode and optionally including nested frames.
    *
    * @param  {NodeActor} rootNode
    * @param  {Boolean} traverseFrames
    *         Whether or not we should iterate through nested frames.
    * @return {Array} An array of GridActor objects.
    */
   getAllGrids: function (rootNode, traverseFrames) {
+    let grids = [];
+
+    if (!rootNode) {
+      return grids;
+    }
+
     if (!traverseFrames) {
       return this.getGrids(rootNode.rawNode);
     }
 
-    let grids = [];
     for (let {document} of this.tabActor.windows) {
       grids = [...grids, ...this.getGrids(document.documentElement)];
     }
 
     return grids;
   },
 
   onNavigate: function () {

--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -10560,24 +10560,22 @@ nsIDocument::ObsoleteSheet(const nsAStri
 
 class UnblockParsingPromiseHandler final : public PromiseNativeHandler
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_CLASS(UnblockParsingPromiseHandler)
 
   explicit UnblockParsingPromiseHandler(nsIDocument* aDocument, Promise* aPromise)
-    : mDocument(aDocument)
-    , mPromise(aPromise)
+    : mPromise(aPromise)
   {
-    nsCOMPtr<nsIParser> parser = mDocument->CreatorParserOrNull();
+    nsCOMPtr<nsIParser> parser = aDocument->CreatorParserOrNull();
     if (parser) {
       parser->BlockParser();
-    } else {
-      mDocument = nullptr;
+      mParser = do_GetWeakReference(parser);
     }
   }
 
   void
   ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
   {
     MaybeUnblockParser();
 
@@ -10595,31 +10593,29 @@ public:
 protected:
   virtual ~UnblockParsingPromiseHandler()
   {
     MaybeUnblockParser();
   }
 
 private:
   void MaybeUnblockParser() {
-    if (mDocument) {
-      nsCOMPtr<nsIParser> parser = mDocument->CreatorParserOrNull();
-      if (parser) {
-        parser->UnblockParser();
-        parser->ContinueInterruptedParsingAsync();
-      }
-      mDocument = nullptr;
-    }
-  }
-
-  RefPtr<nsIDocument> mDocument;
+    nsCOMPtr<nsIParser> parser = do_QueryReferent(mParser);
+    if (parser) {
+      parser->UnblockParser();
+      parser->ContinueInterruptedParsingAsync();
+      mParser = nullptr;
+    }
+  }
+
+  nsWeakPtr mParser;
   RefPtr<Promise> mPromise;
 };
 
-NS_IMPL_CYCLE_COLLECTION(UnblockParsingPromiseHandler, mDocument, mPromise)
+NS_IMPL_CYCLE_COLLECTION(UnblockParsingPromiseHandler, mPromise)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(UnblockParsingPromiseHandler)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(UnblockParsingPromiseHandler)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(UnblockParsingPromiseHandler)
 

--- a/dom/cache/DBSchema.cpp
+++ b/dom/cache/DBSchema.cpp
@@ -1970,25 +1970,25 @@ ReadResponse(mozIStorageConnection* aCon
   }
 
   nsAutoCString serializedInfo;
   rv = state->GetUTF8String(5, serializedInfo);
   if (NS_WARN_IF(NS_FAILED(rv))) { return rv; }
 
   aSavedResponseOut->mValue.principalInfo() = void_t();
   if (!serializedInfo.IsEmpty()) {
-    nsAutoCString originNoSuffix;
+    nsAutoCString specNoSuffix;
     OriginAttributes attrs;
-    if (!attrs.PopulateFromOrigin(serializedInfo, originNoSuffix)) {
+    if (!attrs.PopulateFromOrigin(serializedInfo, specNoSuffix)) {
       NS_WARNING("Something went wrong parsing a serialized principal!");
       return NS_ERROR_FAILURE;
     }
 
     aSavedResponseOut->mValue.principalInfo() =
-      mozilla::ipc::ContentPrincipalInfo(attrs, originNoSuffix);
+      mozilla::ipc::ContentPrincipalInfo(attrs, void_t(), specNoSuffix);
   }
 
   rv = state->GetBlobAsUTF8String(6, aSavedResponseOut->mValue.channelInfo().securityInfo());
   if (NS_WARN_IF(NS_FAILED(rv))) { return rv; }
 
   rv = aConn->CreateStatement(NS_LITERAL_CSTRING(
     "SELECT "
       "name, "

--- a/dom/events/test/pointerevents/mochitest.ini
+++ b/dom/events/test/pointerevents/mochitest.ini
@@ -1,16 +1,26 @@
 [DEFAULT]
 skip-if = os == 'android' # Bug 1312791
 support-files =
   mochitest_support_external.js
   mochitest_support_internal.js
   pointerevent_styles.css
   pointerevent_support.js
 
+[test_bug1285128.html]
+[test_bug1293174_implicit_pointer_capture_for_touch_1.html]
+  support-files = bug1293174_implicit_pointer_capture_for_touch_1.html
+[test_bug1293174_implicit_pointer_capture_for_touch_2.html]
+  support-files = bug1293174_implicit_pointer_capture_for_touch_2.html
+[test_bug1303704.html]
+[test_bug1315862.html]
+[test_bug1323158.html]
+[test_empty_file.html]
+  disabled = disabled # Bug 1150091 - Issue with support-files
 [test_pointerevent_attributes_hoverable_pointers-manual.html]
   support-files =
     pointerevent_attributes_hoverable_pointers-manual.html
     ./resources/pointerevent_attributes_hoverable_pointers-iframe.html
 [test_pointerevent_attributes_nohover_pointers-manual.html]
   support-files =
     pointerevent_attributes_nohover_pointers-manual.html
     ./resources/pointerevent_attributes_hoverable_pointers-iframe.html
@@ -113,19 +123,10 @@ support-files =
     pointerevent_touch-action-pan-y-css_touch-manual.html
     pointerevent_touch-action-span-test_touch-manual.html
     pointerevent_touch-action-svg-test_touch-manual.html
     pointerevent_touch-action-table-test_touch-manual.html
     pointerevent_touch-action-pan-down-css_touch-manual.html
     pointerevent_touch-action-pan-left-css_touch-manual.html
     pointerevent_touch-action-pan-right-css_touch-manual.html
     pointerevent_touch-action-pan-up-css_touch-manual.html
-[test_bug1285128.html]
-[test_bug1293174_implicit_pointer_capture_for_touch_1.html]
-  support-files = bug1293174_implicit_pointer_capture_for_touch_1.html
-[test_bug1293174_implicit_pointer_capture_for_touch_2.html]
-  support-files = bug1293174_implicit_pointer_capture_for_touch_2.html
-[test_bug1303704.html]
-[test_bug1323158.html]
+[test_trigger_fullscreen_by_pointer_events.html]
 [test_trigger_popup_by_pointer_events.html]
-[test_empty_file.html]
-  disabled = disabled # Bug 1150091 - Issue with support-files
-[test_bug1315862.html]

new file mode 100644
--- /dev/null
+++ b/dom/events/test/pointerevents/test_trigger_fullscreen_by_pointer_events.html
@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for triggering Fullscreen by pointer events</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script src="/tests/SimpleTest/EventUtils.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<div id="target" style="width: 50px; height: 50px; background: green"></div>
+<script>
+
+SimpleTest.waitForExplicitFinish();
+
+var target = document.getElementById("target");
+target.addEventListener("pointerdown", () => {
+  target.requestFullscreen();
+  target.addEventListener("pointerdown", () => {
+    document.exitFullscreen();
+  }, {once: true});
+}, {once: true});
+
+document.addEventListener("fullscreenchange", () => {
+  if (document.fullscreenElement) {
+    ok(document.fullscreenElement, target, "fullscreenElement should be the div element");
+    // synthesize mouse events to generate pointer events and leave full screen.
+    synthesizeMouseAtCenter(target, { type: "mousedown" });
+    synthesizeMouseAtCenter(target, { type: "mouseup" });
+  } else {
+    SimpleTest.finish();
+  }
+});
+
+function startTest() {
+  // synthesize mouse events to generate pointer events and enter full screen.
+  synthesizeMouseAtCenter(target, { type: "mousedown" });
+  synthesizeMouseAtCenter(target, { type: "mouseup" });
+}
+
+SimpleTest.waitForFocus(() => {
+  SpecialPowers.pushPrefEnv({
+    "set": [
+      ["full-screen-api.unprefix.enabled", true],
+      ["full-screen-api.allow-trusted-requests-only", false],
+      ["dom.w3c_pointer_events.enabled", true]
+    ]
+  }, startTest);
+});
+
+</script>
+</body>
+</html>

--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -18791,20 +18791,22 @@ Maintenance::DirectoryWork()
         }
 
         // Found a database.
         if (databasePaths.IsEmpty()) {
           MOZ_ASSERT(group.IsEmpty());
           MOZ_ASSERT(origin.IsEmpty());
 
           int64_t dummyTimeStamp;
+          bool dummyPersisted;
           nsCString dummySuffix;
           if (NS_WARN_IF(NS_FAILED(
                 quotaManager->GetDirectoryMetadata2(originDir,
                                                     &dummyTimeStamp,
+                                                    &dummyPersisted,
                                                     dummySuffix,
                                                     group,
                                                     origin)))) {
             // Not much we can do here...
             continue;
           }
         }
 

--- a/dom/media/MediaStreamGraph.cpp
+++ b/dom/media/MediaStreamGraph.cpp
@@ -4004,17 +4004,18 @@ MediaStreamGraph::ApplyAudioContextOpera
     }
     void Run() override
     {
       mStream->GraphImpl()->ApplyAudioContextOperationImpl(mStream,
         mStreams, mAudioContextOperation, mPromise);
     }
     void RunDuringShutdown() override
     {
-      MOZ_ASSERT(false, "We should be reviving the graph?");
+      MOZ_ASSERT(mAudioContextOperation == AudioContextOperation::Close,
+                 "We should be reviving the graph?");
     }
 
   private:
     // We don't need strong references here for the same reason ControlMessage
     // doesn't.
     nsTArray<MediaStream*> mStreams;
     AudioContextOperation mAudioContextOperation;
     void* mPromise;

--- a/dom/media/systemservices/MediaParent.cpp
+++ b/dom/media/systemservices/MediaParent.cpp
@@ -102,38 +102,38 @@ class OriginKeyStore : public nsISupport
         }
       }
       mPersistCount = 0;
     }
 
   private:
     void
     PrincipalInfoToString(const ipc::PrincipalInfo& aPrincipalInfo,
-                          nsAutoCString aString)
+                          nsACString& aString)
     {
       switch (aPrincipalInfo.type()) {
         case ipc::PrincipalInfo::TSystemPrincipalInfo:
           aString.Assign("[System Principal]");
           return;
 
         case ipc::PrincipalInfo::TNullPrincipalInfo: {
           const ipc::NullPrincipalInfo& info =
             aPrincipalInfo.get_NullPrincipalInfo();
           aString.Assign(info.spec());
           return;
         }
 
         case ipc::PrincipalInfo::TContentPrincipalInfo: {
           const ipc::ContentPrincipalInfo& info =
             aPrincipalInfo.get_ContentPrincipalInfo();
-          aString.Assign(info.spec());
+          aString.Assign(info.originNoSuffix());
 
           nsAutoCString suffix;
           info.attrs().CreateSuffix(suffix);
-          suffix.Append(suffix);
+          aString.Append(suffix);
           return;
         }
 
         case ipc::PrincipalInfo::TExpandedPrincipalInfo: {
           const ipc::ExpandedPrincipalInfo& info =
             aPrincipalInfo.get_ExpandedPrincipalInfo();
 
           aString.Assign("[Expanded Principal [");

--- a/dom/media/test/mochitest.ini
+++ b/dom/media/test/mochitest.ini
@@ -1091,17 +1091,17 @@ tags = webvtt
 skip-if = toolkit == 'android' # android(bug 1232305)
 tags = webvtt
 [test_trackevent.html]
 skip-if = toolkit == 'android' # android(bug 1232305)
 tags = webvtt
 [test_unseekable.html]
 skip-if = toolkit == 'android' # android(bug 1232305)
 [test_video_to_canvas.html]
-skip-if = android_version == '15' || android_version == '17' || (android_version == '19' && debug) || android_version == '22' # bug 1320418, android(bug 1232305)
+skip-if = toolkit == 'android' # android(bug 1232305), bugs 1320418,1347953,1347954,1348140,1348386
 [test_video_in_audio_element.html]
 skip-if = android_version == '15' || android_version == '17' # bug 1320417, 1326326, android(bug 1232323, bug 1232305)
 [test_videoDocumentTitle.html]
 skip-if = toolkit == 'android' # android(bug 1232305)
 [test_VideoPlaybackQuality.html]
 skip-if = toolkit == 'android' # android(bug 1232305)
 [test_VideoPlaybackQuality_disabled.html]
 skip-if = android_version == '15' || android_version == '17' # android(bug 1232305)

--- a/dom/media/tests/mochitest/test_enumerateDevices.html
+++ b/dom/media/tests/mochitest/test_enumerateDevices.html
@@ -112,18 +112,17 @@ runTest(async () => {
   is(differentOriginDevices.length, devices.length);
   [...sameOriginDevices, ...differentOriginDevices].forEach(d => validateDevice(d));
 
   for (let device of sameOriginDevices) {
     ok(devices.find(d => d.deviceId == device.deviceId),
        "Same origin deviceId for " + device.label + " must match");
   }
   for (let device of differentOriginDevices) {
-    // TODO: s/todo/ok/ once bug 1340163 is fixed.
-    todo(!devices.find(d => d.deviceId == device.deviceId),
+    ok(!devices.find(d => d.deviceId == device.deviceId),
          "Different origin deviceId for " + device.label + " must be different");
   }
 
   // Check the special case of no devices found.
   await pushPrefs(["media.navigator.streams.fake", false],
                   ["media.audio_loopback_dev", "none"],
                   ["media.video_loopback_dev", "none"]);
   devices = await navigator.mediaDevices.enumerateDevices();

--- a/dom/quota/ActorsChild.cpp
+++ b/dom/quota/ActorsChild.cpp
@@ -267,23 +267,28 @@ QuotaRequestChild::Recv__delete__(const 
       HandleResponse(aResponse.get_nsresult());
       break;
 
     case RequestResponse::TInitResponse:
     case RequestResponse::TClearOriginResponse:
     case RequestResponse::TClearDataResponse:
     case RequestResponse::TClearAllResponse:
     case RequestResponse::TResetAllResponse:
+    case RequestResponse::TPersistResponse:
       HandleResponse();
       break;
 
     case RequestResponse::TInitOriginResponse:
       HandleResponse(aResponse.get_InitOriginResponse().created());
       break;
 
+    case RequestResponse::TPersistedResponse:
+      HandleResponse(aResponse.get_PersistedResponse().persisted());
+      break;
+
     default:
       MOZ_CRASH("Unknown response type!");
   }
 
   return IPC_OK();
 }
 
 } // namespace quota

--- a/dom/quota/ActorsParent.cpp
+++ b/dom/quota/ActorsParent.cpp
@@ -1250,16 +1250,73 @@ private:
 
   nsresult
   DoInitOnMainThread() override;
 
   void
   GetResponse(RequestResponse& aResponse) override;
 };
 
+class PersistRequestBase
+  : public QuotaRequestBase
+{
+  const PrincipalInfo mPrincipalInfo;
+
+protected:
+  nsCString mSuffix;
+  nsCString mGroup;
+
+public:
+  bool
+  Init(Quota* aQuota) override;
+
+protected:
+  explicit PersistRequestBase(const PrincipalInfo& aPrincipalInfo);
+
+private:
+  nsresult
+  DoInitOnMainThread() override;
+};
+
+class PersistedOp final
+  : public PersistRequestBase
+{
+  bool mPersisted;
+
+public:
+  explicit PersistedOp(const RequestParams& aParams);
+
+private:
+  ~PersistedOp()
+  { }
+
+  nsresult
+  DoDirectoryWork(QuotaManager* aQuotaManager) override;
+
+  void
+  GetResponse(RequestResponse& aResponse) override;
+};
+
+class PersistOp final
+  : public PersistRequestBase
+{
+public:
+  explicit PersistOp(const RequestParams& aParams);
+
+private:
+  ~PersistOp()
+  { }
+
+  nsresult
+  DoDirectoryWork(QuotaManager* aQuotaManager) override;
+
+  void
+  GetResponse(RequestResponse& aResponse) override;
+};
+
 /*******************************************************************************
  * Helper Functions
  ******************************************************************************/
 
 template <typename T, bool = mozilla::IsUnsigned<T>::value>
 struct IntChecker
 {
   static void
@@ -1847,16 +1904,62 @@ EnsureDirectory(nsIFile* aDirectory, boo
     NS_ENSURE_SUCCESS(rv, rv);
 
     *aCreated = true;
   }
 
   return NS_OK;
 }
 
+nsresult
+EnsureOriginDirectory(nsIFile* aDirectory, bool* aCreated)
+{
+  AssertIsOnIOThread();
+
+  nsresult rv;
+
+#ifndef RELEASE_OR_BETA
+  bool exists;
+  rv = aDirectory->Exists(&exists);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (!exists) {
+    nsString leafName;
+    nsresult rv = aDirectory->GetLeafName(leafName);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    if (!leafName.EqualsLiteral(kChromeOrigin)) {
+      nsCString spec;
+      OriginAttributes attrs;
+      OriginParser::ResultType result =
+        OriginParser::ParseOrigin(NS_ConvertUTF16toUTF8(leafName),
+                                  spec,
+                                  &attrs);
+      if (NS_WARN_IF(result != OriginParser::ValidOrigin)) {
+        QM_WARNING("Preventing creation of a new origin directory which is not "
+                   "supported by our origin parser or is obsolete!");
+
+        return NS_ERROR_FAILURE;
+      }
+    }
+  }
+#endif
+
+  rv = EnsureDirectory(aDirectory, aCreated);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
 enum FileFlag {
   kTruncateFileFlag,
   kUpdateFileFlag,
   kAppendFileFlag
 };
 
 nsresult
 GetOutputStream(nsIFile* aFile,
@@ -2072,16 +2175,17 @@ CreateDirectoryMetadata(nsIFile* aDirect
   }
 
   return NS_OK;
 }
 
 nsresult
 CreateDirectoryMetadata2(nsIFile* aDirectory,
                          int64_t aTimestamp,
+                         bool aPersisted,
                          const nsACString& aSuffix,
                          const nsACString& aGroup,
                          const nsACString& aOrigin)
 {
   AssertIsOnIOThread();
   MOZ_ASSERT(aDirectory);
 
   nsCOMPtr<nsIFile> file;
@@ -2103,18 +2207,17 @@ CreateDirectoryMetadata2(nsIFile* aDirec
 
   MOZ_ASSERT(stream);
 
   rv = stream->Write64(aTimestamp);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  // Reserved for navigator.persist()
-  rv = stream->WriteBoolean(false);
+  rv = stream->WriteBoolean(aPersisted);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   // Reserved data 1
   rv = stream->Write32(0);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
@@ -2164,16 +2267,53 @@ CreateDirectoryMetadata2(nsIFile* aDirec
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   return NS_OK;
 }
 
 nsresult
+CreateDirectoryMetadataFiles(nsIFile* aDirectory,
+                             bool aPersisted,
+                             const nsACString& aSuffix,
+                             const nsACString& aGroup,
+                             const nsACString& aOrigin,
+                             int64_t* aTimestamp)
+{
+  AssertIsOnIOThread();
+
+  int64_t timestamp = PR_Now();
+
+  nsresult rv = CreateDirectoryMetadata(aDirectory,
+                                        timestamp,
+                                        aSuffix,
+                                        aGroup,
+                                        aOrigin);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = CreateDirectoryMetadata2(aDirectory,
+                                timestamp,
+                                aPersisted,
+                                aSuffix,
+                                aGroup,
+                                aOrigin);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (aTimestamp) {
+    *aTimestamp = timestamp;
+  }
+  return NS_OK;
+}
+
+nsresult
 GetBinaryInputStream(nsIFile* aDirectory,
                      const nsAString& aFilename,
                      nsIBinaryInputStream** aStream)
 {
   MOZ_ASSERT(!NS_IsMainThread());
   MOZ_ASSERT(aDirectory);
   MOZ_ASSERT(aStream);
 
@@ -3507,16 +3647,18 @@ QuotaManager::UpdateOriginAccessTime(Per
 
     op->RunImmediately();
   }
 }
 
 void
 QuotaManager::RemoveQuota()
 {
+  AssertIsOnIOThread();
+
   MutexAutoLock lock(mQuotaMutex);
 
   for (auto iter = mGroupInfoPairs.Iter(); !iter.Done(); iter.Next()) {
     nsAutoPtr<GroupInfoPair>& pair = iter.Data();
 
     MOZ_ASSERT(!iter.Key().IsEmpty(), "Empty key!");
     MOZ_ASSERT(pair, "Null pointer!");
 
@@ -3632,16 +3774,50 @@ QuotaManager::GetQuotaObject(Persistence
   NS_ENSURE_SUCCESS(rv, nullptr);
 
   rv = file->InitWithPath(aPath);
   NS_ENSURE_SUCCESS(rv, nullptr);
 
   return GetQuotaObject(aPersistenceType, aGroup, aOrigin, file);
 }
 
+Nullable<bool>
+QuotaManager::OriginPersisted(const nsACString& aGroup,
+                              const nsACString& aOrigin)
+{
+  AssertIsOnIOThread();
+
+  MutexAutoLock lock(mQuotaMutex);
+
+  RefPtr<OriginInfo> originInfo = LockedGetOriginInfo(PERSISTENCE_TYPE_DEFAULT,
+                                                      aGroup,
+                                                      aOrigin);
+  if (originInfo) {
+    return Nullable<bool>(originInfo->LockedPersisted());
+  }
+
+  return Nullable<bool>();
+}
+
+void
+QuotaManager::PersistOrigin(const nsACString& aGroup,
+                            const nsACString& aOrigin)
+{
+  AssertIsOnIOThread();
+
+  MutexAutoLock lock(mQuotaMutex);
+
+  RefPtr<OriginInfo> originInfo = LockedGetOriginInfo(PERSISTENCE_TYPE_DEFAULT,
+                                                      aGroup,
+                                                      aOrigin);
+  if (originInfo && !originInfo->LockedPersisted()) {
+    originInfo->LockedPersist();
+  }
+}
+
 void
 QuotaManager::AbortOperationsForProcess(ContentParentId aContentParentId)
 {
   AssertIsOnOwningThread();
 
   for (RefPtr<Client>& client : mClients) {
     client->AbortOperationsForProcess(aContentParentId);
   }
@@ -3686,23 +3862,25 @@ QuotaManager::RestoreDirectoryMetadata2(
   }
 
   return NS_OK;
 }
 
 nsresult
 QuotaManager::GetDirectoryMetadata2(nsIFile* aDirectory,
                                     int64_t* aTimestamp,
+                                    bool* aPersisted,
                                     nsACString& aSuffix,
                                     nsACString& aGroup,
                                     nsACString& aOrigin)
 {
   MOZ_ASSERT(!NS_IsMainThread());
   MOZ_ASSERT(aDirectory);
   MOZ_ASSERT(aTimestamp);
+  MOZ_ASSERT(aPersisted);
   MOZ_ASSERT(mStorageInitialized);
 
   nsCOMPtr<nsIBinaryInputStream> binaryStream;
   nsresult rv = GetBinaryInputStream(aDirectory,
                                      NS_LITERAL_STRING(METADATA_V2_FILE_NAME),
                                      getter_AddRefs(binaryStream));
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -3745,93 +3923,113 @@ QuotaManager::GetDirectoryMetadata2(nsIF
   // Currently unused (used to be isApp).
   bool dummy;
   rv = binaryStream->ReadBoolean(&dummy);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   *aTimestamp = timestamp;
+  *aPersisted = persisted;
   aSuffix = suffix;
   aGroup = group;
   aOrigin = origin;
   return NS_OK;
 }
 
 nsresult
 QuotaManager::GetDirectoryMetadata2WithRestore(nsIFile* aDirectory,
                                                bool aPersistent,
                                                int64_t* aTimestamp,
+                                               bool* aPersisted,
                                                nsACString& aSuffix,
                                                nsACString& aGroup,
                                                nsACString& aOrigin)
 {
   nsresult rv = GetDirectoryMetadata2(aDirectory,
                                       aTimestamp,
+                                      aPersisted,
                                       aSuffix,
                                       aGroup,
                                       aOrigin);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     rv = RestoreDirectoryMetadata2(aDirectory, aPersistent);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     rv = GetDirectoryMetadata2(aDirectory,
                                aTimestamp,
+                               aPersisted,
                                aSuffix,
                                aGroup,
                                aOrigin);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
   return NS_OK;
 }
 
 nsresult
-QuotaManager::GetDirectoryMetadata2(nsIFile* aDirectory, int64_t* aTimestamp)
+QuotaManager::GetDirectoryMetadata2(nsIFile* aDirectory,
+                                    int64_t* aTimestamp,
+                                    bool* aPersisted)
 {
   AssertIsOnIOThread();
   MOZ_ASSERT(aDirectory);
-  MOZ_ASSERT(aTimestamp);
+  MOZ_ASSERT(aTimestamp || aPersisted);
   MOZ_ASSERT(mStorageInitialized);
 
   nsCOMPtr<nsIBinaryInputStream> binaryStream;
   nsresult rv = GetBinaryInputStream(aDirectory,
                                      NS_LITERAL_STRING(METADATA_V2_FILE_NAME),
                                      getter_AddRefs(binaryStream));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   uint64_t timestamp;
   rv = binaryStream->Read64(&timestamp);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  *aTimestamp = timestamp;
+  bool persisted;
+  if (aPersisted) {
+    rv = binaryStream->ReadBoolean(&persisted);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+
+  if (aTimestamp) {
+    *aTimestamp = timestamp;
+  }
+  if (aPersisted) {
+    *aPersisted = persisted;
+  }
   return NS_OK;
 }
 
 nsresult
 QuotaManager::GetDirectoryMetadata2WithRestore(nsIFile* aDirectory,
                                                bool aPersistent,
-                                               int64_t* aTimestamp)
-{
-  nsresult rv = GetDirectoryMetadata2(aDirectory, aTimestamp);
+                                               int64_t* aTimestamp,
+                                               bool* aPersisted)
+{
+  nsresult rv = GetDirectoryMetadata2(aDirectory, aTimestamp, aPersisted);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     rv = RestoreDirectoryMetadata2(aDirectory, aPersistent);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    rv = GetDirectoryMetadata2(aDirectory, aTimestamp);
+    rv = GetDirectoryMetadata2(aDirectory, aTimestamp, aPersisted);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
   return NS_OK;
 }
 
@@ -3894,31 +4092,33 @@ QuotaManager::InitializeRepository(Persi
         continue;
       }
 
       UNKNOWN_FILE_WARNING(leafName);
       return NS_ERROR_UNEXPECTED;
     }
 
     int64_t timestamp;
+    bool persisted;
     nsCString suffix;
     nsCString group;
     nsCString origin;
     rv = GetDirectoryMetadata2WithRestore(childDirectory,
                                           /* aPersistent */ false,
                                           &timestamp,
+                                          &persisted,
                                           suffix,
                                           group,
                                           origin);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    rv = InitializeOrigin(aPersistenceType, group, origin, timestamp,
-                          /* aPersisted */ false, childDirectory);
+    rv = InitializeOrigin(aPersistenceType, group, origin, timestamp, persisted,
+                          childDirectory);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
@@ -4815,107 +5015,62 @@ QuotaManager::EnsureOriginIsInitializedI
       NS_ENSURE_SUCCESS(rv, rv);
     }
 
     mTemporaryStorageInitialized = true;
 
     CheckTemporaryStorageLimits();
   }
 
+  bool created;
+  rv = EnsureOriginDirectory(directory, &created);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
   int64_t timestamp;
-
-#ifndef RELEASE_OR_BETA
-  bool exists;
-  rv = directory->Exists(&exists);
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
-  }
-
-  if (!exists) {
-    nsString leafName;
-    nsresult rv = directory->GetLeafName(leafName);
-    if (NS_WARN_IF(NS_FAILED(rv))) {
-      return rv;
-    }
-
-    if (!leafName.EqualsLiteral(kChromeOrigin)) {
-      nsCString spec;
-      OriginAttributes attrs;
-      OriginParser::ResultType result =
-        OriginParser::ParseOrigin(NS_ConvertUTF16toUTF8(leafName),
-                                  spec,
-                                  &attrs);
-      if (NS_WARN_IF(result != OriginParser::ValidOrigin)) {
-        QM_WARNING("Preventing creation of a new origin directory which is not "
-                   "supported by our origin parser or is obsolete!");
-
-        return NS_ERROR_FAILURE;
-      }
-    }
-  }
-#endif
-
-  bool created;
-  rv = EnsureDirectory(directory, &created);
-  NS_ENSURE_SUCCESS(rv, rv);
-
   if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
     if (created) {
-      timestamp = PR_Now();
-
-      rv = CreateDirectoryMetadata(directory,
-                                   timestamp,
-                                   aSuffix,
-                                   aGroup,
-                                   aOrigin);
+      rv = CreateDirectoryMetadataFiles(directory,
+                                        /* aPersisted */ true,
+                                        aSuffix,
+                                        aGroup,
+                                        aOrigin,
+                                        &timestamp);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
-
-      rv = CreateDirectoryMetadata2(directory,
-                                    timestamp,
-                                    aSuffix,
-                                    aGroup,
-                                    aOrigin);
-      NS_ENSURE_SUCCESS(rv, rv);
     } else {
       rv = GetDirectoryMetadata2WithRestore(directory,
                                             /* aPersistent */ true,
-                                            &timestamp);
+                                            &timestamp,
+                                            /* aPersisted */ nullptr);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
 
       MOZ_ASSERT(timestamp <= PR_Now());
     }
 
     rv = InitializeOrigin(aPersistenceType, aGroup, aOrigin, timestamp,
                           /* aPersisted */ true, directory);
     NS_ENSURE_SUCCESS(rv, rv);
 
     mInitializedOrigins.AppendElement(aOrigin);
   } else if (created) {
-    timestamp = PR_Now();
-
-    rv = CreateDirectoryMetadata(directory,
-                                 timestamp,
-                                 aSuffix,
-                                 aGroup,
-                                 aOrigin);
+    rv = CreateDirectoryMetadataFiles(directory,
+                                      /* aPersisted */ false,
+                                      aSuffix,
+                                      aGroup,
+                                      aOrigin,
+                                      &timestamp);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    rv = CreateDirectoryMetadata2(directory,
-                                  timestamp,
-                                  aSuffix,
-                                  aGroup,
-                                  aOrigin);
-    NS_ENSURE_SUCCESS(rv, rv);
-
     rv = InitializeOrigin(aPersistenceType, aGroup, aOrigin, timestamp,
                           /* aPersisted */ false, directory);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   directory.forget(aDirectory);
   *aCreated = created;
   return NS_OK;
@@ -5223,16 +5378,35 @@ QuotaManager::LockedRemoveQuotaForOrigin
 
       if (!pair->LockedHasGroupInfos()) {
         mGroupInfoPairs.Remove(aGroup);
       }
     }
   }
 }
 
+already_AddRefed<OriginInfo>
+QuotaManager::LockedGetOriginInfo(PersistenceType aPersistenceType,
+                                  const nsACString& aGroup,
+                                  const nsACString& aOrigin)
+{
+  mQuotaMutex.AssertCurrentThreadOwns();
+  MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_PERSISTENT);
+
+  GroupInfoPair* pair;
+  if (mGroupInfoPairs.Get(aGroup, &pair)) {
+    RefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
+    if (groupInfo) {
+      return groupInfo->LockedGetOriginInfo(aOrigin);
+    }
+  }
+
+  return nullptr;
+}
+
 void
 QuotaManager::CheckTemporaryStorageLimits()
 {
   AssertIsOnIOThread();
 
   nsTArray<OriginInfo*> doomedOriginInfos;
   {
     MutexAutoLock lock(mQuotaMutex);
@@ -6130,16 +6304,24 @@ Quota::AllocPQuotaRequestParent(const Re
     case RequestParams::TClearAllParams:
       actor = new ResetOrClearOp(/* aClear */ true);
       break;
 
     case RequestParams::TResetAllParams:
       actor = new ResetOrClearOp(/* aClear */ false);
       break;
 
+    case RequestParams::TPersistedParams:
+      actor = new PersistedOp(aParams);
+      break;
+
+    case RequestParams::TPersistParams:
+      actor = new PersistOp(aParams);
+      break;
+
     default:
       MOZ_CRASH("Should never get here!");
   }
 
   MOZ_ASSERT(actor);
 
   // Transfer ownership to IPDL.
   return actor.forget().take();
@@ -6812,19 +6994,21 @@ ClearRequestBase::DeleteFiles(QuotaManag
     }
 
     bool persistent = aPersistenceType == PERSISTENCE_TYPE_PERSISTENT;
 
     int64_t timestamp;
     nsCString suffix;
     nsCString group;
     nsCString origin;
+    bool persisted;
     rv = aQuotaManager->GetDirectoryMetadata2WithRestore(file,
                                                          persistent,
                                                          &timestamp,
+                                                         &persisted,
                                                          suffix,
                                                          group,
                                                          origin);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return;
     }
 
     for (uint32_t index = 0; index < 10; index++) {
@@ -6976,16 +7160,245 @@ ClearDataOp::DoInitOnMainThread()
 void
 ClearDataOp::GetResponse(RequestResponse& aResponse)
 {
   AssertIsOnOwningThread();
 
   aResponse = ClearDataResponse();
 }
 
+PersistRequestBase::PersistRequestBase(const PrincipalInfo& aPrincipalInfo)
+  : QuotaRequestBase(/* aExclusive */ false)
+  , mPrincipalInfo(aPrincipalInfo)
+{
+  AssertIsOnOwningThread();
+}
+
+bool
+PersistRequestBase::Init(Quota* aQuota)
+{
+  AssertIsOnOwningThread();
+  MOZ_ASSERT(aQuota);
+
+  if (NS_WARN_IF(!QuotaRequestBase::Init(aQuota))) {
+    return false;
+  }
+
+  mPersistenceType.SetValue(PERSISTENCE_TYPE_DEFAULT);
+
+  mNeedsMainThreadInit = true;
+
+  return true;
+}
+
+nsresult
+PersistRequestBase::DoInitOnMainThread()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(GetState() == State_Initializing);
+  MOZ_ASSERT(mNeedsMainThreadInit);
+
+  nsresult rv;
+  nsCOMPtr<nsIPrincipal> principal =
+    PrincipalInfoToPrincipal(mPrincipalInfo, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Figure out which origin we're dealing with.
+  nsCString origin;
+  rv = QuotaManager::GetInfoFromPrincipal(principal, &mSuffix, &mGroup,
+                                          &origin);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  mOriginScope.SetFromOrigin(origin);
+
+  return NS_OK;
+}
+
+PersistedOp::PersistedOp(const RequestParams& aParams)
+  : PersistRequestBase(aParams.get_PersistedParams().principalInfo())
+  , mPersisted(false)
+{
+  MOZ_ASSERT(aParams.type() == RequestParams::TPersistedParams);
+}
+
+nsresult
+PersistedOp::DoDirectoryWork(QuotaManager* aQuotaManager)
+{
+  AssertIsOnIOThread();
+  MOZ_ASSERT(!mPersistenceType.IsNull());
+  MOZ_ASSERT(mPersistenceType.Value() == PERSISTENCE_TYPE_DEFAULT);
+  MOZ_ASSERT(mOriginScope.IsOrigin());
+
+  PROFILER_LABEL("Quota", "PersistedOp::DoDirectoryWork",
+                 js::ProfileEntry::Category::OTHER);
+
+  Nullable<bool> persisted =
+    aQuotaManager->OriginPersisted(mGroup, mOriginScope.GetOrigin());
+
+  if (!persisted.IsNull()) {
+    mPersisted = persisted.Value();
+    return NS_OK;
+  }
+
+  // If we get here, it means the origin hasn't been initialized yet.
+  // Try to get the persisted flag from directory metadata on disk.
+
+  nsCOMPtr<nsIFile> directory;
+  nsresult rv = aQuotaManager->GetDirectoryForOrigin(mPersistenceType.Value(),
+                                                     mOriginScope.GetOrigin(),
+                                                     getter_AddRefs(directory));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  bool exists;
+  rv = directory->Exists(&exists);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (exists) {
+    // Get the persisted flag.
+    bool persisted;
+    rv =
+      aQuotaManager->GetDirectoryMetadata2WithRestore(directory,
+                                                      /* aPersistent */ false,
+                                                      /* aTimestamp */ nullptr,
+                                                      &persisted);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    mPersisted = persisted;
+  } else {
+    // The directory has not been created yet.
+    mPersisted = false;
+  }
+
+  return NS_OK;
+}
+
+void
+PersistedOp::GetResponse(RequestResponse& aResponse)
+{
+  AssertIsOnOwningThread();
+
+  PersistedResponse persistedResponse;
+  persistedResponse.persisted() = mPersisted;
+
+  aResponse = persistedResponse;
+}
+
+PersistOp::PersistOp(const RequestParams& aParams)
+  : PersistRequestBase(aParams.get_PersistParams().principalInfo())
+{
+  MOZ_ASSERT(aParams.type() == RequestParams::TPersistParams);
+}
+
+nsresult
+PersistOp::DoDirectoryWork(QuotaManager* aQuotaManager)
+{
+  AssertIsOnIOThread();
+  MOZ_ASSERT(!mPersistenceType.IsNull());
+  MOZ_ASSERT(mPersistenceType.Value() == PERSISTENCE_TYPE_DEFAULT);
+  MOZ_ASSERT(mOriginScope.IsOrigin());
+
+  PROFILER_LABEL("Quota", "PersistOp::DoDirectoryWork",
+                 js::ProfileEntry::Category::OTHER);
+
+  // Update directory metadata on disk first.
+  nsCOMPtr<nsIFile> directory;
+  nsresult rv = aQuotaManager->GetDirectoryForOrigin(mPersistenceType.Value(),
+                                                     mOriginScope.GetOrigin(),
+                                                     getter_AddRefs(directory));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  bool created;
+  rv = EnsureOriginDirectory(directory, &created);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (created) {
+    rv = CreateDirectoryMetadataFiles(directory,
+                                      /* aPersisted */ true,
+                                      mSuffix,
+                                      mGroup,
+                                      mOriginScope.GetOrigin(),
+                                      /* aTimestamp */ nullptr);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  } else {
+    // Get the persisted flag (restore the metadata file if necessary).
+    bool persisted;
+    rv =
+      aQuotaManager->GetDirectoryMetadata2WithRestore(directory,
+                                                      /* aPersistent */ false,
+                                                      /* aTimestamp */ nullptr,
+                                                      &persisted);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    if (!persisted) {
+      nsCOMPtr<nsIFile> file;
+      nsresult rv = directory->Clone(getter_AddRefs(file));
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+
+      rv = file->Append(NS_LITERAL_STRING(METADATA_V2_FILE_NAME));
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+
+      nsCOMPtr<nsIBinaryOutputStream> stream;
+      rv = GetBinaryOutputStream(file, kUpdateFileFlag, getter_AddRefs(stream));
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+
+      MOZ_ASSERT(stream);
+
+      // Update origin access time while we are here.
+      rv = stream->Write64(PR_Now());
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+
+      // Set the persisted flag to true.
+      rv = stream->WriteBoolean(true);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+    }
+  }
+
+  // Directory metadata has been successfully created/updated, try to update
+  // OriginInfo too (it's ok if OriginInfo doesn't exist yet).
+  aQuotaManager->PersistOrigin(mGroup, mOriginScope.GetOrigin());
+
+  return NS_OK;
+}
+
+void
+PersistOp::GetResponse(RequestResponse& aResponse)
+{
+  AssertIsOnOwningThread();
+
+  aResponse = PersistResponse();
+}
+
 nsresult
 StorageDirectoryHelper::GetDirectoryMetadata(nsIFile* aDirectory,
                                              int64_t& aTimestamp,
                                              nsACString& aGroup,
                                              nsACString& aOrigin,
                                              Nullable<bool>& aIsApp)
 {
   AssertIsOnIOThread();
@@ -8120,16 +8533,17 @@ UpgradeStorageFrom0_0To1_0Helper::Proces
                                  aOriginProps.mOrigin);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
   rv = CreateDirectoryMetadata2(aOriginProps.mDirectory,
                                 aOriginProps.mTimestamp,
+                                /* aPersisted */ false,
                                 aOriginProps.mSuffix,
                                 aOriginProps.mGroup,
                                 aOriginProps.mOrigin);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   nsString oldName;
@@ -8402,16 +8816,17 @@ UpgradeStorageFrom1_0To2_0Helper::MaybeS
                                         aOriginProps.mGroup,
                                         aOriginProps.mOrigin);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = CreateDirectoryMetadata2(aOriginProps.mDirectory,
                                 aOriginProps.mTimestamp,
+                                /* aPersisted */ false,
                                 aOriginProps.mSuffix,
                                 aOriginProps.mGroup,
                                 aOriginProps.mOrigin);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   nsCOMPtr<nsIFile> newFile;
@@ -8473,16 +8888,17 @@ UpgradeStorageFrom1_0To2_0Helper::Proces
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
   if (aOriginProps.mNeedsRestore2) {
     rv = CreateDirectoryMetadata2(aOriginProps.mDirectory,
                                   aOriginProps.mTimestamp,
+                                  /* aPersisted */ false,
                                   aOriginProps.mSuffix,
                                   aOriginProps.mGroup,
                                   aOriginProps.mOrigin);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
@@ -8515,18 +8931,20 @@ RestoreDirectoryMetadata2Helper::Restore
 }
 
 nsresult
 RestoreDirectoryMetadata2Helper::ProcessOriginDirectory(
                                                 const OriginProps& aOriginProps)
 {
   AssertIsOnIOThread();
 
+  // We don't have any approach to restore aPersisted, so reset it to false.
   nsresult rv = CreateDirectoryMetadata2(aOriginProps.mDirectory,
                                          aOriginProps.mTimestamp,
+                                         /* aPersisted */ false,
                                          aOriginProps.mSuffix,
                                          aOriginProps.mGroup,
                                          aOriginProps.mOrigin);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   return NS_OK;

--- a/dom/quota/PQuota.ipdl
+++ b/dom/quota/PQuota.ipdl
@@ -54,24 +54,36 @@ struct ClearDataParams
 struct ClearAllParams
 {
 };
 
 struct ResetAllParams
 {
 };
 
+struct PersistedParams
+{
+  PrincipalInfo principalInfo;
+};
+
+struct PersistParams
+{
+  PrincipalInfo principalInfo;
+};
+
 union RequestParams
 {
   InitParams;
   InitOriginParams;
   ClearOriginParams;
   ClearDataParams;
   ClearAllParams;
   ResetAllParams;
+  PersistedParams;
+  PersistParams;
 };
 
 protocol PQuota
 {
   manager PBackground;
 
   manages PQuotaRequest;
   manages PQuotaUsageRequest;

--- a/dom/quota/PQuotaRequest.ipdl
+++ b/dom/quota/PQuotaRequest.ipdl
@@ -28,25 +28,36 @@ struct ClearDataResponse
 struct ClearAllResponse
 {
 };
 
 struct ResetAllResponse
 {
 };
 
+struct PersistedResponse
+{
+  bool persisted;
+};
+
+struct PersistResponse
+{
+};
+
 union RequestResponse
 {
   nsresult;
   InitResponse;
   InitOriginResponse;
   ClearOriginResponse;
   ClearDataResponse;
   ClearAllResponse;
   ResetAllResponse;
+  PersistedResponse;
+  PersistResponse;
 };
 
 protocol PQuotaRequest
 {
   manager PQuota;
 
 child:
   async __delete__(RequestResponse response);

--- a/dom/quota/QuotaManager.h
+++ b/dom/quota/QuotaManager.h
@@ -180,51 +180,64 @@ public:
                  nsIFile* aFile);
 
   already_AddRefed<QuotaObject>
   GetQuotaObject(PersistenceType aPersistenceType,
                  const nsACString& aGroup,
                  const nsACString& aOrigin,
                  const nsAString& aPath);
 
+  Nullable<bool>
+  OriginPersisted(const nsACString& aGroup,
+                  const nsACString& aOrigin);
+
+  void
+  PersistOrigin(const nsACString& aGroup,
+                const nsACString& aOrigin);
+
   // Called when a process is being shot down. Aborts any running operations
   // for the given process.
   void
   AbortOperationsForProcess(ContentParentId aContentParentId);
 
   nsresult
   GetDirectoryForOrigin(PersistenceType aPersistenceType,
                         const nsACString& aASCIIOrigin,
                         nsIFile** aDirectory) const;
 
   nsresult
   RestoreDirectoryMetadata2(nsIFile* aDirectory, bool aPersistent);
 
   nsresult
   GetDirectoryMetadata2(nsIFile* aDirectory,
                         int64_t* aTimestamp,
+                        bool* aPersisted,
                         nsACString& aSuffix,
                         nsACString& aGroup,
                         nsACString& aOrigin);
 
   nsresult
   GetDirectoryMetadata2WithRestore(nsIFile* aDirectory,
                                    bool aPersistent,
                                    int64_t* aTimestamp,
+                                   bool* aPersisted,
                                    nsACString& aSuffix,
                                    nsACString& aGroup,
                                    nsACString& aOrigin);
 
   nsresult
-  GetDirectoryMetadata2(nsIFile* aDirectory, int64_t* aTimestamp);
+  GetDirectoryMetadata2(nsIFile* aDirectory,
+                        int64_t* aTimestamp,
+                        bool* aPersisted);
 
   nsresult
   GetDirectoryMetadata2WithRestore(nsIFile* aDirectory,
                                    bool aPersistent,
-                                   int64_t* aTimestamp);
+                                   int64_t* aTimestamp,
+                                   bool* aPersisted);
 
   // This is the main entry point into the QuotaManager API.
   // Any storage API implementation (quota client) that participates in
   // centralized quota and storage handling should call this method to get
   // a directory lock which will protect client's files from being deleted
   // while they are still in use.
   // After a lock is acquired, client is notified via the open listener's
   // method DirectoryLockAcquired. If the lock couldn't be acquired, client
@@ -433,16 +446,21 @@ private:
                                  uint64_t aMinSizeToBeFreed,
                                  nsTArray<RefPtr<DirectoryLockImpl>>& aLocks);
 
   void
   LockedRemoveQuotaForOrigin(PersistenceType aPersistenceType,
                              const nsACString& aGroup,
                              const nsACString& aOrigin);
 
+  already_AddRefed<OriginInfo>
+  LockedGetOriginInfo(PersistenceType aPersistenceType,
+                      const nsACString& aGroup,
+                      const nsACString& aOrigin);
+
   nsresult
   MaybeUpgradeIndexedDBDirectory();
 
   nsresult
   MaybeUpgradePersistentStorageDirectory();
 
   nsresult
   MaybeRemoveOldDirectories();

--- a/dom/quota/QuotaManagerService.cpp
+++ b/dom/quota/QuotaManagerService.cpp
@@ -55,16 +55,35 @@ TestingPrefChangedCallback(const char* a
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!strcmp(aPrefName, kTestingPref));
   MOZ_ASSERT(!aClosure);
 
   gTestingMode = Preferences::GetBool(aPrefName);
 }
 
+nsresult
+CheckedPrincipalToPrincipalInfo(nsIPrincipal* aPrincipal,
+                                PrincipalInfo& aPrincipalInfo)
+{
+  MOZ_ASSERT(aPrincipal);
+
+  nsresult rv = PrincipalToPrincipalInfo(aPrincipal, &aPrincipalInfo);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (aPrincipalInfo.type() != PrincipalInfo::TContentPrincipalInfo &&
+      aPrincipalInfo.type() != PrincipalInfo::TSystemPrincipalInfo) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  return NS_OK;
+}
+
 class AbortOperationsRunnable final
   : public Runnable
 {
   ContentParentId mContentParentId;
 
 public:
   explicit AbortOperationsRunnable(ContentParentId aContentParentId)
     : mContentParentId(aContentParentId)
@@ -535,28 +554,22 @@ QuotaManagerService::InitStoragesForPrin
   if (NS_WARN_IF(!gTestingMode)) {
     return NS_ERROR_UNEXPECTED;
   }
 
   RefPtr<Request> request = new Request();
 
   InitOriginParams params;
 
-  PrincipalInfo& principalInfo = params.principalInfo();
-
-  nsresult rv = PrincipalToPrincipalInfo(aPrincipal, &principalInfo);
+  nsresult rv = CheckedPrincipalToPrincipalInfo(aPrincipal,
+                                                params.principalInfo());
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  if (principalInfo.type() != PrincipalInfo::TContentPrincipalInfo &&
-      principalInfo.type() != PrincipalInfo::TSystemPrincipalInfo) {
-    return NS_ERROR_UNEXPECTED;
-  }
-
   Nullable<PersistenceType> persistenceType;
   rv = NullablePersistenceTypeFromText(aPersistenceType, &persistenceType);
   if (NS_WARN_IF(NS_FAILED(rv)) || persistenceType.IsNull()) {
     return NS_ERROR_INVALID_ARG;
   }
 
   params.persistenceType() = persistenceType.Value();
 
@@ -580,27 +593,22 @@ QuotaManagerService::GetUsageForPrincipa
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aPrincipal);
   MOZ_ASSERT(aCallback);
 
   RefPtr<UsageRequest> request = new UsageRequest(aPrincipal, aCallback);
 
   UsageParams params;
 
-  PrincipalInfo& principalInfo = params.principalInfo();
-  nsresult rv = PrincipalToPrincipalInfo(aPrincipal, &principalInfo);
+  nsresult rv = CheckedPrincipalToPrincipalInfo(aPrincipal,
+                                                params.principalInfo());
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  if (principalInfo.type() != PrincipalInfo::TContentPrincipalInfo &&
-      principalInfo.type() != PrincipalInfo::TSystemPrincipalInfo) {
-    return NS_ERROR_UNEXPECTED;
-  }
-
   params.getGroupUsage() = aGetGroupUsage;
 
   nsAutoPtr<PendingRequestInfo> info(new UsageRequestInfo(request, params));
 
   rv = InitiateRequest(info);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -650,28 +658,22 @@ QuotaManagerService::ClearStoragesForPri
     // aClearAll flag is set.
     return NS_ERROR_INVALID_ARG;
   }
 
   RefPtr<Request> request = new Request(aPrincipal);
 
   ClearOriginParams params;
 
-  PrincipalInfo& principalInfo = params.principalInfo();
-
-  nsresult rv = PrincipalToPrincipalInfo(aPrincipal, &principalInfo);
+  nsresult rv = CheckedPrincipalToPrincipalInfo(aPrincipal,
+                                                params.principalInfo());
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  if (principalInfo.type() != PrincipalInfo::TContentPrincipalInfo &&
-      principalInfo.type() != PrincipalInfo::TSystemPrincipalInfo) {
-    return NS_ERROR_UNEXPECTED;
-  }
-
   Nullable<PersistenceType> persistenceType;
   rv = NullablePersistenceTypeFromText(aPersistenceType, &persistenceType);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return NS_ERROR_INVALID_ARG;
   }
 
   if (persistenceType.IsNull()) {
     params.persistenceTypeIsExplicit() = false;
@@ -713,16 +715,74 @@ QuotaManagerService::Reset(nsIQuotaReque
     return rv;
   }
 
   request.forget(_retval);
   return NS_OK;
 }
 
 NS_IMETHODIMP
+QuotaManagerService::Persisted(nsIPrincipal* aPrincipal,
+                               nsIQuotaRequest** _retval)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aPrincipal);
+  MOZ_ASSERT(_retval);
+
+  RefPtr<Request> request = new Request(aPrincipal);
+
+  PersistedParams params;
+
+  nsresult rv = CheckedPrincipalToPrincipalInfo(aPrincipal,
+                                                params.principalInfo());
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  nsAutoPtr<PendingRequestInfo> info(new RequestInfo(request, params));
+
+  rv = InitiateRequest(info);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  request.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+QuotaManagerService::Persist(nsIPrincipal* aPrincipal,
+                             nsIQuotaRequest** _retval)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aPrincipal);
+  MOZ_ASSERT(_retval);
+
+  RefPtr<Request> request = new Request(aPrincipal);
+
+  PersistParams params;
+
+  nsresult rv = CheckedPrincipalToPrincipalInfo(aPrincipal,
+                                                params.principalInfo());
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  nsAutoPtr<PendingRequestInfo> info(new RequestInfo(request, params));
+
+  rv = InitiateRequest(info);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  request.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
 QuotaManagerService::Observe(nsISupports* aSubject,
                              const char* aTopic,
                              const char16_t* aData)
 {
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!strcmp(aTopic, PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID)) {

--- a/dom/quota/nsIQuotaManagerService.idl
+++ b/dom/quota/nsIQuotaManagerService.idl
@@ -95,9 +95,27 @@ interface nsIQuotaManagerService : nsISu
    * overriding the temp storage limit has changed.
    * Be carefull, this invalidates all live storages!
    *
    * If the dom.quotaManager.testing preference is not true the call will be
    * a no-op.
    */
   [must_use] nsIQuotaRequest
   reset();
+
+  /**
+   * Check if given origin is persisted.
+   *
+   * @param aPrincipal
+   *        A principal for the origin which we want to check.
+   */
+  [must_use] nsIQuotaRequest
+  persisted(in nsIPrincipal aPrincipal);
+
+  /**
+   * Persist given origin.
+   *
+   * @param aPrincipal
+   *        A principal for the origin which we want to persist.
+   */
+  [must_use] nsIQuotaRequest
+  persist(in nsIPrincipal aPrincipal);
 };

--- a/dom/quota/test/unit/head.js
+++ b/dom/quota/test/unit/head.js
@@ -1,16 +1,17 @@
 /**
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 const { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components;
 
 const NS_OK = Cr.NS_OK;
+const NS_ERROR_FAILURE = Cr.NS_ERROR_FAILURE;
 const NS_ERROR_UNEXPECTED = Cr.NS_ERROR_UNEXPECTED;
 
 function is(a, b, msg)
 {
   do_check_eq(a, b, Components.stack.caller);
 }
 
 function ok(cond, msg)
@@ -141,16 +142,30 @@ function clearChromeOrigin(callback)
 function reset(callback)
 {
   let request = SpecialPowers._getQuotaManager().reset();
   request.callback = callback;
 
   return request;
 }
 
+function persist(principal, callback) {
+  let request = SpecialPowers._getQuotaManager().persist(principal);
+  request.callback = callback;
+
+  return request;
+}
+
+function persisted(principal, callback) {
+  let request = SpecialPowers._getQuotaManager().persisted(principal);
+  request.callback = callback;
+
+  return request;
+}
+
 function installPackage(packageName)
 {
   let directoryService = Cc["@mozilla.org/file/directory_service;1"]
                          .getService(Ci.nsIProperties);
 
   let currentDir = directoryService.get("CurWorkD", Ci.nsIFile);
 
   let packageFile = currentDir.clone();
@@ -232,16 +247,25 @@ function compareBuffers(buffer1, buffer2
   for (let i = 0; i < buffer1.byteLength; i++) {
     if (view1[i] != view2[i]) {
       return false;
     }
   }
   return true;
 }
 
+function getPersistedFromMetadata(readBuffer)
+{
+  const persistedPosition = 8; // Persisted state is stored in the 9th byte
+  let view =
+    readBuffer instanceof Uint8Array ? readBuffer : new Uint8Array(readBuffer);
+
+  return !!view[persistedPosition];
+}
+
 function grabUsageAndContinueHandler(request)
 {
   testGenerator.next(request.usage);
 }
 
 function getUsage(usageHandler)
 {
   let principal = Cc["@mozilla.org/systemprincipal;1"]

new file mode 100644
--- /dev/null
+++ b/dom/quota/test/unit/test_persist.js
@@ -0,0 +1,150 @@
+/**
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+var testGenerator = testSteps();
+
+function* testSteps()
+{
+  const origins = [
+    {
+      url: "http://default.test.persist",
+      path: "storage/default/http+++default.test.persist",
+      persistence: "default"
+    },
+
+    {
+      url: "ftp://ftp.invalid.origin",
+      path: "storage/default/ftp+++ftp.invalid.origin",
+      persistence: "default"
+    },
+  ];
+
+  const metadataFileName = ".metadata-v2";
+
+  let principal = getPrincipal(origins[0].url);
+
+  info("Persisting an uninitialized origin");
+
+  // Origin directory doesn't exist yet, so only check the result for
+  // persisted().
+  let request = persisted(principal, continueToNextStepSync);
+  yield undefined;
+
+  ok(request.resultCode === NS_OK, "Persisted() succeeded");
+  ok(!request.result, "The origin is not persisted");
+
+  info("Verifying persist() does update the metadata");
+
+  request = persist(principal, continueToNextStepSync);
+  yield undefined;
+
+  ok(request.resultCode === NS_OK, "Persist() succeeded");
+
+  let originDir = getRelativeFile(origins[0].path);
+  let exists = originDir.exists();
+  ok(exists, "Origin directory does exist");
+
+  info("Reading out contents of metadata file");
+
+  let metadataFile = originDir.clone();
+  metadataFile.append(metadataFileName);
+
+  File.createFromNsIFile(metadataFile).then(grabArgAndContinueHandler);
+  let file = yield undefined;
+
+  let fileReader = new FileReader();
+  fileReader.onload = continueToNextStepSync;
+  fileReader.readAsArrayBuffer(file);
+  yield undefined;
+
+  let originPersisted = getPersistedFromMetadata(fileReader.result);
+  ok(originPersisted, "The origin is persisted");
+
+  info("Verifying persisted()");
+
+  request = persisted(principal, continueToNextStepSync);
+  yield undefined;
+
+  ok(request.resultCode === NS_OK, "Persisted() succeeded");
+  ok(request.result === originPersisted, "Persisted() concurs with metadata");
+
+  info("Clearing the origin");
+
+  // Clear the origin since we'll test the same directory again under different
+  // circumstances.
+  clearOrigin(principal, origins[0].persistence, continueToNextStepSync);
+  yield undefined;
+
+  info("Persisting an already initialized origin");
+
+  initOrigin(principal, origins[0].persistence, continueToNextStepSync);
+  yield undefined;
+
+  info("Reading out contents of metadata file");
+
+  fileReader = new FileReader();
+  fileReader.onload = continueToNextStepSync;
+  fileReader.readAsArrayBuffer(file);
+  yield undefined;
+
+  originPersisted = getPersistedFromMetadata(fileReader.result);
+  ok(!originPersisted, "The origin isn't persisted after clearing");
+
+  info("Verifying persisted()");
+
+  request = persisted(principal, continueToNextStepSync);
+  yield undefined;
+
+  ok(request.resultCode === NS_OK, "Persisted() succeeded");
+  ok(request.result === originPersisted, "Persisted() concurs with metadata");
+
+  info("Verifying persist() does update the metadata");
+
+  request = persist(principal, continueToNextStepSync);
+  yield undefined;
+
+  ok(request.resultCode === NS_OK, "Persist() succeeded");
+
+  info("Reading out contents of metadata file");
+
+  fileReader = new FileReader();
+  fileReader.onload = continueToNextStepSync;
+  fileReader.readAsArrayBuffer(file);
+  yield undefined;
+
+  originPersisted = getPersistedFromMetadata(fileReader.result);
+  ok(originPersisted, "The origin is persisted");
+
+  info("Verifying persisted()");
+
+  request = persisted(principal, continueToNextStepSync);
+  yield undefined;
+
+  ok(request.resultCode === NS_OK, "Persisted() succeeded");
+  ok(request.result === originPersisted, "Persisted() concurs with metadata");
+
+  info("Persisting an invalid origin");
+
+  let invalidPrincipal = getPrincipal(origins[1].url);
+
+  request = persist(invalidPrincipal, continueToNextStepSync);
+  yield undefined;
+
+  ok(request.resultCode === NS_ERROR_FAILURE,
+     "Persist() failed because of the invalid origin");
+
+  originDir = getRelativeFile(origins[1].path);
+  exists = originDir.exists();
+  ok(!exists, "Directory for invalid origin doesn't exist");
+
+  request = persisted(invalidPrincipal, continueToNextStepSync);
+  yield undefined;
+
+  ok(request.resultCode === NS_OK, "Persisted() succeeded");
+  ok(!request.result,
+     "The origin isn't persisted since the operation failed");
+
+  finishTest();
+}

--- a/dom/quota/test/unit/xpcshell.ini
+++ b/dom/quota/test/unit/xpcshell.ini
@@ -17,12 +17,13 @@ support-files =
   tempMetadataCleanup_profile.zip
 
 [test_basics.js]
 [test_defaultStorageUpgrade.js]
 [test_idbSubdirUpgrade.js]
 [test_morgueCleanup.js]
 [test_obsoleteOriginAttributesUpgrade.js]
 [test_originAttributesUpgrade.js]
+[test_persist.js]
 [test_removeAppsUpgrade.js]
 [test_storagePersistentUpgrade.js]
 [test_tempMetadataCleanup.js]
 [test_unknownFiles.js]

--- a/dom/workers/ServiceWorkerEvents.cpp
+++ b/dom/workers/ServiceWorkerEvents.cpp
@@ -653,17 +653,17 @@ RespondWithHandler::ResolvedCallback(JSC
   nsCOMPtr<nsIInputStream> body;
   ir->GetUnfilteredBody(getter_AddRefs(body));
   // Errors and redirects may not have a body.
   if (body) {
     response->SetBodyUsed();
 
     nsCOMPtr<nsIOutputStream> responseBody;
     rv = mInterceptedChannel->GetResponseBody(getter_AddRefs(responseBody));
-    if (NS_WARN_IF(NS_FAILED(rv))) {
+    if (NS_WARN_IF(NS_FAILED(rv)) || !responseBody) {
       return;
     }
 
     const uint32_t kCopySegmentSize = 4096;
 
     // Depending on how the Response passed to .respondWith() was created, we may
     // get a non-buffered input stream.  In addition, in some configurations the
     // destination channel's output stream can be unbuffered.  We wrap the output

--- a/dom/workers/ServiceWorkerPrivate.cpp
+++ b/dom/workers/ServiceWorkerPrivate.cpp
@@ -1575,17 +1575,18 @@ private:
     }
 
     event->PostInit(mInterceptedChannel, mRegistration, mScriptSpec);
     event->SetTrusted(true);
 
     nsresult rv2 =
       DispatchExtendableEventOnWorkerScope(aCx, aWorkerPrivate->GlobalScope(),
                                            event, nullptr);
-    if (NS_WARN_IF(NS_FAILED(rv2)) || !event->WaitToRespond()) {
+    if ((NS_WARN_IF(NS_FAILED(rv2)) && rv2 != NS_ERROR_XPC_JS_THREW_EXCEPTION) ||
+        !event->WaitToRespond()) {
       nsCOMPtr<nsIRunnable> runnable;
       MOZ_ASSERT(!aWorkerPrivate->UsesSystemPrincipal(),
                  "We don't support system-principal serviceworkers");
       if (event->DefaultPrevented(CallerType::NonSystem)) {
         runnable = new CancelChannelRunnable(mInterceptedChannel,
                                              mRegistration,
                                              NS_ERROR_INTERCEPTION_FAILED);
       } else {

--- a/dom/workers/ServiceWorkerRegistrar.cpp
+++ b/dom/workers/ServiceWorkerRegistrar.cpp
@@ -349,17 +349,17 @@ ServiceWorkerRegistrar::ReadData()
       OriginAttributes attrs;
       if (!attrs.PopulateFromSuffix(suffix)) {
         return NS_ERROR_INVALID_ARG;
       }
 
       GET_LINE(entry->scope());
 
       entry->principal() =
-        mozilla::ipc::ContentPrincipalInfo(attrs, entry->scope());
+        mozilla::ipc::ContentPrincipalInfo(attrs, void_t(), entry->scope());
 
       GET_LINE(entry->currentWorkerURL());
 
       nsAutoCString fetchFlag;
       GET_LINE(fetchFlag);
       if (!fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE) &&
           !fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_FALSE)) {
         return NS_ERROR_INVALID_ARG;
@@ -390,17 +390,17 @@ ServiceWorkerRegistrar::ReadData()
       OriginAttributes attrs;
       if (!attrs.PopulateFromSuffix(suffix)) {
         return NS_ERROR_INVALID_ARG;
       }
 
       GET_LINE(entry->scope());
 
       entry->principal() =
-        mozilla::ipc::ContentPrincipalInfo(attrs, entry->scope());
+        mozilla::ipc::ContentPrincipalInfo(attrs, void_t(), entry->scope());
 
       GET_LINE(entry->currentWorkerURL());
 
       nsAutoCString fetchFlag;
       GET_LINE(fetchFlag);
       if (!fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE) &&
           !fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_FALSE)) {
         return NS_ERROR_INVALID_ARG;
@@ -423,17 +423,17 @@ ServiceWorkerRegistrar::ReadData()
       OriginAttributes attrs;
       if (!attrs.PopulateFromSuffix(suffix)) {
         return NS_ERROR_INVALID_ARG;
       }
 
       GET_LINE(entry->scope());
 
       entry->principal() =
-        mozilla::ipc::ContentPrincipalInfo(attrs, entry->scope());
+        mozilla::ipc::ContentPrincipalInfo(attrs, void_t(), entry->scope());
 
       GET_LINE(entry->currentWorkerURL());
 
       // default handlesFetch flag to Enabled
       entry->currentWorkerHandlesFetch() = true;
 
       nsAutoCString cacheName;
       GET_LINE(cacheName);
@@ -453,17 +453,17 @@ ServiceWorkerRegistrar::ReadData()
       }
 
       // principal spec is no longer used; we use scope directly instead
       GET_LINE(unused);
 
       GET_LINE(entry->scope());
 
       entry->principal() =
-        mozilla::ipc::ContentPrincipalInfo(attrs, entry->scope());
+        mozilla::ipc::ContentPrincipalInfo(attrs, void_t(), entry->scope());
 
       GET_LINE(entry->currentWorkerURL());
 
       // default handlesFetch flag to Enabled
       entry->currentWorkerHandlesFetch() = true;
 
       nsAutoCString cacheName;
       GET_LINE(cacheName);
@@ -483,17 +483,17 @@ ServiceWorkerRegistrar::ReadData()
       }
 
       // principal spec is no longer used; we use scope directly instead
       GET_LINE(unused);
 
       GET_LINE(entry->scope());
 
       entry->principal() =
-        mozilla::ipc::ContentPrincipalInfo(attrs, entry->scope());
+        mozilla::ipc::ContentPrincipalInfo(attrs, void_t(), entry->scope());
 
       // scriptSpec is no more used in latest version.
       GET_LINE(unused);
 
       GET_LINE(entry->currentWorkerURL());
 
       // default handlesFetch flag to Enabled
       entry->currentWorkerHandlesFetch() = true;

--- a/dom/workers/test/gtest/TestReadWrite.cpp
+++ b/dom/workers/test/gtest/TestReadWrite.cpp
@@ -238,17 +238,18 @@ TEST(ServiceWorkerRegistrar, TestWriteDa
       reg.currentWorkerHandlesFetch() = true;
       reg.cacheName() =
         NS_ConvertUTF8toUTF16(nsPrintfCString("cacheName write %d", i));
       reg.loadFlags() = nsIRequest::VALIDATE_ALWAYS;
 
       nsAutoCString spec;
       spec.AppendPrintf("spec write %d", i);
       reg.principal() =
-        mozilla::ipc::ContentPrincipalInfo(mozilla::OriginAttributes(i, i % 2), spec);
+        mozilla::ipc::ContentPrincipalInfo(mozilla::OriginAttributes(i, i % 2),
+                                           mozilla::void_t(), spec);
 
       swr->TestRegisterServiceWorker(reg);
     }
 
     nsresult rv = swr->TestWriteData();
     ASSERT_EQ(NS_OK, rv) << "WriteData() should not fail";
   }
 
@@ -592,17 +593,18 @@ TEST(ServiceWorkerRegistrar, TestDedupeW
       reg.currentWorkerHandlesFetch() = true;
       reg.cacheName() =
         NS_ConvertUTF8toUTF16(nsPrintfCString("cacheName write %d", i));
       reg.loadFlags() = nsIRequest::VALIDATE_ALWAYS;
 
       nsAutoCString spec;
       spec.AppendPrintf("spec write dedupe/%d", i);
       reg.principal() =
-        mozilla::ipc::ContentPrincipalInfo(mozilla::OriginAttributes(0, false), spec);
+        mozilla::ipc::ContentPrincipalInfo(mozilla::OriginAttributes(0, false),
+                                           mozilla::void_t(), spec);
 
       swr->TestRegisterServiceWorker(reg);
     }
 
     nsresult rv = swr->TestWriteData();
     ASSERT_EQ(NS_OK, rv) << "WriteData() should not fail";
   }
 

--- a/gfx/angle/src/compiler/translator/glslang_lex.cpp
+++ b/gfx/angle/src/compiler/translator/glslang_lex.cpp
@@ -2333,17 +2333,17 @@ static int yy_get_next_buffer (yyscan_t 
 	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
 		/* don't do the read, it's not guaranteed to return an EOF,
 		 * just force an EOF
 		 */
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
 
 	else
 		{
-			yy_size_t num_to_read =
+			int num_to_read =
 			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
 		while ( num_to_read <= 0 )
 			{ /* Not enough room in the buffer - grow it. */
 
 			/* just a shorter name for the current buffer */
 			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
 

--- a/gfx/layers/apz/src/AsyncPanZoomController.cpp
+++ b/gfx/layers/apz/src/AsyncPanZoomController.cpp
@@ -1268,16 +1268,19 @@ nsEventStatus AsyncPanZoomController::On
     // what our final state is to avoid notification churn.
     StateChangeNotificationBlocker blocker(this);
     SetState(NOTHING);
 
     APZC_LOG("%p starting a fling animation if %f >= %f\n", this,
         flingVelocity.Length().value, gfxPrefs::APZFlingMinVelocityThreshold());
 
     if (flingVelocity.Length() < gfxPrefs::APZFlingMinVelocityThreshold()) {
+      // Relieve overscroll now if needed, since we will not transition to a fling
+      // animation and then an overscroll animation, and relieve it then.
+      GetCurrentTouchBlock()->GetOverscrollHandoffChain()->SnapBackOverscrolledApzc(this);
       return nsEventStatus_eConsumeNoDefault;
     }
 
     // Make a local copy of the tree manager pointer and check that it's not
     // null before calling DispatchFling(). This is necessary because Destroy(),
     // which nulls out mTreeManager, could be called concurrently.
     if (APZCTreeManager* treeManagerLocal = GetApzcTreeManager()) {
       FlingHandoffState handoffState{flingVelocity,