--- a/b2g/installer/package-manifest.in
+++ b/b2g/installer/package-manifest.in
@@ -291,16 +291,17 @@
 @BINPATH@/components/shellservice.xpt
 @BINPATH@/components/shistory.xpt
 @BINPATH@/components/spellchecker.xpt
 @BINPATH@/components/storage.xpt
 @BINPATH@/components/telemetry.xpt
 @BINPATH@/components/toolkit_finalizationwitness.xpt
 @BINPATH@/components/toolkit_formautofill.xpt
 @BINPATH@/components/toolkit_osfile.xpt
+@BINPATH@/components/toolkit_xulstore.xpt
 @BINPATH@/components/toolkitprofile.xpt
 #ifdef MOZ_ENABLE_XREMOTE
 @BINPATH@/components/toolkitremote.xpt
 #endif
 @BINPATH@/components/txtsvc.xpt
 @BINPATH@/components/txmgr.xpt
 #ifdef MOZ_USE_NATIVE_UCONV
 @BINPATH@/components/ucnative.xpt
@@ -535,16 +536,18 @@
 @BINPATH@/components/HealthReportService.js
 #endif
 #ifdef MOZ_CAPTIVEDETECT
 @BINPATH@/components/CaptivePortalDetectComponents.manifest
 @BINPATH@/components/captivedetect.js
 #endif
 @BINPATH@/components/TelemetryStartup.js
 @BINPATH@/components/TelemetryStartup.manifest
+@BINPATH@/components/XULStore.js
+@BINPATH@/components/XULStore.manifest
 @BINPATH@/components/Webapps.js
 @BINPATH@/components/Webapps.manifest
 @BINPATH@/components/AppsService.js
 @BINPATH@/components/AppsService.manifest
 @BINPATH@/components/Push.js
 @BINPATH@/components/Push.manifest
 @BINPATH@/components/PushServiceLauncher.js
 
@@ -687,19 +690,16 @@
 @BINPATH@/res/text_caret_tilt_left.png
 @BINPATH@/res/text_caret_tilt_left@1.5x.png
 @BINPATH@/res/text_caret_tilt_left@2.25x.png
 @BINPATH@/res/text_caret_tilt_left@2x.png
 @BINPATH@/res/text_caret_tilt_right.png
 @BINPATH@/res/text_caret_tilt_right@1.5x.png
 @BINPATH@/res/text_caret_tilt_right@2.25x.png
 @BINPATH@/res/text_caret_tilt_right@2x.png
-@BINPATH@/res/text_selection_handle.png
-@BINPATH@/res/text_selection_handle@1.5.png
-@BINPATH@/res/text_selection_handle@2.png
 @BINPATH@/res/grabber.gif
 #ifdef XP_MACOSX
 @BINPATH@/res/cursors/*
 #endif
 @BINPATH@/res/fonts/*
 @BINPATH@/res/dtd/*
 @BINPATH@/res/html/*
 @BINPATH@/res/langGroups.properties

--- a/browser/base/content/browser-fullScreen.js
+++ b/browser/base/content/browser-fullScreen.js
@@ -4,16 +4,31 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 var FullScreen = {
   _XULNS: "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
   get _fullScrToggler() {
     delete this._fullScrToggler;
     return this._fullScrToggler = document.getElementById("fullscr-toggler");
   },
+
+  init: function() {
+    // called when we go into full screen, even if initiated by a web page script
+    window.addEventListener("fullscreen", this, true);
+    window.messageManager.addMessageListener("MozEnteredDomFullscreen", this);
+
+    if (window.fullScreen)
+      this.toggle();
+  },
+
+  uninit: function() {
+    window.messageManager.removeMessageListener("MozEnteredDomFullscreen", this);
+    this.cleanup();
+  },
+
   toggle: function (event) {
     var enterFS = window.fullScreen;
 
     // We get the fullscreen event _before_ the window transitions into or out of FS mode.
     if (event && event.type == "fullscreen")
       enterFS = !enterFS;
 
     // Toggle the View:FullScreen command, which controls elements like the
@@ -90,38 +105,56 @@ var FullScreen = {
   exitDomFullScreen : function() {
     document.mozCancelFullScreen();
   },
 
   handleEvent: function (event) {
     switch (event.type) {
       case "activate":
         if (document.mozFullScreen) {
-          this.showWarning(this.fullscreenDoc);
+          this.showWarning(this.fullscreenOrigin);
         }
         break;
+      case "fullscreen":
+        this.toggle(event);
+        break;
       case "transitionend":
         if (event.propertyName == "opacity")
           this.cancelWarning();
         break;
     }
   },
 
-  enterDomFullscreen : function(event) {
+  receiveMessage: function(aMessage) {
+    if (aMessage.name == "MozEnteredDomFullscreen") {
+      // If we're a multiprocess browser, then the request to enter fullscreen
+      // did not bubble up to the root browser document - it stopped at the root
+      // of the content document. That means we have to kick off the switch to
+      // fullscreen here at the operating system level in the parent process
+      // ourselves.
+      let data = aMessage.data;
+      let browser = aMessage.target;
+      if (gMultiProcessBrowser && browser.getAttribute("remote") == "true") {
+        let windowUtils = window.QueryInterface(Ci.nsIInterfaceRequestor)
+                                .getInterface(Ci.nsIDOMWindowUtils);
+        windowUtils.remoteFrameFullscreenChanged(browser, data.origin);
+      }
+      this.enterDomFullscreen(browser, data.origin);
+    }
+  },
+
+  enterDomFullscreen : function(aBrowser, aOrigin) {
     if (!document.mozFullScreen)
       return;
 
-    // However, if we receive a "MozEnteredDomFullScreen" event for a document
-    // which is not a subdocument of a currently active (ie. visible) browser
-    // or iframe, we know that we've switched to a different frame since the
-    // request to enter full-screen was made, so we should exit full-screen
-    // since the "full-screen document" isn't acutally visible.
-    if (!event.target.defaultView.QueryInterface(Ci.nsIInterfaceRequestor)
-                                 .getInterface(Ci.nsIWebNavigation)
-                                 .QueryInterface(Ci.nsIDocShell).isActive) {
+    // If we've received a fullscreen notification, we have to ensure that the
+    // element that's requesting fullscreen belongs to the browser that's currently
+    // active. If not, we exit fullscreen since the "full-screen document" isn't
+    // actually visible now.
+    if (gBrowser.selectedBrowser != aBrowser) {
       document.mozCancelFullScreen();
       return;
     }
 
     let focusManager = Cc["@mozilla.org/focus-manager;1"].getService(Ci.nsIFocusManager);
     if (focusManager.activeWindow != window) {
       // The top-level window has lost focus since the request to enter
       // full-screen was made. Cancel full-screen.
@@ -131,17 +164,17 @@ var FullScreen = {
 
     // Ensure the sidebar is hidden.
     if (!document.getElementById("sidebar-box").hidden)
       toggleSidebar();
 
     if (gFindBarInitialized)
       gFindBar.close();
 
-    this.showWarning(event.target);
+    this.showWarning(aOrigin);
 
     // Exit DOM full-screen mode upon open, close, or change tab.
     gBrowser.tabContainer.addEventListener("TabOpen", this.exitDomFullScreen);
     gBrowser.tabContainer.addEventListener("TabClose", this.exitDomFullScreen);
     gBrowser.tabContainer.addEventListener("TabSelect", this.exitDomFullScreen);
 
     // Add listener to detect when the fullscreen window is re-focused.
     // If a fullscreen window loses focus, we show a warning when the
@@ -173,17 +206,19 @@ var FullScreen = {
       this._fullScrToggler.removeEventListener("mouseover", this._expandCallback, false);
       this._fullScrToggler.removeEventListener("dragenter", this._expandCallback, false);
       this.cancelWarning();
       gBrowser.tabContainer.removeEventListener("TabOpen", this.exitDomFullScreen);
       gBrowser.tabContainer.removeEventListener("TabClose", this.exitDomFullScreen);
       gBrowser.tabContainer.removeEventListener("TabSelect", this.exitDomFullScreen);
       if (!this.useLionFullScreen)
         window.removeEventListener("activate", this);
-      this.fullscreenDoc = null;
+
+      window.messageManager
+            .broadcastAsyncMessage("DOMFullscreen:Cleanup");
     }
   },
 
   observe: function(aSubject, aTopic, aData)
   {
     if (aData == "browser.fullscreen.autohide") {
       if (gPrefService.getBoolPref("browser.fullscreen.autohide")) {
         gBrowser.mPanelContainer.addEventListener("mousemove",
@@ -332,17 +367,17 @@ var FullScreen = {
     this.warningBox = null;
   },
 
   setFullscreenAllowed: function(isApproved) {
     // The "remember decision" checkbox is hidden when showing for documents that
     // the permission manager can't handle (documents with URIs without a host).
     // We simply require those to be approved every time instead.
     let rememberCheckbox = document.getElementById("full-screen-remember-decision");
-    let uri = this.fullscreenDoc.nodePrincipal.URI;
+    let uri = BrowserUtils.makeURI(this.fullscreenOrigin);
     if (!rememberCheckbox.hidden) {
       if (rememberCheckbox.checked)
         Services.perms.add(uri,
                            "fullscreen",
                            isApproved ? Services.perms.ALLOW_ACTION : Services.perms.DENY_ACTION,
                            Services.perms.EXPIRE_NEVER);
       else if (isApproved) {
         // The user has only temporarily approved fullscren for this fullscreen
@@ -365,37 +400,39 @@ var FullScreen = {
         document.addEventListener("mozfullscreenchange", onFullscreenchange);
       }
     }
     if (this.warningBox)
       this.warningBox.setAttribute("fade-warning-out", "true");
     // If the document has been granted fullscreen, notify Gecko so it can resume
     // any pending pointer lock requests, otherwise exit fullscreen; the user denied
     // the fullscreen request.
-    if (isApproved)
-      Services.obs.notifyObservers(this.fullscreenDoc, "fullscreen-approved", "");
-    else
+    if (isApproved) {
+      gBrowser.selectedBrowser
+              .messageManager
+              .sendAsyncMessage("DOMFullscreen:Approved");
+    } else {
       document.mozCancelFullScreen();
+    }
   },
 
   warningBox: null,
   warningFadeOutTimeout: null,
-  fullscreenDoc: null,
 
   // Shows the fullscreen approval UI, or if the domain has already been approved
   // for fullscreen, shows a warning that the site has entered fullscreen for a short
   // duration.
-  showWarning: function(targetDoc) {
+  showWarning: function(aOrigin) {
     if (!document.mozFullScreen ||
         !gPrefService.getBoolPref("full-screen-api.approval-required"))
       return;
 
     // Set the strings on the fullscreen approval UI.
-    this.fullscreenDoc = targetDoc;
-    let uri = this.fullscreenDoc.nodePrincipal.URI;
+    this.fullscreenOrigin = aOrigin;
+    let uri = BrowserUtils.makeURI(aOrigin);
     let host = null;
     try {
       host = uri.host;
     } catch (e) { }
     let hostLabel = document.getElementById("full-screen-domain-text");
     let rememberCheckbox = document.getElementById("full-screen-remember-decision");
     let isApproved = false;
     if (host) {

--- a/browser/base/content/browser-fullZoom.js
+++ b/browser/base/content/browser-fullZoom.js
@@ -14,20 +14,16 @@ var FullZoom = {
   name: "browser.content.full-zoom",
 
   // browser.zoom.siteSpecific preference cache
   _siteSpecificPref: undefined,
 
   // browser.zoom.updateBackgroundTabs preference cache
   updateBackgroundTabs: undefined,
 
-  // One of the possible values for the mousewheel.* preferences.
-  // From EventStateManager.h.
-  ACTION_ZOOM: 3,
-
   // This maps the browser to monotonically increasing integer
   // tokens. _browserTokenMap[browser] is increased each time the zoom is
   // changed in the browser. See _getBrowserToken and _ignorePendingZoomAccesses.
   _browserTokenMap: new WeakMap(),
 
   // Stores initial locations if we receive onLocationChange
   // events before we're initialized.
   _initialLocations: new WeakMap(),
@@ -44,18 +40,17 @@ var FullZoom = {
                                          Ci.nsIContentPrefObserver,
                                          Ci.nsISupportsWeakReference,
                                          Ci.nsISupports]),
 
   //**************************************************************************//
   // Initialization & Destruction
 
   init: function FullZoom_init() {
-    // Listen for scrollwheel events so we can save scrollwheel-based changes.
-    window.addEventListener("DOMMouseScroll", this, false);
+    gBrowser.addEventListener("ZoomChangeUsingMouseWheel", this);
 
     // Register ourselves with the service so we know when our pref changes.
     this._cps2 = Cc["@mozilla.org/content-pref/service;1"].
                  getService(Ci.nsIContentPrefService2);
     this._cps2.addObserverForName(this.name, this);
 
     this._siteSpecificPref =
       gPrefService.getBoolPref("browser.zoom.siteSpecific");
@@ -76,79 +71,35 @@ var FullZoom = {
     // This should be nulled after initialization.
     this._initialLocations.clear();
     this._initialLocations = null;
   },
 
   destroy: function FullZoom_destroy() {
     gPrefService.removeObserver("browser.zoom.", this);
     this._cps2.removeObserverForName(this.name, this);
-    window.removeEventListener("DOMMouseScroll", this, false);
+    gBrowser.removeEventListener("ZoomChangeUsingMouseWheel", this);
   },
 
 
   //**************************************************************************//
   // Event Handlers
 
   // nsIDOMEventListener
 
   handleEvent: function FullZoom_handleEvent(event) {
     switch (event.type) {
-      case "DOMMouseScroll":
-        this._handleMouseScrolled(event);
+      case "ZoomChangeUsingMouseWheel":
+        let browser = this._getTargetedBrowser(event);
+        this._ignorePendingZoomAccesses(browser);
+        this._applyZoomToPref(browser);
         break;
     }
   },
 
-  _handleMouseScrolled: function FullZoom__handleMouseScrolled(event) {
-    // Construct the "mousewheel action" pref key corresponding to this event.
-    // Based on EventStateManager::WheelPrefs::GetBasePrefName().
-    var pref = "mousewheel.";
-
-    var pressedModifierCount = event.shiftKey + event.ctrlKey + event.altKey +
-                                 event.metaKey + event.getModifierState("OS");
-    if (pressedModifierCount != 1) {
-      pref += "default.";
-    } else if (event.shiftKey) {
-      pref += "with_shift.";
-    } else if (event.ctrlKey) {
-      pref += "with_control.";
-    } else if (event.altKey) {
-      pref += "with_alt.";
-    } else if (event.metaKey) {
-      pref += "with_meta.";
-    } else {
-      pref += "with_win.";
-    }
-
-    pref += "action";
-
-    // Don't do anything if this isn't a "zoom" scroll event.
-    var isZoomEvent = false;
-    try {
-      isZoomEvent = (gPrefService.getIntPref(pref) == this.ACTION_ZOOM);
-    } catch (e) {}
-    if (!isZoomEvent)
-      return;
-
-    // XXX Lazily cache all the possible action prefs so we don't have to get
-    // them anew from the pref service for every scroll event?  We'd have to
-    // make sure to observe them so we can update the cache when they change.
-
-    // We have to call _applyZoomToPref in a timeout because we handle the
-    // event before the event state manager has a chance to apply the zoom
-    // during EventStateManager::PostHandleEvent.
-    let browser = gBrowser.selectedBrowser;
-    let token = this._getBrowserToken(browser);
-    window.setTimeout(function () {
-      if (token.isCurrent)
-        this._applyZoomToPref(browser);
-    }.bind(this), 0);
-  },
-
   // nsIObserver
 
   observe: function (aSubject, aTopic, aData) {
     switch (aTopic) {
       case "nsPref:changed":
         switch (aData) {
           case "browser.zoom.siteSpecific":
             this._siteSpecificPref =
@@ -465,16 +416,40 @@ var FullZoom = {
         // has no properties, so return false.  Check for this case by getting a
         // property, say, docShell.
         return map.get(browser) === this.token && browser.parentNode;
       },
     };
   },
 
   /**
+   * Returns the browser that the supplied zoom event is associated with.
+   * @param event  The ZoomChangeUsingMouseWheel event.
+   * @return  The associated browser element, if one exists, otherwise null.
+   */
+  _getTargetedBrowser: function FullZoom__getTargetedBrowser(event) {
+    let target = event.originalTarget;
+
+    // With remote content browsers, the event's target is the browser
+    // we're looking for.
+    const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+    if (target instanceof window.XULElement &&
+        target.localName == "browser" &&
+        target.namespaceURI == XUL_NS)
+      return target;
+
+    // With in-process content browsers, the event's target is the content
+    // document.
+    if (target.nodeType == Node.DOCUMENT_NODE)
+      return gBrowser.getBrowserForDocument(target);
+
+    throw new Error("Unexpected ZoomChangeUsingMouseWheel event source");
+  },
+
+  /**
    * Increments the zoom change token for the given browser so that pending
    * async operations know that it may be unsafe to access they zoom when they
    * finish.
    *
    * @param browser  Pending accesses in this browser will be ignored.
    */
   _ignorePendingZoomAccesses: function FullZoom__ignorePendingZoomAccesses(browser) {
     let map = this._browserTokenMap;

--- a/browser/base/content/browser.js
+++ b/browser/base/content/browser.js
@@ -18,16 +18,18 @@ XPCOMUtils.defineLazyModuleGetter(this, 
 XPCOMUtils.defineLazyModuleGetter(this, "Task",
                                   "resource://gre/modules/Task.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "CharsetMenu",
                                   "resource://gre/modules/CharsetMenu.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "ShortcutUtils",
                                   "resource://gre/modules/ShortcutUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "GMPInstallManager",
                                   "resource://gre/modules/GMPInstallManager.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NewTabUtils",
+                                  "resource://gre/modules/NewTabUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "ContentSearch",
                                   "resource:///modules/ContentSearch.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "AboutHome",
                                   "resource:///modules/AboutHome.jsm");
 XPCOMUtils.defineLazyServiceGetter(this, "gDNSService",
                                    "@mozilla.org/network/dns-service;1",
                                    "nsIDNSService");
 
@@ -1289,27 +1291,17 @@ var gBrowserInit = {
 
     gBrowser.mPanelContainer.addEventListener("InstallBrowserTheme", LightWeightThemeWebInstaller, false, true);
     gBrowser.mPanelContainer.addEventListener("PreviewBrowserTheme", LightWeightThemeWebInstaller, false, true);
     gBrowser.mPanelContainer.addEventListener("ResetBrowserThemePreview", LightWeightThemeWebInstaller, false, true);
 
     if (Win7Features)
       Win7Features.onOpenWindow();
 
-   // called when we go into full screen, even if initiated by a web page script
-    window.addEventListener("fullscreen", onFullScreen, true);
-
-    // Called when we enter DOM full-screen mode. Note we can already be in browser
-    // full-screen mode when we enter DOM full-screen mode.
-    window.addEventListener("MozEnteredDomFullscreen", onMozEnteredDomFullscreen, true);
-
-    if (window.fullScreen)
-      onFullScreen();
-    if (document.mozFullScreen)
-      onMozEnteredDomFullscreen();
+    FullScreen.init();
 
 #ifdef MOZ_SERVICES_SYNC
     // initialize the sync UI
     gSyncUI.init();
     gFxAccounts.init();
 #endif
 
 #ifdef MOZ_DATA_REPORTING
@@ -1430,17 +1422,17 @@ var gBrowserInit = {
     // uninit methods don't depend on the services having been initialized).
 
     CombinedStopReload.uninit();
 
     gGestureSupport.init(false);
 
     gHistorySwipeAnimation.uninit();
 
-    FullScreen.cleanup();
+    FullScreen.uninit();
 
 #ifdef MOZ_SERVICES_SYNC
     gFxAccounts.uninit();
 #endif
 
     Services.obs.removeObserver(gPluginHandler.pluginCrashed, "plugin-crashed");
 
     try {
@@ -2757,24 +2749,16 @@ function SwitchToMetro() {
 
   let intervalID = window.setInterval(this._checkDefaultAndSwitchToMetro, 1000);
   window.setTimeout(function() { window.clearInterval(intervalID); }, 10000);
 #endif
 #endif
 #endif
 }
 
-function onFullScreen(event) {
-  FullScreen.toggle(event);
-}
-
-function onMozEnteredDomFullscreen(event) {
-  FullScreen.enterDomFullscreen(event);
-}
-
 function getWebNavigation()
 {
   return gBrowser.webNavigation;
 }
 
 function BrowserReloadWithFlags(reloadFlags) {
   let url = gBrowser.currentURI.spec;
   if (gBrowser.updateBrowserRemotenessByURL(gBrowser.selectedBrowser, url)) {
@@ -3104,17 +3088,17 @@ const BrowserSearch = {
     }
 #endif
     let openSearchPageIfFieldIsNotActive = function(aSearchBar) {
       if (!aSearchBar || document.activeElement != aSearchBar.textbox.inputField) {
         let url = gBrowser.currentURI.spec.toLowerCase();
         let mm = gBrowser.selectedBrowser.messageManager;
         if (url === "about:home") {
           AboutHome.focusInput(mm);
-        } else if (url === "about:newtab") {
+        } else if (url === "about:newtab" && NewTabUtils.allPages.enabled) {
           ContentSearch.focusInput(mm);
         } else {
           openUILinkIn("about:home", "current");
         }
       }
     };
 
     let searchBar = this.searchBar;

--- a/browser/base/content/content.js
+++ b/browser/base/content/content.js
@@ -573,8 +573,45 @@ let PageStyleHandler = {
 PageStyleHandler.init();
 
 // Keep a reference to the translation content handler to avoid it it being GC'ed.
 let trHandler = null;
 if (Services.prefs.getBoolPref("browser.translation.detectLanguage")) {
   Cu.import("resource:///modules/translation/TranslationContentHandler.jsm");
   trHandler = new TranslationContentHandler(global, docShell);
 }
+
+let DOMFullscreenHandler = {
+  _fullscreenDoc: null,
+
+  init: function() {
+    addMessageListener("DOMFullscreen:Approved", this);
+    addMessageListener("DOMFullscreen:CleanUp", this);
+    addEventListener("MozEnteredDomFullscreen", this);
+  },
+
+  receiveMessage: function(aMessage) {
+    switch(aMessage.name) {
+      case "DOMFullscreen:Approved": {
+        if (this._fullscreenDoc) {
+          Services.obs.notifyObservers(this._fullscreenDoc,
+                                       "fullscreen-approved",
+                                       "");
+        }
+        break;
+      }
+      case "DOMFullscreen:CleanUp": {
+        this._fullscreenDoc = null;
+        break;
+      }
+    }
+  },
+
+  handleEvent: function(aEvent) {
+    if (aEvent.type == "MozEnteredDomFullscreen") {
+      this._fullscreenDoc = aEvent.target;
+      sendAsyncMessage("MozEnteredDomFullscreen", {
+        origin: this._fullscreenDoc.nodePrincipal.origin,
+      });
+    }
+  }
+};
+DOMFullscreenHandler.init();
\ No newline at end of file

--- a/browser/base/content/tabbrowser.xml
+++ b/browser/base/content/tabbrowser.xml
@@ -1220,16 +1220,25 @@
           return;
         }
 
         // Otherwise, focus the content area. If we're not using remote tabs, we
         // can focus the content area right away, since tab switching is synchronous.
         // If we're using remote tabs, we have to wait until after we've finalized
         // switching the tabs.
 
+        if (newTab._skipContentFocus) {
+          // It's possible the tab we're switching to is ready to focus asynchronously,
+          // when we've already focused something else. In that case, this
+          // _skipContentFocus property can be set so that we skip focusing the
+          // content after we switch tabs.
+          delete newTab._skipContentFocus;
+          return;
+        }
+
         let fm = Cc["@mozilla.org/focus-manager;1"].getService(Ci.nsIFocusManager);
         let focusFlags = fm.FLAG_NOSCROLL;
 
         if (!gMultiProcessBrowser) {
           let newFocusedElement = fm.getFocusedElementForWindow(window.content, true, {});
 
           // for anchors, use FLAG_SHOWRING so that it is clear what link was
           // last clicked when switching back to that tab

--- a/browser/base/content/test/general/browser.ini
+++ b/browser/base/content/test/general/browser.ini
@@ -271,16 +271,18 @@ skip-if = e10s # Bug 921959 - reload wit
 [browser_bug880101.js]
 [browser_bug882977.js]
 [browser_bug902156.js]
 skip-if = e10s # Bug 921959 - reload with LOAD_FLAGS_ALLOW_MIXED_CONTENT fails in e10s
 [browser_bug906190.js]
 skip-if = buildapp == "mulet" || e10s # Bug ?????? - test directly manipulates content (strange - gets an element from a child which it tries to treat as a string, but that fails)
 [browser_bug970746.js]
 skip-if = e10s # Bug ?????? - test directly manipulates content (directly gets elements from the content)
+[browser_bug1015721.js]
+skip-if = os == 'win' || e10s # Bug 1056146 - FullZoomHelper uses promiseTabLoadEvent() which isn't e10s friendly
 [browser_canonizeURL.js]
 skip-if = e10s # Bug ?????? - [JavaScript Error: "Error in AboutHome.sendAboutHomeData TypeError: target.messageManager is undefined" {file: "resource:///modules/AboutHome.jsm" line: 208}]
 [browser_contentAreaClick.js]
 [browser_contextSearchTabPosition.js]
 skip-if = os == "mac" # bug 967013, bug 926729
 [browser_ctrlTab.js]
 skip-if = e10s # Bug ????? - thumbnail captures need e10s love (tabPreviews_capture fails with Argument 1 of CanvasRenderingContext2D.drawWindow does not implement interface Window.)
 [browser_customize_popupNotification.js]

new file mode 100644
--- /dev/null
+++ b/browser/base/content/test/general/browser_bug1015721.js
@@ -0,0 +1,55 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const TEST_PAGE = "http://example.org/browser/browser/base/content/test/general/zoom_test.html";
+
+var gTab1, gTab2, gLevel1;
+
+function test() {
+  waitForExplicitFinish();
+
+  Task.spawn(function () {
+    gTab1 = gBrowser.addTab();
+    gTab2 = gBrowser.addTab();
+
+    yield FullZoomHelper.selectTabAndWaitForLocationChange(gTab1);
+    yield FullZoomHelper.load(gTab1, TEST_PAGE);
+    yield FullZoomHelper.load(gTab2, TEST_PAGE);
+  }).then(zoomTab1, FullZoomHelper.failAndContinue(finish));
+}
+
+function dispatchZoomEventToBrowser(browser) {
+  EventUtils.synthesizeWheel(browser.contentDocument.documentElement, 10, 10, {
+    ctrlKey: true, deltaY: -1, deltaMode: WheelEvent.DOM_DELTA_LINE
+  }, browser.contentWindow);
+}
+
+function zoomTab1() {
+  Task.spawn(function () {
+    is(gBrowser.selectedTab, gTab1, "Tab 1 is selected");
+    FullZoomHelper.zoomTest(gTab1, 1, "Initial zoom of tab 1 should be 1");
+    FullZoomHelper.zoomTest(gTab2, 1, "Initial zoom of tab 2 should be 1");
+
+    let browser1 = gBrowser.getBrowserForTab(gTab1);
+    dispatchZoomEventToBrowser(browser1);
+
+    gLevel1 = ZoomManager.getZoomForBrowser(browser1);
+    ok(gLevel1 > 1, "New zoom for tab 1 should be greater than 1");
+
+    yield FullZoomHelper.selectTabAndWaitForLocationChange(gTab2);
+    FullZoomHelper.zoomTest(gTab2, gLevel1, "Tab 2 should have zoomed along with tab 1");
+  }).then(finishTest, FullZoomHelper.failAndContinue(finish));
+}
+
+function finishTest() {
+  Task.spawn(function () {
+    yield FullZoomHelper.selectTabAndWaitForLocationChange(gTab1);
+    FullZoom.reset();
+    yield FullZoomHelper.removeTabAndWaitForLocationChange(gTab1);
+    yield FullZoomHelper.selectTabAndWaitForLocationChange(gTab2);
+    FullZoom.reset();
+    yield FullZoomHelper.removeTabAndWaitForLocationChange(gTab2);
+  }).then(finish, FullZoomHelper.failAndContinue(finish));
+}

--- a/browser/base/content/test/newtab/browser_newtab_search.js
+++ b/browser/base/content/test/newtab/browser_newtab_search.js
@@ -200,16 +200,34 @@ function runTests() {
   // Reset changes made to toolbar
   CustomizableUI.reset();
 
   // Test that Ctrl/Cmd + K will focus the search bar from toolbar.
   let searchBar = gWindow.document.getElementById("searchbar");
   EventUtils.synthesizeKey("k", { accelKey: true });
   is(searchBar.textbox.inputField, gWindow.document.activeElement, "Toolbar's search bar should be focused");
 
+  // Test that Ctrl/Cmd + K will focus the search bar from a new about:home page if
+  // the newtab is disabled from `NewTabUtils.allPages.enabled`.
+  yield addNewTabPageTab();
+  // Remove the search bar from toolbar
+  CustomizableUI.removeWidgetFromArea("search-container");
+  NewTabUtils.allPages.enabled = false;
+  EventUtils.synthesizeKey("k", { accelKey: true });
+  let waitEvent = "AboutHomeLoadSnippetsCompleted";
+  yield promiseTabLoadEvent(gWindow.gBrowser.selectedTab, "about:home", waitEvent).then(TestRunner.next);
+
+  is(getContentDocument().documentURI.toLowerCase(), "about:home", "New tab's uri should be about:home");
+  let searchInput = getContentDocument().getElementById("searchText");
+  is(searchInput, getContentDocument().activeElement, "Search input must be the selected element");
+
+  NewTabUtils.allPages.enabled = true;
+  CustomizableUI.reset();
+  gBrowser.removeCurrentTab();
+
   // Done.  Revert the current engine and remove the new engines.
   Services.search.currentEngine = oldCurrentEngine;
   yield promiseSearchEvents(["CurrentEngine"]).then(TestRunner.next);
 
   let events = [];
   for (let engine of gNewEngines) {
     Services.search.removeEngine(engine);
     events.push("CurrentState");
@@ -409,8 +427,51 @@ function searchPanel() {
 
 function logoImg() {
   return $("logo");
 }
 
 function gSearch() {
   return getContentWindow().gSearch;
 }
+
+/**
+ * Waits for a load (or custom) event to finish in a given tab. If provided
+ * load an uri into the tab.
+ *
+ * @param tab
+ *        The tab to load into.
+ * @param [optional] url
+ *        The url to load, or the current url.
+ * @param [optional] event
+ *        The load event type to wait for.  Defaults to "load".
+ * @return {Promise} resolved when the event is handled.
+ * @resolves to the received event
+ * @rejects if a valid load event is not received within a meaningful interval
+ */
+function promiseTabLoadEvent(tab, url, eventType="load") {
+  let deferred = Promise.defer();
+  info("Wait tab event: " + eventType);
+
+  function handle(event) {
+    if (event.originalTarget != tab.linkedBrowser.contentDocument ||
+        event.target.location.href == "about:blank" ||
+        (url && event.target.location.href != url)) {
+      info("Skipping spurious '" + eventType + "'' event" +
+           " for " + event.target.location.href);
+      return;
+    }
+    clearTimeout(timeout);
+    tab.linkedBrowser.removeEventListener(eventType, handle, true);
+    info("Tab event received: " + eventType);
+    deferred.resolve(event);
+  }
+
+  let timeout = setTimeout(() => {
+    tab.linkedBrowser.removeEventListener(eventType, handle, true);
+    deferred.reject(new Error("Timed out while waiting for a '" + eventType + "'' event"));
+  }, 20000);
+
+  tab.linkedBrowser.addEventListener(eventType, handle, true, true);
+  if (url)
+    tab.linkedBrowser.loadURI(url);
+  return deferred.promise;
+}

--- a/browser/base/content/test/newtab/head.js
+++ b/browser/base/content/test/newtab/head.js
@@ -9,17 +9,17 @@ Services.prefs.setBoolPref(PREF_NEWTAB_E
 let tmp = {};
 Cu.import("resource://gre/modules/Promise.jsm", tmp);
 Cu.import("resource://gre/modules/NewTabUtils.jsm", tmp);
 Cu.import("resource://gre/modules/DirectoryLinksProvider.jsm", tmp);
 Cc["@mozilla.org/moz/jssubscript-loader;1"]
   .getService(Ci.mozIJSSubScriptLoader)
   .loadSubScript("chrome://browser/content/sanitize.js", tmp);
 Cu.import("resource://gre/modules/Timer.jsm", tmp);
-let {Promise, NewTabUtils, Sanitizer, clearTimeout, DirectoryLinksProvider} = tmp;
+let {Promise, NewTabUtils, Sanitizer, clearTimeout, setTimeout, DirectoryLinksProvider} = tmp;
 
 let uri = Services.io.newURI("about:newtab", null, null);
 let principal = Services.scriptSecurityManager.getNoAppCodebasePrincipal(uri);
 
 let isMac = ("nsILocalFileMac" in Ci);
 let isLinux = ("@mozilla.org/gnome-gconf-service;1" in Cc);
 let isWindows = ("@mozilla.org/windows-registry-key;1" in Cc);
 let gWindow = window;

--- a/browser/base/content/utilityOverlay.js
+++ b/browser/base/content/utilityOverlay.js
@@ -304,16 +304,18 @@ function openLinkIn(url, where, params) 
       loadInBackground = false;
     }
   }
 
   // Raise the target window before loading the URI, since loading it may
   // result in a new frontmost window (e.g. "javascript:window.open('');").
   w.focus();
 
+  let newTab;
+
   switch (where) {
   case "current":
     let flags = Ci.nsIWebNavigation.LOAD_FLAGS_NONE;
 
     if (aAllowThirdPartyFixup) {
       flags |= Ci.nsIWebNavigation.LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP;
       flags |= Ci.nsIWebNavigation.LOAD_FLAGS_FIXUP_SCHEME_TYPOS;
     }
@@ -326,33 +328,40 @@ function openLinkIn(url, where, params) 
       flags |= Ci.nsIWebNavigation.LOAD_FLAGS_DISALLOW_INHERIT_OWNER;
 
     w.gBrowser.loadURIWithFlags(url, flags, aReferrerURI, null, aPostData);
     break;
   case "tabshifted":
     loadInBackground = !loadInBackground;
     // fall through
   case "tab":
-    let browser = w.gBrowser;
-    browser.loadOneTab(url, {
-                       referrerURI: aReferrerURI,
-                       charset: aCharset,
-                       postData: aPostData,
-                       inBackground: loadInBackground,
-                       allowThirdPartyFixup: aAllowThirdPartyFixup,
-                       relatedToCurrent: aRelatedToCurrent,
-                       skipAnimation: aSkipTabAnimation,
-                       allowMixedContent: aAllowMixedContent });
+    newTab = w.gBrowser.loadOneTab(url, {
+      referrerURI: aReferrerURI,
+      charset: aCharset,
+      postData: aPostData,
+      inBackground: loadInBackground,
+      allowThirdPartyFixup: aAllowThirdPartyFixup,
+      relatedToCurrent: aRelatedToCurrent,
+      skipAnimation: aSkipTabAnimation,
+      allowMixedContent: aAllowMixedContent
+    });
     break;
   }
 
   w.gBrowser.selectedBrowser.focus();
 
-  if (!loadInBackground && w.isBlankPageURL(url))
+  if (!loadInBackground && w.isBlankPageURL(url)) {
+    if (newTab && gMultiProcessBrowser) {
+      // Remote browsers are switched to asynchronously, and we need to
+      // ensure that the location bar remains focused in that case rather
+      // than the content area being focused.
+      newTab._skipContentFocus = true;
+    }
     w.focusAndSelectUrlBar();
+  }
 }
 
 // Used as an onclick handler for UI elements with link-like behavior.
 // e.g. onclick="checkForMiddleClick(this, event);"
 function checkForMiddleClick(node, event) {
   // We should be using the disabled property here instead of the attribute,
   // but some elements that this function is used with don't support it (e.g.
   // menuitem).

--- a/browser/components/nsBrowserGlue.js
+++ b/browser/components/nsBrowserGlue.js
@@ -1315,118 +1315,105 @@ BrowserGlue.prototype = {
     var notification = notifyBox.appendNotification(text, title, null,
                                                     notifyBox.PRIORITY_CRITICAL_MEDIUM,
                                                     buttons);
     notification.persistence = -1; // Until user closes it
   },
 
   _migrateUI: function BG__migrateUI() {
     const UI_VERSION = 23;
-    const BROWSER_DOCURL = "chrome://browser/content/browser.xul#";
+    const BROWSER_DOCURL = "chrome://browser/content/browser.xul";
     let currentUIVersion = 0;
     try {
       currentUIVersion = Services.prefs.getIntPref("browser.migration.version");
     } catch(ex) {}
     if (currentUIVersion >= UI_VERSION)
       return;
 
-    this._rdf = Cc["@mozilla.org/rdf/rdf-service;1"].getService(Ci.nsIRDFService);
-    this._dataSource = this._rdf.GetDataSource("rdf:local-store");
-    this._dirty = false;
+    let xulStore = Cc["@mozilla.org/xul/xulstore;1"].getService(Ci.nsIXULStore);
 
     if (currentUIVersion < 2) {
       // This code adds the customizable bookmarks button.
-      let currentsetResource = this._rdf.GetResource("currentset");
-      let toolbarResource = this._rdf.GetResource(BROWSER_DOCURL + "nav-bar");
-      let currentset = this._getPersist(toolbarResource, currentsetResource);
+      let currentset = xulStore.getValue(BROWSER_DOCURL, "nav-bar", "currentset");
       // Need to migrate only if toolbar is customized and the element is not found.
       if (currentset &&
           currentset.indexOf("bookmarks-menu-button-container") == -1) {
         currentset += ",bookmarks-menu-button-container";
-        this._setPersist(toolbarResource, currentsetResource, currentset);
+        xulStore.setValue(BROWSER_DOCURL, "nav-bar", "currentset", currentset);
       }
     }
 
     if (currentUIVersion < 3) {
       // This code merges the reload/stop/go button into the url bar.
-      let currentsetResource = this._rdf.GetResource("currentset");
-      let toolbarResource = this._rdf.GetResource(BROWSER_DOCURL + "nav-bar");
-      let currentset = this._getPersist(toolbarResource, currentsetResource);
+      let currentset = xulStore.getValue(BROWSER_DOCURL, "nav-bar", "currentset");
       // Need to migrate only if toolbar is customized and all 3 elements are found.
       if (currentset &&
           currentset.indexOf("reload-button") != -1 &&
           currentset.indexOf("stop-button") != -1 &&
           currentset.indexOf("urlbar-container") != -1 &&
           currentset.indexOf("urlbar-container,reload-button,stop-button") == -1) {
         currentset = currentset.replace(/(^|,)reload-button($|,)/, "$1$2")
                                .replace(/(^|,)stop-button($|,)/, "$1$2")
                                .replace(/(^|,)urlbar-container($|,)/,
                                         "$1urlbar-container,reload-button,stop-button$2");
-        this._setPersist(toolbarResource, currentsetResource, currentset);
+        xulStore.setValue(BROWSER_DOCURL, "nav-bar", "currentset", currentset);
       }
     }
 
     if (currentUIVersion < 4) {
       // This code moves the home button to the immediate left of the bookmarks menu button.
-      let currentsetResource = this._rdf.GetResource("currentset");
-      let toolbarResource = this._rdf.GetResource(BROWSER_DOCURL + "nav-bar");
-      let currentset = this._getPersist(toolbarResource, currentsetResource);
+      let currentset = xulStore.getValue(BROWSER_DOCURL, "nav-bar", "currentset");
       // Need to migrate only if toolbar is customized and the elements are found.
       if (currentset &&
           currentset.indexOf("home-button") != -1 &&
           currentset.indexOf("bookmarks-menu-button-container") != -1) {
         currentset = currentset.replace(/(^|,)home-button($|,)/, "$1$2")
                                .replace(/(^|,)bookmarks-menu-button-container($|,)/,
                                         "$1home-button,bookmarks-menu-button-container$2");
-        this._setPersist(toolbarResource, currentsetResource, currentset);
+        xulStore.setValue(BROWSER_DOCURL, "nav-bar", "currentset", currentset);
       }
     }
 
     if (currentUIVersion < 5) {
       // This code uncollapses PersonalToolbar if its collapsed status is not
       // persisted, and user customized it or changed default bookmarks.
-      let toolbarResource = this._rdf.GetResource(BROWSER_DOCURL + "PersonalToolbar");
-      let collapsedResource = this._rdf.GetResource("collapsed");
-      let collapsed = this._getPersist(toolbarResource, collapsedResource);
+      //
       // If the user does not have a persisted value for the toolbar's
       // "collapsed" attribute, try to determine whether it's customized.
-      if (collapsed === null) {
+      if (!xulStore.hasValue(BROWSER_DOCURL, "PersonalToolbar", "collapsed")) {
         // We consider the toolbar customized if it has more than
         // 3 children, or if it has a persisted currentset value.
-        let currentsetResource = this._rdf.GetResource("currentset");
-        let toolbarIsCustomized = !!this._getPersist(toolbarResource,
-                                                     currentsetResource);
+        let toolbarIsCustomized = xulStore.hasValue(BROWSER_DOCURL,
+                                                    "PersonalToolbar", "currentset");
         let getToolbarFolderCount = function () {
           let toolbarFolder =
             PlacesUtils.getFolderContents(PlacesUtils.toolbarFolderId).root;
           let toolbarChildCount = toolbarFolder.childCount;
           toolbarFolder.containerOpen = false;
           return toolbarChildCount;
         };
 
         if (toolbarIsCustomized || getToolbarFolderCount() > 3) {
-          this._setPersist(toolbarResource, collapsedResource, "false");
+          xulStore.setValue(BROWSER_DOCURL, "PersonalToolbar", "collapsed", "false");
         }
       }
     }
 
     if (currentUIVersion < 8) {
       // Reset homepage pref for users who have it set to google.com/firefox
       let uri = Services.prefs.getComplexValue("browser.startup.homepage",
                                                Ci.nsIPrefLocalizedString).data;
       if (uri && /^https?:\/\/(www\.)?google(\.\w{2,3}){1,2}\/firefox\/?$/.test(uri)) {
         Services.prefs.clearUserPref("browser.startup.homepage");
       }
     }
 
     if (currentUIVersion < 9) {
       // This code adds the customizable downloads buttons.
-      let currentsetResource = this._rdf.GetResource("currentset");
-      let toolbarResource = this._rdf.GetResource(BROWSER_DOCURL + "nav-bar");
-      let currentset = this._getPersist(toolbarResource, currentsetResource);
+      let currentset = xulStore.getValue(BROWSER_DOCURL, "nav-bar", "currentset");
 
       // Since the Downloads button is located in the navigation bar by default,
       // migration needs to happen only if the toolbar was customized using a
       // previous UI version, and the button was not already placed on the
       // toolbar manually.
       if (currentset &&
           currentset.indexOf("downloads-button") == -1) {
         // The element is added either after the search bar or before the home
@@ -1437,17 +1424,17 @@ BrowserGlue.prototype = {
                                           "$1search-container,downloads-button$2")
         } else if (currentset.indexOf("home-button") != -1) {
           currentset = currentset.replace(/(^|,)home-button($|,)/,
                                           "$1downloads-button,home-button$2")
         } else {
           currentset = currentset.replace(/(^|,)window-controls($|,)/,
                                           "$1downloads-button,window-controls$2")
         }
-        this._setPersist(toolbarResource, currentsetResource, currentset);
+        xulStore.setValue(BROWSER_DOCURL, "nav-bar", "currentset", currentset);
       }
     }
 
 #ifdef XP_WIN
     if (currentUIVersion < 10) {
       // For Windows systems with display set to > 96dpi (i.e. systemDefaultScale
       // will return a value > 1.0), we want to discard any saved full-zoom settings,
       // as we'll now be scaling the content according to the system resolution
@@ -1467,25 +1454,23 @@ BrowserGlue.prototype = {
       Services.prefs.clearUserPref("dom.event.contextmenu.enabled");
       Services.prefs.clearUserPref("javascript.enabled");
       Services.prefs.clearUserPref("permissions.default.image");
     }
 
     if (currentUIVersion < 12) {
       // Remove bookmarks-menu-button-container, then place
       // bookmarks-menu-button into its position.
-      let currentsetResource = this._rdf.GetResource("currentset");
-      let toolbarResource = this._rdf.GetResource(BROWSER_DOCURL + "nav-bar");
-      let currentset = this._getPersist(toolbarResource, currentsetResource);
+      let currentset = xulStore.getValue(BROWSER_DOCURL, "nav-bar", "currentset");
       // Need to migrate only if toolbar is customized.
       if (currentset) {
         if (currentset.contains("bookmarks-menu-button-container")) {
           currentset = currentset.replace(/(^|,)bookmarks-menu-button-container($|,)/,
                                           "$1bookmarks-menu-button$2");
-          this._setPersist(toolbarResource, currentsetResource, currentset);
+          xulStore.setValue(BROWSER_DOCURL, "nav-bar", "currentset", currentset);
         }
       }
     }
 
     if (currentUIVersion < 13) {
       try {
         if (Services.prefs.getBoolPref("plugins.hide_infobar_for_missing_plugin"))
           Services.prefs.setBoolPref("plugins.notifyMissingFlash", false);
@@ -1496,62 +1481,54 @@ BrowserGlue.prototype = {
     if (currentUIVersion < 14) {
       // DOM Storage doesn't specially handle about: pages anymore.
       let path = OS.Path.join(OS.Constants.Path.profileDir,
                               "chromeappsstore.sqlite");
       OS.File.remove(path);
     }
 
     if (currentUIVersion < 16) {
-      let toolbarResource = this._rdf.GetResource(BROWSER_DOCURL + "nav-bar");
-      let collapsedResource = this._rdf.GetResource("collapsed");
-      let isCollapsed = this._getPersist(toolbarResource, collapsedResource);
+      let isCollapsed = xulStore.getValue(BROWSER_DOCURL, "nav-bar", "collapsed");
       if (isCollapsed == "true") {
-        this._setPersist(toolbarResource, collapsedResource, "false");
+        xulStore.setValue(BROWSER_DOCURL, "nav-bar", "collapsed", "false");
       }
     }
 
     // Insert the bookmarks-menu-button into the nav-bar if it isn't already
     // there.
     if (currentUIVersion < 17) {
-      let currentsetResource = this._rdf.GetResource("currentset");
-      let toolbarResource = this._rdf.GetResource(BROWSER_DOCURL + "nav-bar");
-      let currentset = this._getPersist(toolbarResource, currentsetResource);
+      let currentset = xulStore.getValue(BROWSER_DOCURL, "nav-bar", "currentset");
       // Need to migrate only if toolbar is customized.
       if (currentset) {
         if (!currentset.contains("bookmarks-menu-button")) {
           // The button isn't in the nav-bar, so let's look for an appropriate
           // place to put it.
           if (currentset.contains("downloads-button")) {
             currentset = currentset.replace(/(^|,)downloads-button($|,)/,
                                             "$1bookmarks-menu-button,downloads-button$2");
           } else if (currentset.contains("home-button")) {
             currentset = currentset.replace(/(^|,)home-button($|,)/,
                                             "$1bookmarks-menu-button,home-button$2");
           } else {
             // Just append.
             currentset = currentset.replace(/(^|,)window-controls($|,)/,
                                             "$1bookmarks-menu-button,window-controls$2")
           }
-          this._setPersist(toolbarResource, currentsetResource, currentset);
+          xulStore.setValue(BROWSER_DOCURL, "nav-bar", "currentset", currentset);
         }
       }
     }
 
     if (currentUIVersion < 18) {
       // Remove iconsize and mode from all the toolbars
       let toolbars = ["navigator-toolbox", "nav-bar", "PersonalToolbar",
                       "addon-bar", "TabsToolbar", "toolbar-menubar"];
       for (let resourceName of ["mode", "iconsize"]) {
-        let resource = this._rdf.GetResource(resourceName);
         for (let toolbarId of toolbars) {
-          let toolbar = this._rdf.GetResource(BROWSER_DOCURL + toolbarId);
-          if (this._getPersist(toolbar, resource)) {
-            this._setPersist(toolbar, resource);
-          }
+          xulStore.removeValue(BROWSER_DOCURL, toolbarId, resourceName);
         }
       }
     }
 
     if (currentUIVersion < 19) {
       let detector = null;    
       try {
         detector = Services.prefs.getComplexValue("intl.charset.detector",
@@ -1564,31 +1541,23 @@ BrowserGlue.prototype = {
         // If the encoding detector pref value is not reachable from the UI,
         // reset to default (varies by localization).
         Services.prefs.clearUserPref("intl.charset.detector");
       }
     }
 
     if (currentUIVersion < 20) {
       // Remove persisted collapsed state from TabsToolbar.
-      let resource = this._rdf.GetResource("collapsed");
-      let toolbar = this._rdf.GetResource(BROWSER_DOCURL + "TabsToolbar");
-      if (this._getPersist(toolbar, resource)) {
-        this._setPersist(toolbar, resource);
-      }
+      xulStore.removeValue(BROWSER_DOCURL, "TabsToolbar", "collapsed");
     }
 
     if (currentUIVersion < 21) {
       // Make sure the 'toolbarbutton-1' class will always be present from here
       // on out.
-      let button = this._rdf.GetResource(BROWSER_DOCURL + "bookmarks-menu-button");
-      let classResource = this._rdf.GetResource("class");
-      if (this._getPersist(button, classResource)) {
-        this._setPersist(button, classResource);
-      }
+      xulStore.removeValue(BROWSER_DOCURL, "bookmarks-menu-button", "class");
     }
 
     if (currentUIVersion < 22) {
       // Reset the Sync promobox count to promote the new FxAccount-based Sync.
       Services.prefs.clearUserPref("browser.syncPromoViewsLeft");
       Services.prefs.clearUserPref("browser.syncPromoViewsLeftMap");
     }
 
@@ -1598,59 +1567,20 @@ BrowserGlue.prototype = {
         try {
           let name = Services.prefs.getComplexValue(kSelectedEnginePref,
                                                     Ci.nsIPrefLocalizedString).data;
           Services.search.currentEngine = Services.search.getEngineByName(name);
         } catch (ex) {}
       }
     }
 
-    if (this._dirty)
-      this._dataSource.QueryInterface(Ci.nsIRDFRemoteDataSource).Flush();
-
-    delete this._rdf;
-    delete this._dataSource;
-
     // Update the migration version.
     Services.prefs.setIntPref("browser.migration.version", UI_VERSION);
   },
 
-  _getPersist: function BG__getPersist(aSource, aProperty) {
-    var target = this._dataSource.GetTarget(aSource, aProperty, true);
-    if (target instanceof Ci.nsIRDFLiteral)
-      return target.Value;
-    return null;
-  },
-
-  _setPersist: function BG__setPersist(aSource, aProperty, aTarget) {
-    this._dirty = true;
-    try {
-      var oldTarget = this._dataSource.GetTarget(aSource, aProperty, true);
-      if (oldTarget) {
-        if (aTarget)
-          this._dataSource.Change(aSource, aProperty, oldTarget, this._rdf.GetLiteral(aTarget));
-        else
-          this._dataSource.Unassert(aSource, aProperty, oldTarget);
-      }
-      else {
-        this._dataSource.Assert(aSource, aProperty, this._rdf.GetLiteral(aTarget), true);
-      }
-
-      // Add the entry to the persisted set for this document if it's not there.
-      // This code is mostly borrowed from XULDocument::Persist.
-      let docURL = aSource.ValueUTF8.split("#")[0];
-      let docResource = this._rdf.GetResource(docURL);
-      let persistResource = this._rdf.GetResource("http://home.netscape.com/NC-rdf#persist");
-      if (!this._dataSource.HasAssertion(docResource, persistResource, aSource, true)) {
-        this._dataSource.Assert(docResource, persistResource, aSource, true);
-      }
-    }
-    catch(ex) {}
-  },
-
   // ------------------------------
   // public nsIBrowserGlue members
   // ------------------------------
 
   sanitize: function BG_sanitize(aParentWindow) {
     this._sanitizer.sanitize(aParentWindow);
   },
 

--- a/browser/components/places/PlacesUIUtils.jsm
+++ b/browser/components/places/PlacesUIUtils.jsm
@@ -1015,20 +1015,16 @@ this.PlacesUIUtils = {
            Weave.Service.engineManager.get("tabs").enabled;
   },
 };
 
 XPCOMUtils.defineLazyServiceGetter(PlacesUIUtils, "RDF",
                                    "@mozilla.org/rdf/rdf-service;1",
                                    "nsIRDFService");
 
-XPCOMUtils.defineLazyGetter(PlacesUIUtils, "localStore", function() {
-  return PlacesUIUtils.RDF.GetDataSource("rdf:local-store");
-});
-
 XPCOMUtils.defineLazyGetter(PlacesUIUtils, "ellipsis", function() {
   return Services.prefs.getComplexValue("intl.ellipsis",
                                         Ci.nsIPrefLocalizedString).data;
 });
 
 XPCOMUtils.defineLazyGetter(PlacesUIUtils, "useAsyncTransactions", function() {
   try {
     return Services.prefs.getBoolPref("browser.places.useAsyncTransactions");

--- a/browser/components/places/content/treeView.js
+++ b/browser/components/places/content/treeView.js
@@ -18,16 +18,24 @@ function PlacesTreeView(aFlatList, aOnOp
   this._flatList = aFlatList;
   this._openContainerCallback = aOnOpenFlatContainer;
   this._controller = aController;
 }
 
 PlacesTreeView.prototype = {
   get wrappedJSObject() this,
 
+  __xulStore: null,
+  get _xulStore() {
+    if (!this.__xulStore) {
+      this.__xulStore = Cc["@mozilla.org/xul/xulstore;1"].getService(Ci.nsIXULStore);
+    }
+    return this.__xulStore;
+  },
+
   __dateService: null,
   get _dateService() {
     if (!this.__dateService) {
       this.__dateService = Cc["@mozilla.org/intl/scriptabledateformat;1"].
                            getService(Ci.nsIScriptableDateFormat);
     }
     return this.__dateService;
   },
@@ -302,21 +310,25 @@ PlacesTreeView.prototype = {
 
       this._rows[row] = curChild;
       rowsInserted++;
 
       // Recursively do containers.
       if (!this._flatList &&
           curChild instanceof Ci.nsINavHistoryContainerResultNode &&
           !this._controller.hasCachedLivemarkInfo(curChild)) {
-        let resource = this._getResourceForNode(curChild);
-        let isopen = resource != null &&
-                     PlacesUIUtils.localStore.HasAssertion(resource,
-                                                           openLiteral,
-                                                           trueLiteral, true);
+        let uri = curChild.uri;
+        let isopen = false;
+
+        if (uri) {
+          let docURI = this._getDocumentURI();
+          let val = this._xulStore.getValue(docURI, uri, "open");
+          isopen = (val == "true");
+        }
+
         if (isopen != curChild.containerOpen)
           aToOpen.push(curChild);
         else if (curChild.containerOpen && curChild.childCount > 0)
           rowsInserted += this._buildVisibleSection(curChild, row + 1, aToOpen);
       }
     }
 
     return rowsInserted;
@@ -1104,21 +1116,26 @@ PlacesTreeView.prototype = {
     try {
       return this._getRowForNode(aNode, true);
     }
     catch(ex) { }
 
     return Ci.nsINavHistoryResultTreeViewer.INDEX_INVISIBLE;
   },
 
-  _getResourceForNode: function PTV_getResourceForNode(aNode)
+  // Retrieves an nsIURI for the document
+  _documentURI: null,
+  _getDocumentURI: function()
   {
-    let uri = aNode.uri;
-    NS_ASSERT(uri, "if there is no uri, we can't persist the open state");
-    return uri ? PlacesUIUtils.RDF.GetResource(uri) : null;
+    if (!this._documentURI) {
+      let ioService = Cc["@mozilla.org/network/io-service;1"].
+                      getService(Ci.nsIIOService);
+      this._documentURI = ioService.newURI(document.URL, null, null);
+    }
+    return this._documentURI;
   },
 
   // nsITreeView
   get rowCount() this._rows.length,
   get selection() this._selection,
   set selection(val) this._selection = val,
 
   getRowProperties: function() { return ""; },
@@ -1492,25 +1509,26 @@ PlacesTreeView.prototype = {
     let node = this._rows[aRow];
     if (this._flatList && this._openContainerCallback) {
       this._openContainerCallback(node);
       return;
     }
 
     // Persist containers open status, but never persist livemarks.
     if (!this._controller.hasCachedLivemarkInfo(node)) {
-      let resource = this._getResourceForNode(node);
-      if (resource) {
-        const openLiteral = PlacesUIUtils.RDF.GetResource("http://home.netscape.com/NC-rdf#open");
-        const trueLiteral = PlacesUIUtils.RDF.GetLiteral("true");
+      let uri = node.uri;
+
+      if (uri) {
+        let docURI = this._getDocumentURI();
 
-        if (node.containerOpen)
-          PlacesUIUtils.localStore.Unassert(resource, openLiteral, trueLiteral);
-        else
-          PlacesUIUtils.localStore.Assert(resource, openLiteral, trueLiteral, true);
+        if (node.containerOpen) {
+          this._xulStore.removeValue(docURI, uri, "open");
+        } else {
+          this._xulStore.setValue(docURI, uri, "open", "true");
+        }
       }
     }
 
     node.containerOpen = !node.containerOpen;
   },
 
   cycleHeader: function PTV_cycleHeader(aColumn) {
     if (!this._result)

--- a/browser/components/places/tests/browser/browser_toolbar_migration.js
+++ b/browser/components/places/tests/browser/browser_toolbar_migration.js
@@ -1,90 +1,53 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 /**
  * Tests PersonalToolbar migration path.
  */
-
 let bg = Cc["@mozilla.org/browser/browserglue;1"].getService(Ci.nsIObserver);
 let gOriginalMigrationVersion;
 const BROWSER_URL = getBrowserURL();
 
 let localStore = {
-  get RDF() Cc["@mozilla.org/rdf/rdf-service;1"].getService(Ci.nsIRDFService),
-  get store() this.RDF.GetDataSource("rdf:local-store"),
+  get xulStore() Cc["@mozilla.org/xul/xulstore;1"].getService(Ci.nsIXULStore),
 
-  get toolbar()
+  getValue: function getValue(aProperty)
   {
-    delete this.toolbar;
-    let toolbar = this.RDF.GetResource(BROWSER_URL + "#PersonalToolbar");
-    // Add the entry to the persisted set for this document if it's not there.
-    // See XULDocument::Persist.
-    let doc = this.RDF.GetResource(BROWSER_URL);
-    let persist = this.RDF.GetResource("http://home.netscape.com/NC-rdf#persist");
-    if (!this.store.HasAssertion(doc, persist, toolbar, true)) {
-      this.store.Assert(doc, persist, toolbar, true);
-    }
-    return this.toolbar = toolbar;
+    return this.xulStore.getValue(BROWSER_URL, "PersonalToolbar", aProperty);
   },
 
-  getPersist: function getPersist(aProperty)
-  {
-    let property = this.RDF.GetResource(aProperty);
-    let target = this.store.GetTarget(this.toolbar, property, true);
-    if (target instanceof Ci.nsIRDFLiteral)
-      return target.Value;
-    return null;
-  },
-
-  setPersist: function setPersist(aProperty, aValue)
+  setValue: function setValue(aProperty, aValue)
   {
-    let property = this.RDF.GetResource(aProperty);
-    let value = aValue ? this.RDF.GetLiteral(aValue) : null;
-
-    try {
-      let oldTarget = this.store.GetTarget(this.toolbar, property, true);
-      if (oldTarget && value) {
-        this.store.Change(this.toolbar, property, oldTarget, value);
-      }
-      else if (value) {
-        this.store.Assert(this.toolbar, property, value, true);  
-      }
-      else if (oldTarget) {
-        this.store.Unassert(this.toolbar, property, oldTarget);
-      }
-      else {
-        return;
-      }
+    if (aValue) {
+      this.xulStore.setValue(BROWSER_URL, "PersonalToolbar", aProperty, aValue);
+    } else {
+      this.xulStore.removeValue(BROWSER_URL, "PersonalToolbar", aProperty);
     }
-    catch(ex) {
-      return;
-    }
-    this.store.QueryInterface(Ci.nsIRDFRemoteDataSource).Flush();
   }
 };
 
 let gTests = [
 
 function test_explicitly_collapsed_toolbar()
 {
   info("An explicitly collapsed toolbar should not be uncollapsed.");
-  localStore.setPersist("collapsed", "true");
+  localStore.setValue("collapsed", "true");
   bg.observe(null, "browser-glue-test", "force-ui-migration");
-  is(localStore.getPersist("collapsed"), "true", "Toolbar is collapsed");
+  is(localStore.getValue("collapsed"), "true", "Toolbar is collapsed");
 },
 
 function test_customized_toolbar()
 {
   info("A customized toolbar should be uncollapsed.");
-  localStore.setPersist("currentset", "splitter");
+  localStore.setValue("currentset", "splitter");
   bg.observe(null, "browser-glue-test", "force-ui-migration");
-  is(localStore.getPersist("collapsed"), "false", "Toolbar has been uncollapsed");
+  is(localStore.getValue("collapsed"), "false", "Toolbar has been uncollapsed");
 },
 
 function test_many_bookmarks_toolbar()
 {
   info("A toolbar with added bookmarks should be uncollapsed.");
   let ids = [];
   ids.push(
     PlacesUtils.bookmarks.insertSeparator(PlacesUtils.toolbarFolderId,
@@ -93,43 +56,47 @@ function test_many_bookmarks_toolbar()
   ids.push(
     PlacesUtils.bookmarks.insertSeparator(PlacesUtils.toolbarFolderId,
                                           PlacesUtils.bookmarks.DEFAULT_INDEX)
   );
   ids.push(
     PlacesUtils.bookmarks.insertSeparator(PlacesUtils.toolbarFolderId,
                                           PlacesUtils.bookmarks.DEFAULT_INDEX)
   );
+  ids.push(
+    PlacesUtils.bookmarks.insertSeparator(PlacesUtils.toolbarFolderId,
+                                          PlacesUtils.bookmarks.DEFAULT_INDEX)
+  );
   bg.observe(null, "browser-glue-test", "force-ui-migration");
-  is(localStore.getPersist("collapsed"), "false", "Toolbar has been uncollapsed");
+  is(localStore.getValue("collapsed"), "false", "Toolbar has been uncollapsed");
 },
 
 ];
 
 function test()
 {
   gOriginalMigrationVersion = Services.prefs.getIntPref("browser.migration.version");
   registerCleanupFunction(clean);
 
-  if (localStore.getPersist("currentset") !== null) {
+  if (localStore.getValue("currentset") !== null) {
     info("Toolbar currentset was persisted by a previous test, fixing it.");
-    localStore.setPersist("currentset", null);
+    localStore.setValue("currentset", null);
   }
 
-  if (localStore.getPersist("collapsed") !== null) {
+  if (localStore.getValue("collapsed") !== null) {
     info("Toolbar collapsed status was persisted by a previous test, fixing it.");
-    localStore.setPersist("collapsed", null);
+    localStore.setValue("collapsed", null);
   }
 
   while (gTests.length) {
     clean();
     Services.prefs.setIntPref("browser.migration.version", 4);
     gTests.shift().call();
   }
 }
 
 function clean()
 {
   Services.prefs.setIntPref("browser.migration.version", gOriginalMigrationVersion);
-  localStore.setPersist("currentset", null);
-  localStore.setPersist("collapsed", null);
+  localStore.setValue("currentset", null);
+  localStore.setValue("collapsed", null);
 }
 

--- a/browser/components/search/test/browser_426329.js
+++ b/browser/components/search/test/browser_426329.js
@@ -2,298 +2,304 @@
 // we only need ChromeUtils.js for a few files which is why we are using loadSubScript.
 var ChromeUtils = {};
 this._scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
                      getService(Ci.mozIJSSubScriptLoader);
 this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/ChromeUtils.js", ChromeUtils);
 
 XPCOMUtils.defineLazyModuleGetter(this, "FormHistory",
   "resource://gre/modules/FormHistory.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+  "resource://gre/modules/Promise.jsm");
 
-function test() {
-  waitForExplicitFinish();
+function expectedURL(aSearchTerms) {
+  const ENGINE_HTML_BASE = "http://mochi.test:8888/browser/browser/components/search/test/test.html";
+  var textToSubURI = Cc["@mozilla.org/intl/texttosuburi;1"].
+                     getService(Ci.nsITextToSubURI);
+  var searchArg = textToSubURI.ConvertAndEscape("utf-8", aSearchTerms);
+  return ENGINE_HTML_BASE + "?test=" + searchArg;
+}
 
-  const ENGINE_HTML_BASE = "http://mochi.test:8888/browser/browser/components/search/test/test.html";
+function simulateClick(aEvent, aTarget) {
+  var event = document.createEvent("MouseEvent");
+  var ctrlKeyArg  = aEvent.ctrlKey  || false;
+  var altKeyArg   = aEvent.altKey   || false;
+  var shiftKeyArg = aEvent.shiftKey || false;
+  var metaKeyArg  = aEvent.metaKey  || false;
+  var buttonArg   = aEvent.button   || 0;
+  event.initMouseEvent("click", true, true, window,
+                        0, 0, 0, 0, 0,
+                        ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg,
+                        buttonArg, null);
+  aTarget.dispatchEvent(event);
+}
+
+// modified from toolkit/components/satchel/test/test_form_autocomplete.html
+function checkMenuEntries(expectedValues) {
+  var actualValues = getMenuEntries();
+  is(actualValues.length, expectedValues.length, "Checking length of expected menu");
+  for (var i = 0; i < expectedValues.length; i++)
+    is(actualValues[i], expectedValues[i], "Checking menu entry #" + i);
+}
 
-  var searchEntries = ["test", "More Text", "Some Text"];
-  var searchBar = BrowserSearch.searchBar;
-  var searchButton = document.getAnonymousElementByAttribute(searchBar,
-                     "anonid", "search-go-button");
-  ok(searchButton, "got search-go-button");
+function getMenuEntries() {
+  var entries = [];
+  var autocompleteMenu = searchBar.textbox.popup;
+  // Could perhaps pull values directly from the controller, but it seems
+  // more reliable to test the values that are actually in the tree?
+  var column = autocompleteMenu.tree.columns[0];
+  var numRows = autocompleteMenu.tree.view.rowCount;
+  for (var i = 0; i < numRows; i++) {
+    entries.push(autocompleteMenu.tree.view.getValueAt(i, column));
+  }
+  return entries;
+}
 
-  searchBar.value = "test";
+function* countEntries(name, value) {
+  let deferred = Promise.defer();
+  let count = 0;
+  let obj = name && value ? {fieldname: name, value: value} : {};
+  FormHistory.count(obj,
+                    { handleResult: function(result) { count = result; },
+                      handleError: function(error) { throw error; },
+                      handleCompletion: function(reason) {
+                        if (!reason) {
+                          deferred.resolve(count);
+                        }
+                      }
+                    });
+  return deferred.promise;
+}
 
+var searchBar;
+var searchButton;
+var searchEntries = ["test", "More Text", "Some Text"];
+function* promiseSetEngine() {
+  let deferred = Promise.defer();
   var ss = Services.search;
 
-  let testIterator;
-
   function observer(aSub, aTopic, aData) {
     switch (aData) {
       case "engine-added":
         var engine = ss.getEngineByName("Bug 426329");
         ok(engine, "Engine was added.");
         ss.currentEngine = engine;
         break;
       case "engine-current":
         ok(ss.currentEngine.name == "Bug 426329", "currentEngine set");
-        testReturn();
-        break;
-      case "engine-removed":
+        searchBar = BrowserSearch.searchBar;
+        searchButton = document.getAnonymousElementByAttribute(searchBar,
+                           "anonid", "search-go-button");
+        ok(searchButton, "got search-go-button");
+        searchBar.value = "test";
+
         Services.obs.removeObserver(observer, "browser-search-engine-modified");
-        finish();
+        deferred.resolve();
         break;
     }
-  }
+  };
 
   Services.obs.addObserver(observer, "browser-search-engine-modified", false);
   ss.addEngine("http://mochi.test:8888/browser/browser/components/search/test/426329.xml",
                Ci.nsISearchEngine.DATA_XML, "data:image/x-icon,%00",
                false);
 
-  var preSelectedBrowser, preTabNo;
-  function init() {
-    preSelectedBrowser = gBrowser.selectedBrowser;
-    preTabNo = gBrowser.tabs.length;
-    searchBar.focus();
-  }
-
-  function testReturn() {
-    init();
-    EventUtils.synthesizeKey("VK_RETURN", {});
-    doOnloadOnce(function(event) {
+  return deferred.promise;
+}
 
-      is(gBrowser.tabs.length, preTabNo, "Return key did not open new tab");
-      is(event.originalTarget, preSelectedBrowser.contentDocument,
-         "Return key loaded results in current tab");
-      is(event.originalTarget.URL, expectedURL(searchBar.value), "testReturn opened correct search page");
-
-      testAltReturn();
-    });
-  }
-
-  function testAltReturn() {
-    init();
-    EventUtils.synthesizeKey("VK_RETURN", { altKey: true });
-    doOnloadOnce(function(event) {
+function* promiseRemoveEngine() {
+  let deferred = Promise.defer();
+  var ss = Services.search;
 
-      is(gBrowser.tabs.length, preTabNo + 1, "Alt+Return key added new tab");
-      isnot(event.originalTarget, preSelectedBrowser.contentDocument,
-            "Alt+Return key loaded results in new tab");
-      is(event.originalTarget, gBrowser.contentDocument,
-         "Alt+Return key loaded results in foreground tab");
-      is(event.originalTarget.URL, expectedURL(searchBar.value), "testAltReturn opened correct search page");
-
-      //Shift key has no effect for now, so skip it
-      //testShiftAltReturn();
-      testLeftClick();
-    });
-  }
+  function observer(aSub, aTopic, aData) {
+    if (aData == "engine-removed") {
+      Services.obs.removeObserver(observer, "browser-search-engine-modified");
+      deferred.resolve();
+    }
+  };
 
-  function testShiftAltReturn() {
-    init();
-    EventUtils.synthesizeKey("VK_RETURN", { shiftKey: true, altKey: true });
-    doOnloadOnce(function(event) {
+  Services.obs.addObserver(observer, "browser-search-engine-modified", false);
+  var engine = ss.getEngineByName("Bug 426329");
+  ss.removeEngine(engine);
 
-      is(gBrowser.tabs.length, preTabNo + 1, "Shift+Alt+Return key added new tab");
-      isnot(event.originalTarget, preSelectedBrowser.contentDocument,
-            "Shift+Alt+Return key loaded results in new tab");
-      isnot(event.originalTarget, gBrowser.contentDocument,
-            "Shift+Alt+Return key loaded results in background tab");
-      is(event.originalTarget.URL, expectedURL(searchBar.value), "testShiftAltReturn opened correct search page");
-
-      testLeftClick();
-    });
-  }
-
-  function testLeftClick() {
-    init();
-    simulateClick({ button: 0 }, searchButton);
-    doOnloadOnce(function(event) {
+  return deferred.promise;
+}
 
-      is(gBrowser.tabs.length, preTabNo, "LeftClick did not open new tab");
-      is(event.originalTarget, preSelectedBrowser.contentDocument,
-         "LeftClick loaded results in current tab");
-      is(event.originalTarget.URL, expectedURL(searchBar.value), "testLeftClick opened correct search page");
 
-      testMiddleClick();
-    });
-  }
-
-  function testMiddleClick() {
-    init();
-    simulateClick({ button: 1 }, searchButton);
-    doOnloadOnce(function(event) {
-
-      is(gBrowser.tabs.length, preTabNo + 1, "MiddleClick added new tab");
-      isnot(event.originalTarget, preSelectedBrowser.contentDocument,
-            "MiddleClick loaded results in new tab");
-      is(event.originalTarget, gBrowser.contentDocument,
-         "MiddleClick loaded results in foreground tab");
-      is(event.originalTarget.URL, expectedURL(searchBar.value), "testMiddleClick opened correct search page");
-
-      testShiftMiddleClick();
-    });
-  }
-
-  function testShiftMiddleClick() {
-    init();
-    simulateClick({ button: 1, shiftKey: true }, searchButton);
-    doOnloadOnce(function(event) {
+var preSelectedBrowser;
+var preTabNo;
+function* prepareTest() {
+  preSelectedBrowser = gBrowser.selectedBrowser;
+  preTabNo = gBrowser.tabs.length;
+  searchBar = BrowserSearch.searchBar;
 
-      is(gBrowser.tabs.length, preTabNo + 1, "Shift+MiddleClick added new tab");
-      isnot(event.originalTarget, preSelectedBrowser.contentDocument,
-            "Shift+MiddleClick loaded results in new tab");
-      isnot(event.originalTarget, gBrowser.contentDocument,
-            "Shift+MiddleClick loaded results in background tab");
-      is(event.originalTarget.URL, expectedURL(searchBar.value), "testShiftMiddleClick opened correct search page");
-
-      testDropText();
-     });
-   }
- 
-  // prevent the search buttonmenu from opening during the drag tests
-  function stopPopup(event) { event.preventDefault(); }
+  let windowFocused = Promise.defer();
+  SimpleTest.waitForFocus(windowFocused.resolve, window);
+  yield windowFocused.promise;
 
-  function testDropText() {
-    init();
-    searchBar.addEventListener("popupshowing", stopPopup, true);
-    // drop on the search button so that we don't need to worry about the
-    // default handlers for textboxes.
-    ChromeUtils.synthesizeDrop(searchBar.searchButton, searchBar.searchButton, [[ {type: "text/plain", data: "Some Text" } ]], "copy", window);
-    doOnloadOnce(function(event) {
-      is(searchBar.value, "Some Text", "drop text/plain on searchbar");
-      testDropInternalText();
+  let deferred = Promise.defer();
+  if (document.activeElement != searchBar) {
+    searchBar.addEventListener("focus", function onFocus() {
+      searchBar.removeEventListener("focus", onFocus);
+      deferred.resolve();
     });
-  }
-
-  function testDropInternalText() {
-    init();
-    ChromeUtils.synthesizeDrop(searchBar.searchButton, searchBar.searchButton, [[ {type: "text/x-moz-text-internal", data: "More Text" } ]], "copy", window);
-    doOnloadOnce(function(event) {
-      is(searchBar.value, "More Text", "drop text/x-moz-text-internal on searchbar");
-      testDropLink();
-    });
+    searchBar.focus();
+  } else {
+    deferred.resolve();
   }
-
-  function testDropLink() {
-    init();
-    ChromeUtils.synthesizeDrop(searchBar.searchButton, searchBar.searchButton, [[ {type: "text/uri-list", data: "http://www.mozilla.org" } ]], "copy", window);
-    is(searchBar.value, "More Text", "drop text/uri-list on searchbar");
-    SimpleTest.executeSoon(testRightClick);
-  }
-
-  function testRightClick() {
-    init();
-    searchBar.removeEventListener("popupshowing", stopPopup, true);
-    content.location.href = "about:blank";
-    simulateClick({ button: 2 }, searchButton);
-    setTimeout(function() {
-      is(gBrowser.tabs.length, preTabNo, "RightClick did not open new tab");
-      is(gBrowser.currentURI.spec, "about:blank", "RightClick did nothing");
-
-      testIterator = testSearchHistory();
-      testIterator.next();
-    }, 5000);
-  }
-
-  function countEntries(name, value, message) {
-    let count = 0;
-    FormHistory.count({ fieldname: name, value: value },
-                      { handleResult: function(result) { count = result; },
-                        handleError: function(error) { throw error; },
-                        handleCompletion: function(reason) {
-                          if (!reason) {
-                            ok(count > 0, message);
-                            testIterator.next();
-                          }
-                        }
-                      });
-  }
-
-  function testSearchHistory() {
-    var textbox = searchBar._textbox;
-    for (var i = 0; i < searchEntries.length; i++) {
-      yield countEntries(textbox.getAttribute("autocompletesearchparam"), searchEntries[i],
-                         "form history entry '" + searchEntries[i] + "' should exist");
-    }
-    testAutocomplete();
-  }
-
-  function testAutocomplete() {
-    var popup = searchBar.textbox.popup;
-    popup.addEventListener("popupshown", function testACPopupShowing() {
-      popup.removeEventListener("popupshown", testACPopupShowing);
-      checkMenuEntries(searchEntries);
-      testClearHistory();
-    });
-    searchBar.textbox.showHistoryPopup();
-  }
-
-  function testClearHistory() {
-    let controller = searchBar.textbox.controllers.getControllerForCommand("cmd_clearhistory")
-    ok(controller.isCommandEnabled("cmd_clearhistory"), "Clear history command enabled");
-    controller.doCommand("cmd_clearhistory");
-    let count = 0;
-    FormHistory.count({ },
-                      { handleResult: function(result) { count = result; },
-                        handleError: function(error) { throw error; },
-                        handleCompletion: function(reason) {
-                          if (!reason) {
-                            ok(count == 0, "History cleared");
-                            finalize();
-                          }
-                        }
-                      });
-  }
-
-  function finalize() {
-    searchBar.value = "";
-    while (gBrowser.tabs.length != 1) {
-      gBrowser.removeTab(gBrowser.tabs[0]);
-    }
-    content.location.href = "about:blank";
-    var engine = ss.getEngineByName("Bug 426329");
-    ss.removeEngine(engine);
-  }
-
-  function simulateClick(aEvent, aTarget) {
-    var event = document.createEvent("MouseEvent");
-    var ctrlKeyArg  = aEvent.ctrlKey  || false;
-    var altKeyArg   = aEvent.altKey   || false;
-    var shiftKeyArg = aEvent.shiftKey || false;
-    var metaKeyArg  = aEvent.metaKey  || false;
-    var buttonArg   = aEvent.button   || 0;
-    event.initMouseEvent("click", true, true, window,
-                          0, 0, 0, 0, 0,
-                          ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg,
-                          buttonArg, null);
-    aTarget.dispatchEvent(event);
-  }
-
-  function expectedURL(aSearchTerms) {
-    var textToSubURI = Cc["@mozilla.org/intl/texttosuburi;1"].
-                       getService(Ci.nsITextToSubURI);
-    var searchArg = textToSubURI.ConvertAndEscape("utf-8", aSearchTerms);
-    return ENGINE_HTML_BASE + "?test=" + searchArg;
-  }
-
-  // modified from toolkit/components/satchel/test/test_form_autocomplete.html
-  function checkMenuEntries(expectedValues) {
-    var actualValues = getMenuEntries();
-    is(actualValues.length, expectedValues.length, "Checking length of expected menu");
-    for (var i = 0; i < expectedValues.length; i++)
-      is(actualValues[i], expectedValues[i], "Checking menu entry #" + i);
-  }
-
-  function getMenuEntries() {
-    var entries = [];
-    var autocompleteMenu = searchBar.textbox.popup;
-    // Could perhaps pull values directly from the controller, but it seems
-    // more reliable to test the values that are actually in the tree?
-    var column = autocompleteMenu.tree.columns[0];
-    var numRows = autocompleteMenu.tree.view.rowCount;
-    for (var i = 0; i < numRows; i++) {
-      entries.push(autocompleteMenu.tree.view.getValueAt(i, column));
-    }
-    return entries;
-  }
+  return deferred.promise;
 }
 
+add_task(function testSetupEngine() {
+  yield promiseSetEngine();
+});
+
+add_task(function testReturn() {
+  yield prepareTest();
+  EventUtils.synthesizeKey("VK_RETURN", {});
+  let event = yield promiseOnLoad();
+
+  is(gBrowser.tabs.length, preTabNo, "Return key did not open new tab");
+  is(event.originalTarget, preSelectedBrowser.contentDocument,
+     "Return key loaded results in current tab");
+  is(event.originalTarget.URL, expectedURL(searchBar.value), "testReturn opened correct search page");
+});
+
+add_task(function testAltReturn() {
+  yield prepareTest();
+  EventUtils.synthesizeKey("VK_RETURN", { altKey: true });
+  let event = yield promiseOnLoad();
+
+  is(gBrowser.tabs.length, preTabNo + 1, "Alt+Return key added new tab");
+  isnot(event.originalTarget, preSelectedBrowser.contentDocument,
+        "Alt+Return key loaded results in new tab");
+  is(event.originalTarget, gBrowser.contentDocument,
+     "Alt+Return key loaded results in foreground tab");
+  is(event.originalTarget.URL, expectedURL(searchBar.value), "testAltReturn opened correct search page");
+});
+
+//Shift key has no effect for now, so skip it
+add_task(function testShiftAltReturn() {
+  return;
+
+  yield prepareTest();
+  EventUtils.synthesizeKey("VK_RETURN", { shiftKey: true, altKey: true });
+  let event = yield promiseOnLoad();
+
+  is(gBrowser.tabs.length, preTabNo + 1, "Shift+Alt+Return key added new tab");
+  isnot(event.originalTarget, preSelectedBrowser.contentDocument,
+        "Shift+Alt+Return key loaded results in new tab");
+  isnot(event.originalTarget, gBrowser.contentDocument,
+        "Shift+Alt+Return key loaded results in background tab");
+  is(event.originalTarget.URL, expectedURL(searchBar.value), "testShiftAltReturn opened correct search page");
+});
+
+add_task(function testLeftClick() {
+  yield prepareTest();
+  simulateClick({ button: 0 }, searchButton);
+  let event = yield promiseOnLoad();
+  is(gBrowser.tabs.length, preTabNo, "LeftClick did not open new tab");
+  is(event.originalTarget, preSelectedBrowser.contentDocument,
+     "LeftClick loaded results in current tab");
+  is(event.originalTarget.URL, expectedURL(searchBar.value), "testLeftClick opened correct search page");
+});
+
+add_task(function testMiddleClick() {
+  yield prepareTest();
+  simulateClick({ button: 1 }, searchButton);
+  let event = yield promiseOnLoad();
+  is(gBrowser.tabs.length, preTabNo + 1, "MiddleClick added new tab");
+  isnot(event.originalTarget, preSelectedBrowser.contentDocument,
+        "MiddleClick loaded results in new tab");
+  is(event.originalTarget, gBrowser.contentDocument,
+     "MiddleClick loaded results in foreground tab");
+  is(event.originalTarget.URL, expectedURL(searchBar.value), "testMiddleClick opened correct search page");
+});
+
+add_task(function testShiftMiddleClick() {
+  yield prepareTest();
+  simulateClick({ button: 1, shiftKey: true }, searchButton);
+  let event = yield promiseOnLoad();
+  is(gBrowser.tabs.length, preTabNo + 1, "Shift+MiddleClick added new tab");
+  isnot(event.originalTarget, preSelectedBrowser.contentDocument,
+        "Shift+MiddleClick loaded results in new tab");
+  isnot(event.originalTarget, gBrowser.contentDocument,
+        "Shift+MiddleClick loaded results in background tab");
+  is(event.originalTarget.URL, expectedURL(searchBar.value), "testShiftMiddleClick opened correct search page");
+});
+
+add_task(function testDropText() {
+  yield prepareTest();
+  let promisePreventPopup = promiseEvent(searchBar, "popupshowing", true);
+  // drop on the search button so that we don't need to worry about the
+  // default handlers for textboxes.
+  ChromeUtils.synthesizeDrop(searchBar.searchButton, searchBar.searchButton, [[ {type: "text/plain", data: "Some Text" } ]], "copy", window);
+  yield promisePreventPopup;
+  let event = yield promiseOnLoad();
+  is(event.originalTarget.URL, expectedURL(searchBar.value), "testDropText opened correct search page");
+  is(searchBar.value, "Some Text", "drop text/plain on searchbar");
+});
+
+add_task(function testDropInternalText() {
+  yield prepareTest();
+  let promisePreventPopup = promiseEvent(searchBar, "popupshowing", true);
+  ChromeUtils.synthesizeDrop(searchBar.searchButton, searchBar.searchButton, [[ {type: "text/x-moz-text-internal", data: "More Text" } ]], "copy", window);
+  yield promisePreventPopup;
+  let event = yield promiseOnLoad();
+  is(event.originalTarget.URL, expectedURL(searchBar.value), "testDropInternalText opened correct search page");
+  is(searchBar.value, "More Text", "drop text/x-moz-text-internal on searchbar");
+
+  // testDropLink implicitly depended on testDropInternalText, so these two tests
+  // were merged so that if testDropInternalText failed it wouldn't cause testDropLink
+  // to fail unexplainably.
+  yield prepareTest();
+  let promisePreventPopup = promiseEvent(searchBar, "popupshowing", true);
+  ChromeUtils.synthesizeDrop(searchBar.searchButton, searchBar.searchButton, [[ {type: "text/uri-list", data: "http://www.mozilla.org" } ]], "copy", window);
+  yield promisePreventPopup;
+  is(searchBar.value, "More Text", "drop text/uri-list on searchbar shouldn't change anything");
+});
+
+add_task(function testRightClick() {
+  preTabNo = gBrowser.tabs.length;
+  content.location.href = "about:blank";
+  simulateClick({ button: 2 }, searchButton);
+  let deferred = Promise.defer();
+  setTimeout(function() {
+    is(gBrowser.tabs.length, preTabNo, "RightClick did not open new tab");
+    is(gBrowser.currentURI.spec, "about:blank", "RightClick did nothing");
+    deferred.resolve();
+  }, 5000);
+  yield deferred.promise;
+});
+
+add_task(function testSearchHistory() {
+  var textbox = searchBar._textbox;
+  for (var i = 0; i < searchEntries.length; i++) {
+    let count = yield countEntries(textbox.getAttribute("autocompletesearchparam"), searchEntries[i]);
+    ok(count > 0, "form history entry '" + searchEntries[i] + "' should exist");
+  }
+});
+
+add_task(function testAutocomplete() {
+  var popup = searchBar.textbox.popup;
+  let popupShownPromise = promiseEvent(popup, "popupshown");
+  searchBar.textbox.showHistoryPopup();
+  yield popupShownPromise;
+  checkMenuEntries(searchEntries);
+});
+
+add_task(function testClearHistory() {
+  let controller = searchBar.textbox.controllers.getControllerForCommand("cmd_clearhistory")
+  ok(controller.isCommandEnabled("cmd_clearhistory"), "Clear history command enabled");
+  controller.doCommand("cmd_clearhistory");
+  let count = yield countEntries();
+  ok(count == 0, "History cleared");
+});
+
+add_task(function asyncCleanup() {
+  searchBar.value = "";
+  while (gBrowser.tabs.length != 1) {
+    gBrowser.removeTab(gBrowser.tabs[0], {animate: false});
+  }
+  content.location.href = "about:blank";
+  yield promiseRemoveEngine();
+});
+

--- a/browser/components/search/test/head.js
+++ b/browser/components/search/test/head.js
@@ -1,11 +1,14 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/ */
 
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+  "resource://gre/modules/Promise.jsm");
+
 function whenNewWindowLoaded(aOptions, aCallback) {
   let win = OpenBrowserWindow(aOptions);
   let gotLoad = false;
   let gotActivate = Services.focus.activeWindow == win;
 
   function maybeRunCallback() {
     if (gotLoad && gotActivate) {
       executeSoon(function() { aCallback(win); });
@@ -83,16 +86,28 @@ function waitForPopupShown(aPopupId, aCa
   }
   function removePopupShownListener() {
     popup.removeEventListener("popupshown", onPopupShown);
   }
   popup.addEventListener("popupshown", onPopupShown);
   registerCleanupFunction(removePopupShownListener);
 }
 
+function* promiseEvent(aTarget, aEventName, aPreventDefault) {
+  let deferred = Promise.defer();
+  aTarget.addEventListener(aEventName, function onEvent(aEvent) {
+    aTarget.removeEventListener(aEventName, onEvent, true);
+    if (aPreventDefault) {
+      aEvent.preventDefault();
+    }
+    deferred.resolve();
+  }, true);
+  return deferred.promise;
+}
+
 function waitForBrowserContextMenu(aCallback) {
   waitForPopupShown(gBrowser.selectedBrowser.contextMenu, aCallback);
 }
 
 function doOnloadOnce(aCallback) {
   function doOnloadOnceListener(aEvent) {
     info("doOnloadOnce: " + aEvent.originalTarget.location);
     removeDoOnloadOnceListener();
@@ -101,8 +116,21 @@ function doOnloadOnce(aCallback) {
     });
   }
   function removeDoOnloadOnceListener() {
     gBrowser.removeEventListener("load", doOnloadOnceListener, true);
   }
   gBrowser.addEventListener("load", doOnloadOnceListener, true);
   registerCleanupFunction(removeDoOnloadOnceListener);
 }
+
+function* promiseOnLoad() {
+  let deferred = Promise.defer();
+
+  gBrowser.addEventListener("load", function onLoadListener(aEvent) {
+    info("onLoadListener: " + aEvent.originalTarget.location);
+    gBrowser.removeEventListener("load", onLoadListener, true);
+    deferred.resolve(aEvent);
+  }, true);
+
+  return deferred.promise;
+}
+

--- a/browser/devtools/framework/gDevTools.jsm
+++ b/browser/devtools/framework/gDevTools.jsm
@@ -17,23 +17,23 @@ XPCOMUtils.defineLazyModuleGetter(this, 
 
 XPCOMUtils.defineLazyModuleGetter(this, "console",
                                   "resource://gre/modules/devtools/Console.jsm");
 
 const EventEmitter = devtools.require("devtools/toolkit/event-emitter");
 const FORBIDDEN_IDS = new Set(["toolbox", ""]);
 const MAX_ORDINAL = 99;
 
-
 /**
  * DevTools is a class that represents a set of developer tools, it holds a
  * set of tools and keeps track of open toolboxes in the browser.
  */
 this.DevTools = function DevTools() {
   this._tools = new Map();     // Map<toolId, tool>
+  this._themes = new Map();    // Map<themeId, theme>
   this._toolboxes = new Map(); // Map<target, toolbox>
 
   // destroy() is an observer's handler so we need to preserve context.
   this.destroy = this.destroy.bind(this);
   this._teardown = this._teardown.bind(this);
 
   this._testing = false;
 
@@ -225,16 +225,146 @@ DevTools.prototype = {
         definitions.push(definition);
       }
     }
 
     return definitions.sort(this.ordinalSort);
   },
 
   /**
+   * Register a new theme for developer tools toolbox.
+   *
+   * A definition is a light object that holds various information about a
+   * theme.
+   *
+   * Each themeDefinition has the following properties:
+   * - id: Unique identifier for this theme (string|required)
+   * - label: Localized name for the theme to be displayed to the user
+   *          (string|required)
+   * - stylesheets: Array of URLs pointing to a CSS document(s) containing
+   *                the theme style rules (array|required)
+   * - classList: Array of class names identifying the theme within a document.
+   *              These names are set to document element when applying
+   *              the theme (array|required)
+   * - onApply: Function that is executed by the framework when the theme
+   *            is applied. The function takes the current iframe window
+   *            and the previous theme id as arguments (function)
+   * - onUnapply: Function that is executed by the framework when the theme
+   *            is unapplied. The function takes the current iframe window
+   *            and the new theme id as arguments (function)
+   */
+  registerTheme: function DT_registerTheme(themeDefinition) {
+    let themeId = themeDefinition.id;
+
+    if (!themeId) {
+      throw new Error("Invalid theme id");
+    }
+
+    if (this._themes.get(themeId)) {
+      throw new Error("Theme with the same id is already registered");
+    }
+
+    this._themes.set(themeId, themeDefinition);
+
+    this.emit("theme-registered", themeId);
+  },
+
+  /**
+   * Removes an existing theme from the list of registered themes.
+   * Needed so that add-ons can remove themselves when they are deactivated
+   *
+   * @param {string|object} theme
+   *        Definition or the id of the theme to unregister.
+   */
+  unregisterTheme: function DT_unregisterTheme(theme) {
+    let themeId = null;
+    if (typeof theme == "string") {
+      themeId = theme;
+      theme = this._themes.get(theme);
+    }
+    else {
+      themeId = theme.id;
+    }
+
+    let currTheme = Services.prefs.getCharPref("devtools.theme");
+
+    // Change the current theme if it's being dynamically removed together
+    // with the owner (bootstrapped) extension.
+    // But, do not change it if the application is just shutting down.
+    if (!Services.startup.shuttingDown && theme.id == currTheme) {
+      Services.prefs.setCharPref("devtools.theme", "light");
+
+      let data = {
+        pref: "devtools.theme",
+        newValue: "light",
+        oldValue: currTheme
+      };
+
+      gDevTools.emit("pref-changed", data);
+
+      this.emit("theme-unregistered", theme);
+    }
+
+    this._themes.delete(themeId);
+  },
+
+  /**
+   * Get a theme definition if it exists.
+   *
+   * @param {string} themeId
+   *        The id of the theme
+   *
+   * @return {ThemeDefinition|null} theme
+   *         The ThemeDefinition for the id or null.
+   */
+  getThemeDefinition: function DT_getThemeDefinition(themeId) {
+    let theme = this._themes.get(themeId);
+    if (!theme) {
+      return null;
+    }
+    return theme;
+  },
+
+  /**
+   * Get map of registered themes.
+   *
+   * @return {Map} themes
+   *         A map of the the theme definitions registered in this instance
+   */
+  getThemeDefinitionMap: function DT_getThemeDefinitionMap() {
+    let themes = new Map();
+
+    for (let [id, definition] of this._themes) {
+      if (this.getThemeDefinition(id)) {
+        themes.set(id, definition);
+      }
+    }
+
+    return themes;
+  },
+
+  /**
+   * Get registered themes definitions sorted by ordinal value.
+   *
+   * @return {Array} themes
+   *         A sorted array of the theme definitions registered in this instance
+   */
+  getThemeDefinitionArray: function DT_getThemeDefinitionArray() {
+    let definitions = [];
+
+    for (let [id, definition] of this._themes) {
+      if (this.getThemeDefinition(id)) {
+        definitions.push(definition);
+      }
+    }
+
+    return definitions.sort(this.ordinalSort);
+  },
+
+  /**
    * Show a Toolbox for a target (either by creating a new one, or if a toolbox
    * already exists for the target, by bring to the front the existing one)
    * If |toolId| is specified then the displayed toolbox will have the
    * specified tool selected.
    * If |hostType| is specified then the toolbox will be displayed using the
    * specified HostType.
    *
    * @param {Target} target

--- a/browser/devtools/framework/test/browser.ini
+++ b/browser/devtools/framework/test/browser.ini
@@ -1,15 +1,16 @@
 [DEFAULT]
 subsuite = devtools
 support-files =
   browser_toolbox_options_disable_js.html
   browser_toolbox_options_disable_js_iframe.html
   browser_toolbox_options_disable_cache.sjs
   head.js
+  doc_theme.css
 
 [browser_devtools_api.js]
 [browser_dynamic_tool_enabling.js]
 [browser_keybindings.js]
 [browser_new_activation_workflow.js]
 [browser_target_events.js]
 [browser_target_remote.js]
 [browser_toolbox_dynamic_registration.js]
@@ -27,12 +28,13 @@ skip-if = e10s # Bug 1030318
 [browser_toolbox_sidebar.js]
 [browser_toolbox_tabsswitch_shortcuts.js]
 [browser_toolbox_tool_ready.js]
 [browser_toolbox_window_reload_target.js]
 [browser_toolbox_window_shortcuts.js]
 [browser_toolbox_window_title_changes.js]
 [browser_toolbox_zoom.js]
 [browser_toolbox_custom_host.js]
+[browser_toolbox_theme_registration.js]
 
 # We want this test to run for mochitest-dt as well, so we include it here:
 [../../../base/content/test/general/browser_parsable_css.js]
 

new file mode 100644
--- /dev/null
+++ b/browser/devtools/framework/test/browser_toolbox_theme_registration.js
@@ -0,0 +1,113 @@
+/* vim: set ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const CHROME_URL = "chrome://mochitests/content/browser/browser/devtools/framework/test/";
+
+let toolbox;
+
+function test()
+{
+  gBrowser.selectedTab = gBrowser.addTab();
+  let target = TargetFactory.forTab(gBrowser.selectedTab);
+
+  gBrowser.selectedBrowser.addEventListener("load", function onLoad(evt) {
+    gBrowser.selectedBrowser.removeEventListener(evt.type, onLoad, true);
+    gDevTools.showToolbox(target).then(testRegister);
+  }, true);
+
+  content.location = "data:text/html,test for dynamically registering and unregistering themes";
+}
+
+function testRegister(aToolbox)
+{
+  toolbox = aToolbox
+  gDevTools.once("theme-registered", themeRegistered);
+
+  gDevTools.registerTheme({
+    id: "test-theme",
+    label: "Test theme",
+    stylesheets: [CHROME_URL + "doc_theme.css"],
+    classList: ["theme-test"],
+  });
+}
+
+function themeRegistered(event, themeId)
+{
+  is(themeId, "test-theme", "theme-registered event handler sent theme id");
+
+  ok(gDevTools.getThemeDefinitionMap().has(themeId), "theme added to map");
+
+  // Test that new theme appears in the Options panel
+  let target = TargetFactory.forTab(gBrowser.selectedTab);
+  gDevTools.showToolbox(target, "options").then(() => {
+    let panel = toolbox.getCurrentPanel();
+    let doc = panel.panelWin.frameElement.contentDocument;
+    let themeOption = doc.querySelector("#devtools-theme-box > radio[value=test-theme]");
+
+    ok(themeOption, "new theme exists in the Options panel");
+
+    // Apply the new theme.
+    applyTheme();
+  });
+}
+
+function applyTheme()
+{
+  let panelWin = toolbox.getCurrentPanel().panelWin;
+  let doc = panelWin.frameElement.contentDocument;
+  let testThemeOption = doc.querySelector("#devtools-theme-box > radio[value=test-theme]");
+  let lightThemeOption = doc.querySelector("#devtools-theme-box > radio[value=light]");
+
+  let color = panelWin.getComputedStyle(testThemeOption).color;
+  isnot(color, "rgb(255, 0, 0)", "style unapplied");
+
+  // Select test theme.
+  testThemeOption.click();
+
+  let color = panelWin.getComputedStyle(testThemeOption).color;
+  is(color, "rgb(255, 0, 0)", "style applied");
+
+  // Select light theme
+  lightThemeOption.click();
+
+  let color = panelWin.getComputedStyle(testThemeOption).color;
+  isnot(color, "rgb(255, 0, 0)", "style unapplied");
+
+  // Select test theme again.
+  testThemeOption.click();
+
+  // Then unregister the test theme.
+  testUnregister();
+}
+
+function testUnregister()
+{
+  gDevTools.unregisterTheme("test-theme");
+
+  ok(!gDevTools.getThemeDefinitionMap().has("test-theme"), "theme removed from map");
+
+  let panelWin = toolbox.getCurrentPanel().panelWin;
+  let doc = panelWin.frameElement.contentDocument;
+  let themeBox = doc.querySelector("#devtools-theme-box");
+
+  // The default light theme must be selected now.
+  is(themeBox.selectedItem, themeBox.querySelector("[value=light]"),
+    "theme light must be selected");
+
+  // Make sure the tab-attaching process is done before we destroy the toolbox.
+  let target = TargetFactory.forTab(gBrowser.selectedTab);
+  let actor = target.activeTab.actor;
+  target.client.attachTab(actor, (response) => {
+    cleanup();
+  });
+}
+
+function cleanup()
+{
+  toolbox.destroy().then(function() {
+    toolbox = null;
+    gBrowser.removeCurrentTab();
+    finish();
+  });
+}

new file mode 100644
--- /dev/null
+++ b/browser/devtools/framework/test/doc_theme.css
@@ -0,0 +1,3 @@
+.theme-test #devtools-theme-box radio {
+  color: red !important;
+}

--- a/browser/devtools/framework/toolbox-options.js
+++ b/browser/devtools/framework/toolbox-options.js
@@ -70,16 +70,18 @@ function InfallibleGetBoolPref(key) {
  */
 function OptionsPanel(iframeWindow, toolbox) {
   this.panelDoc = iframeWindow.document;
   this.panelWin = iframeWindow;
   this.toolbox = toolbox;
   this.isReady = false;
 
   this._prefChanged = this._prefChanged.bind(this);
+  this._themeRegistered = this._themeRegistered.bind(this);
+  this._themeUnregistered = this._themeUnregistered.bind(this);
 
   this._addListeners();
 
   const EventEmitter = require("devtools/toolkit/event-emitter");
   EventEmitter.decorate(this);
 }
 
 OptionsPanel.prototype = {
@@ -96,17 +98,19 @@ OptionsPanel.prototype = {
       targetPromise = this.target.makeRemote();
     } else {
       targetPromise = promise.resolve(this.target);
     }
 
     return targetPromise.then(() => {
       this.setupToolsList();
       this.setupToolbarButtonsList();
+      this.setupThemeList();
       this.populatePreferences();
+      this.updateDefaultTheme();
 
       this._disableJSClicked = this._disableJSClicked.bind(this);
 
       let disableJSNode = this.panelDoc.getElementById("devtools-disable-javascript");
       disableJSNode.addEventListener("click", this._disableJSClicked, false);
     }).then(() => {
       this.isReady = true;
       this.emit("ready");
@@ -114,29 +118,49 @@ OptionsPanel.prototype = {
     }).then(null, function onError(aReason) {
       Cu.reportError("OptionsPanel open failed. " +
                      aReason.error + ": " + aReason.message);
     });
   },
 
   _addListeners: function() {
     gDevTools.on("pref-changed", this._prefChanged);
+    gDevTools.on("theme-registered", this._themeRegistered);
+    gDevTools.on("theme-unregistered", this._themeUnregistered);
   },
 
   _removeListeners: function() {
     gDevTools.off("pref-changed", this._prefChanged);
+    gDevTools.off("theme-registered", this._themeRegistered);
+    gDevTools.off("theme-unregistered", this._themeUnregistered);
   },
 
   _prefChanged: function(event, data) {
     if (data.pref === "devtools.cache.disabled") {
       let cacheDisabled = data.newValue;
       let cbx = this.panelDoc.getElementById("devtools-disable-cache");
 
       cbx.checked = cacheDisabled;
     }
+    else if (data.pref === "devtools.theme") {
+      this.updateCurrentTheme();
+    }
+  },
+
+  _themeRegistered: function(event, themeId) {
+    this.setupThemeList();
+  },
+
+  _themeUnregistered: function(event, theme) {
+    let themeBox = this.panelDoc.getElementById("devtools-theme-box");
+    let themeOption = themeBox.querySelector("[value=" + theme.id + "]");
+
+    if (themeOption) {
+      themeBox.removeChild(themeOption);
+    }
   },
 
   setupToolbarButtonsList: function() {
     let enabledToolbarButtonsBox = this.panelDoc.getElementById("enabled-toolbox-buttons-box");
     enabledToolbarButtonsBox.textContent = "";
 
     let toggleableButtons = this.toolbox.toolboxButtons;
     let setToolboxButtonsVisibility =
@@ -224,16 +248,36 @@ OptionsPanel.prototype = {
 
     if (!atleastOneToolNotSupported) {
       toolsNotSupportedLabel.style.display = "none";
     }
 
     this.panelWin.focus();
   },
 
+  setupThemeList: function() {
+    let themeBox = this.panelDoc.getElementById("devtools-theme-box");
+    themeBox.textContent = "";
+
+    let createThemeOption = theme => {
+      let radio = this.panelDoc.createElement("radio");
+      radio.setAttribute("value", theme.id);
+      radio.setAttribute("label", theme.label);
+      return radio;
+    };
+
+    // Populating the default theme list
+    let themes = gDevTools.getThemeDefinitionArray();
+    for (let theme of themes) {
+      themeBox.appendChild(createThemeOption(theme));
+    }
+
+    this.updateCurrentTheme();
+  },
+
   populatePreferences: function() {
     let prefCheckboxes = this.panelDoc.querySelectorAll("checkbox[data-pref]");
     for (let checkbox of prefCheckboxes) {
       checkbox.checked = GetPref(checkbox.getAttribute("data-pref"));
       checkbox.addEventListener("command", function() {
         let data = {
           pref: this.getAttribute("data-pref"),
           newValue: this.checked
@@ -253,19 +297,23 @@ OptionsPanel.prototype = {
           break;
         }
       }
       radiogroup.addEventListener("select", function() {
         let data = {
           pref: this.getAttribute("data-pref"),
           newValue: this.selectedItem.getAttribute("value")
         };
+
         data.oldValue = GetPref(data.pref);
         SetPref(data.pref, data.newValue);
-        gDevTools.emit("pref-changed", data);
+
+        if (data.newValue != data.oldValue) {
+          gDevTools.emit("pref-changed", data);
+        }
       }.bind(radiogroup));
     }
     let prefMenulists = this.panelDoc.querySelectorAll("menulist[data-pref]");
     for (let menulist of prefMenulists) {
       let pref = GetPref(menulist.getAttribute("data-pref"));
       let menuitems = menulist.querySelectorAll("menuitem");
       for (let menuitem of menuitems) {
         let value = menuitem.value;
@@ -287,16 +335,35 @@ OptionsPanel.prototype = {
 
     this.target.client.attachTab(this.target.activeTab._actor, (response) => {
       this._origJavascriptEnabled = response.javascriptEnabled;
 
       this._populateDisableJSCheckbox();
     });
   },
 
+  updateDefaultTheme: function() {
+    // Make sure a theme is set in case the previous one coming from
+    // an extension isn't available anymore.
+    let themeBox = this.panelDoc.getElementById("devtools-theme-box");
+    if (themeBox.selectedIndex == -1) {
+      themeBox.selectedItem = themeBox.querySelector("[value=light]");
+    }
+  },
+
+  updateCurrentTheme: function() {
+    let currentTheme = GetPref("devtools.theme");
+    let themeBox = this.panelDoc.getElementById("devtools-theme-box");
+    let themeOption = themeBox.querySelector("[value=" + currentTheme + "]");
+
+    if (themeOption) {
+      themeBox.selectedItem = themeOption;
+    }
+  },
+
   _populateDisableJSCheckbox: function() {
     let cbx = this.panelDoc.getElementById("devtools-disable-javascript");
     cbx.checked = !this._origJavascriptEnabled;
   },
 
   /**
    * Disables JavaScript for the currently loaded tab. We force a page refresh
    * here because setting docShell.allowJavascript to true fails to block JS

--- a/browser/devtools/framework/toolbox-options.xul
+++ b/browser/devtools/framework/toolbox-options.xul
@@ -28,18 +28,16 @@
 
       </vbox>
       <vbox class="options-vertical-pane" flex="1">
         <label>&options.selectDevToolsTheme.label;</label>
         <radiogroup id="devtools-theme-box"
                     class="options-groupbox"
                     data-pref="devtools.theme"
                     orient="horizontal">
-          <radio value="light" label="&options.lightTheme.label;"/>
-          <radio value="dark" label="&options.darkTheme.label;"/>
         </radiogroup>
         <label>&options.commonPrefs.label;</label>
         <vbox id="commonprefs-options" class="options-groupbox">
           <checkbox label="&options.enablePersistentLogs.label;"
                     tooltiptext="&options.enablePersistentLogs.tooltip;"
                     data-pref="devtools.webconsole.persistlog"/>
         </vbox>
         <label>&options.context.inspector;</label>

--- a/browser/devtools/main.js
+++ b/browser/devtools/main.js
@@ -352,23 +352,51 @@ let defaultTools = [
 ];
 
 exports.defaultTools = defaultTools;
 
 for (let definition of defaultTools) {
   gDevTools.registerTool(definition);
 }
 
+Tools.darkTheme = {
+  id: "dark",
+  label: l10n("options.darkTheme.label", toolboxStrings),
+  ordinal: 1,
+  stylesheets: ["chrome://browser/skin/devtools/dark-theme.css"],
+  classList: ["theme-dark"],
+};
+
+Tools.lightTheme = {
+  id: "light",
+  label: l10n("options.lightTheme.label", toolboxStrings),
+  ordinal: 2,
+  stylesheets: ["chrome://browser/skin/devtools/light-theme.css"],
+  classList: ["theme-light"],
+};
+
+let defaultThemes = [
+  Tools.darkTheme,
+  Tools.lightTheme,
+];
+
+for (let definition of defaultThemes) {
+  gDevTools.registerTheme(definition);
+}
+
 var unloadObserver = {
   observe: function(subject, topic, data) {
     if (subject.wrappedJSObject === require("@loader/unload")) {
       Services.obs.removeObserver(unloadObserver, "sdk:loader:destroy");
       for (let definition of gDevTools.getToolDefinitionArray()) {
         gDevTools.unregisterTool(definition.id);
       }
+      for (let definition of gDevTools.getThemeDefinitionArray()) {
+        gDevTools.unregisterTheme(definition.id);
+      }
     }
   }
 };
 Services.obs.addObserver(unloadObserver, "sdk:loader:destroy", false);
 
 events.emit("devtools-loaded", {});
 
 /**

--- a/browser/devtools/shared/frame-script-utils.js
+++ b/browser/devtools/shared/frame-script-utils.js
@@ -1,18 +1,28 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 "use strict";
 
+let { utils: Cu, interfaces: Ci } = Components;
+
 addMessageListener("devtools:test:history", function ({ data }) {
   content.history[data.direction]();
 });
 
 addMessageListener("devtools:test:navigate", function ({ data }) {
   content.location = data.location;
 });
 
 addMessageListener("devtools:test:reload", function ({ data }) {
   data = data || {};
   content.location.reload(data.forceget);
 });
+
+addMessageListener("devtools:test:forceCC", function () {
+  let DOMWindowUtils = content.QueryInterface(Ci.nsIInterfaceRequestor)
+    .getInterface(Ci.nsIDOMWindowUtils)
+  DOMWindowUtils.cycleCollect();
+  DOMWindowUtils.garbageCollect();
+  DOMWindowUtils.garbageCollect();
+});

--- a/browser/devtools/shared/theme-switching.js
+++ b/browser/devtools/shared/theme-switching.js
@@ -19,34 +19,45 @@
     documentElement.style.display = display; // Restore
   }
 
   function switchTheme(newTheme, oldTheme) {
     if (newTheme === oldTheme) {
       return;
     }
 
-    if (oldTheme && newTheme != oldTheme) {
-      StylesheetUtils.removeSheet(
-        window,
-        DEVTOOLS_SKIN_URL + oldTheme + "-theme.css",
-        "author"
-      );
+    let oldThemeDef = gDevTools.getThemeDefinition(oldTheme);
+    let newThemeDef = gDevTools.getThemeDefinition(newTheme);
+
+    // Unload all theme stylesheets related to the old theme.
+    if (oldThemeDef) {
+      for (let url of oldThemeDef.stylesheets) {
+        StylesheetUtils.removeSheet(window, url, "author");
+      }
     }
 
-    StylesheetUtils.loadSheet(
-      window,
-      DEVTOOLS_SKIN_URL + newTheme + "-theme.css",
-      "author"
-    );
+    // Load all stylesheets associated with the new theme.
+    let newThemeDef = gDevTools.getThemeDefinition(newTheme);
 
-    // Floating scrollbars à la osx
+    // The theme might not be available anymore (e.g. uninstalled)
+    // Use the default one.
+    if (!newThemeDef) {
+      newThemeDef = gDevTools.getThemeDefinition("light");
+    }
+
+    for (let url of newThemeDef.stylesheets) {
+      StylesheetUtils.loadSheet(window, url, "author");
+    }
+
+    // Floating scroll-bars like in OSX
     let hiddenDOMWindow = Cc["@mozilla.org/appshell/appShellService;1"]
                  .getService(Ci.nsIAppShellService)
                  .hiddenDOMWindow;
+
+    // TODO: extensions might want to customize scrollbar styles too.
     if (!hiddenDOMWindow.matchMedia("(-moz-overlay-scrollbars)").matches) {
       let scrollbarsUrl = Services.io.newURI(
         DEVTOOLS_SKIN_URL + "floating-scrollbars-light.css", null, null);
 
       if (newTheme == "dark") {
         StylesheetUtils.loadSheet(
           window,
           scrollbarsUrl,
@@ -57,18 +68,36 @@
           window,
           scrollbarsUrl,
           "agent"
         );
       }
       forceStyle();
     }
 
-    documentElement.classList.remove("theme-" + oldTheme);
-    documentElement.classList.add("theme-" + newTheme);
+    if (oldThemeDef) {
+      for (let name of oldThemeDef.classList) {
+        documentElement.classList.remove(name);
+      }
+
+      if (oldThemeDef.onUnapply) {
+        oldThemeDef.onUnapply(window, newTheme);
+      }
+    }
+
+    for (let name of newThemeDef.classList) {
+      documentElement.classList.add(name);
+    }
+
+    if (newThemeDef.onApply) {
+      newThemeDef.onApply(window, oldTheme);
+    }
+
+    // Final notification for further theme-switching related logic.
+    gDevTools.emit("theme-switched", window, newTheme, oldTheme);
   }
 
   function handlePrefChange(event, data) {
     if (data.pref == "devtools.theme") {
       switchTheme(data.newValue, data.oldValue);
     }
   }
 

--- a/browser/devtools/webaudioeditor/test/browser.ini
+++ b/browser/devtools/webaudioeditor/test/browser.ini
@@ -5,28 +5,33 @@ support-files =
   doc_complex-context.html
   doc_simple-node-creation.html
   doc_buffer-and-array.html
   doc_media-node-creation.html
   doc_destroy-nodes.html
   doc_connect-toggle.html
   doc_connect-param.html
   doc_connect-multi-param.html
+  doc_change-param.html
   440hz_sine.ogg
   head.js
 
-[browser_audionode-actor-get-set-param.js]
-[browser_audionode-actor-get-type.js]
+[browser_audionode-actor-get-param-flags.js]
 [browser_audionode-actor-get-params-01.js]
 [browser_audionode-actor-get-params-02.js]
-[browser_audionode-actor-get-param-flags.js]
+[browser_audionode-actor-get-set-param.js]
+[browser_audionode-actor-get-type.js]
 [browser_audionode-actor-is-source.js]
+
+[browser_webaudio-actor-change-params-01.js]
+[browser_webaudio-actor-change-params-02.js]
+[browser_webaudio-actor-change-params-03.js]
+[browser_webaudio-actor-connect-param.js]
+[browser_webaudio-actor-destroy-node.js]
 [browser_webaudio-actor-simple.js]
-[browser_webaudio-actor-destroy-node.js]
-[browser_webaudio-actor-connect-param.js]
 
 [browser_wa_destroy-node-01.js]
 
 [browser_wa_first-run.js]
 [browser_wa_reset-01.js]
 [browser_wa_reset-02.js]
 [browser_wa_reset-03.js]
 
@@ -43,9 +48,10 @@ support-files =
 [browser_wa_inspector-toggle.js]
 
 [browser_wa_properties-view.js]
 [browser_wa_properties-view-media-nodes.js]
 # [browser_wa_properties-view-edit-01.js]
 # [browser_wa_properties-view-edit-02.js]
 # Disabled for too many intermittents bug 1010423
 [browser_wa_properties-view-params.js]
+[browser_wa_properties-view-change-params.js]
 [browser_wa_properties-view-params-objects.js]

new file mode 100644
--- /dev/null
+++ b/browser/devtools/webaudioeditor/test/browser_wa_properties-view-change-params.js
@@ -0,0 +1,46 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Tests that params view correctly updates changed parameters
+ * when source code updates them, as well as CHANGE_PARAM events.
+ */
+
+function spawnTest() {
+  let [target, debuggee, panel] = yield initWebAudioEditor(CHANGE_PARAM_URL);
+  let { panelWin } = panel;
+  let { gFront, $, $$, EVENTS, WebAudioInspectorView } = panelWin;
+  let gVars = WebAudioInspectorView._propsView;
+
+  // Set parameter polling to 20ms for tests
+  panelWin.PARAM_POLLING_FREQUENCY = 20;
+
+  let started = once(gFront, "start-context");
+
+  reload(target);
+
+  let [actors] = yield Promise.all([
+    getN(gFront, "create-node", 3),
+    waitForGraphRendered(panelWin, 3, 0)
+  ]);
+
+  let oscId = actors[1].actorID;
+
+  click(panelWin, findGraphNode(panelWin, oscId));
+  yield once(panelWin, EVENTS.UI_INSPECTOR_NODE_SET);
+
+  // Yield twice so we get a diff
+  yield once(panelWin, EVENTS.CHANGE_PARAM);
+  let [[_, args]] = yield getSpread(panelWin, EVENTS.CHANGE_PARAM);
+  is(args.actorID, oscId, "EVENTS.CHANGE_PARAM has correct `actorID`");
+  ok(args.oldValue < args.newValue, "EVENTS.CHANGE_PARAM has correct `newValue` and `oldValue`");
+  is(args.param, "detune", "EVENTS.CHANGE_PARAM has correct `param`");
+
+  let [[_, args]] = yield getSpread(panelWin, EVENTS.CHANGE_PARAM);
+  checkVariableView(gVars, 0, { "detune": args.newValue }, "`detune` parameter updated.");
+  let [[_, args]] = yield getSpread(panelWin, EVENTS.CHANGE_PARAM);
+  checkVariableView(gVars, 0, { "detune": args.newValue }, "`detune` parameter updated.");
+
+  yield teardown(panel);
+  finish();
+}

new file mode 100644
--- /dev/null
+++ b/browser/devtools/webaudioeditor/test/browser_webaudio-actor-change-params-01.js
@@ -0,0 +1,46 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Test WebAudioActor `change-param` events and front.[en|dis]ableChangeParamEvents
+ */
+
+function spawnTest () {
+  let [target, debuggee, front] = yield initBackend(CHANGE_PARAM_URL);
+  let [_, nodes] = yield Promise.all([
+    front.setup({ reload: true }),
+    getN(front, "create-node", 3)
+  ]);
+
+  let osc = nodes[1];
+  let eventCount = 0;
+
+  yield front.enableChangeParamEvents(osc, 20);
+
+  front.on("change-param", onChangeParam);
+
+  yield getN(front, "change-param", 3);
+  yield front.disableChangeParamEvents();
+
+  let currEventCount = eventCount;
+
+  // Be flexible here incase we get an extra counter before the listener is turned off
+  ok(eventCount >= 3, "Calling `enableChangeParamEvents` should allow front to emit `change-param`.");
+
+  yield wait(100);
+
+  ok((eventCount - currEventCount) <= 2, "Calling `disableChangeParamEvents` should turn off the listener.");
+
+  front.off("change-param", onChangeParam);
+
+  yield removeTab(target.tab);
+  finish();
+
+  function onChangeParam ({ newValue, oldValue, param, actorID }) {
+    is(actorID, osc.actorID, "correct `actorID` in `change-param`.");
+    is(param, "detune", "correct `param` property in `change-param`.");
+    ok(newValue > oldValue,
+      "correct `newValue` (" + newValue + ") and `oldValue` (" + oldValue + ") in `change-param`");
+    eventCount++;
+  }
+}

new file mode 100644
--- /dev/null
+++ b/browser/devtools/webaudioeditor/test/browser_webaudio-actor-change-params-02.js
@@ -0,0 +1,36 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Test that listening to param change polling does not break when the AudioNode is collected.
+ */
+
+function spawnTest () {
+  let [target, debuggee, front] = yield initBackend(DESTROY_NODES_URL);
+  let waitUntilDestroyed = getN(front, "destroy-node", 10);
+  let [_, nodes] = yield Promise.all([
+    front.setup({ reload: true }),
+    getN(front, "create-node", 13)
+  ]);
+
+  let bufferNode = nodes[6];
+
+  yield front.enableChangeParamEvents(bufferNode, 20);
+
+  front.on("change-param", onChangeParam);
+
+  forceCC();
+
+  yield waitUntilDestroyed;
+  yield wait(50);
+
+  front.off("change-param", onChangeParam);
+
+  ok(true, "listening to `change-param` on a dead node doesn't throw.");
+  yield removeTab(target.tab);
+  finish();
+
+  function onChangeParam (args) {
+    ok(false, "`change-param` should not be emitted on a node that hasn't changed params or is dead.");
+  }
+}

new file mode 100644
--- /dev/null
+++ b/browser/devtools/webaudioeditor/test/browser_webaudio-actor-change-params-03.js
@@ -0,0 +1,32 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Test WebAudioActor `change-param` events on special types.
+ */
+
+function spawnTest () {
+  let [target, debuggee, front] = yield initBackend(CHANGE_PARAM_URL);
+  let [_, nodes] = yield Promise.all([
+    front.setup({ reload: true }),
+    getN(front, "create-node", 3)
+  ]);
+
+  let shaper = nodes[2];
+  let eventCount = 0;
+
+  yield front.enableChangeParamEvents(shaper, 20);
+
+  let onChange = once(front, "change-param");
+
+  shaper.setParam("curve", null);
+
+  let { newValue, oldValue } = yield onChange;
+
+  is(oldValue.type, "object", "`oldValue` should be an object.");
+  is(oldValue.class, "Float32Array", "`oldValue` should be of class Float32Array.");
+  is(newValue.type, "null", "`newValue` should be null.");
+
+  yield removeTab(target.tab);
+  finish();
+}

new file mode 100644
--- /dev/null
+++ b/browser/devtools/webaudioeditor/test/doc_change-param.html
@@ -0,0 +1,25 @@
+<!-- Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/ -->
+<!doctype html>
+
+<html>
+  <head>
+    <meta charset="utf-8"/>
+    <title>Web Audio Editor test page</title>
+  </head>
+
+  <body>
+
+    <script type="text/javascript;version=1.8">
+      "use strict";
+
+      let ctx = new AudioContext();
+      let osc = ctx.createOscillator();
+      let shaperNode = ctx.createWaveShaper();
+      let detuneVal = 0;
+      shaperNode.curve = new Float32Array(65536);
+      setInterval(() => osc.detune.value = ++detuneVal, 10);
+    </script>
+  </body>
+
+</html>

--- a/browser/devtools/webaudioeditor/test/head.js
+++ b/browser/devtools/webaudioeditor/test/head.js
@@ -14,27 +14,30 @@ Services.prefs.setBoolPref("devtools.deb
 let { Task } = Cu.import("resource://gre/modules/Task.jsm", {});
 let { Promise } = Cu.import("resource://gre/modules/Promise.jsm", {});
 let { gDevTools } = Cu.import("resource:///modules/devtools/gDevTools.jsm", {});
 let { devtools } = Cu.import("resource://gre/modules/devtools/Loader.jsm", {});
 let { DebuggerServer } = Cu.import("resource://gre/modules/devtools/dbg-server.jsm", {});
 
 let { WebAudioFront } = devtools.require("devtools/server/actors/webaudio");
 let TargetFactory = devtools.TargetFactory;
+let mm = null;
 
+const FRAME_SCRIPT_UTILS_URL = "chrome://browser/content/devtools/frame-script-utils.js";
 const EXAMPLE_URL = "http://example.com/browser/browser/devtools/webaudioeditor/test/";
 const SIMPLE_CONTEXT_URL = EXAMPLE_URL + "doc_simple-context.html";
 const COMPLEX_CONTEXT_URL = EXAMPLE_URL + "doc_complex-context.html";
 const SIMPLE_NODES_URL = EXAMPLE_URL + "doc_simple-node-creation.html";
 const MEDIA_NODES_URL = EXAMPLE_URL + "doc_media-node-creation.html";
 const BUFFER_AND_ARRAY_URL = EXAMPLE_URL + "doc_buffer-and-array.html";
 const DESTROY_NODES_URL = EXAMPLE_URL + "doc_destroy-nodes.html";
 const CONNECT_TOGGLE_URL = EXAMPLE_URL + "doc_connect-toggle.html";
 const CONNECT_PARAM_URL = EXAMPLE_URL + "doc_connect-param.html";
 const CONNECT_MULTI_PARAM_URL = EXAMPLE_URL + "doc_connect-multi-param.html";
+const CHANGE_PARAM_URL = EXAMPLE_URL + "doc_change-param.html";
 
 // All tests are asynchronous.
 waitForExplicitFinish();
 
 let gToolEnabled = Services.prefs.getBoolPref("devtools.webaudioeditor.enabled");
 
 registerCleanupFunction(() => {
   info("finish() was called, cleaning up...");
@@ -128,16 +131,18 @@ function initBackend(aUrl) {
   return Task.spawn(function*() {
     let tab = yield addTab(aUrl);
     let target = TargetFactory.forTab(tab);
     let debuggee = target.window.wrappedJSObject;
 
     yield target.makeRemote();
 
     let front = new WebAudioFront(target.client, target.form);
+
+    loadFrameScripts();
     return [target, debuggee, front];
   });
 }
 
 function initWebAudioEditor(aUrl) {
   info("Initializing a web audio editor pane.");
 
   return Task.spawn(function*() {
@@ -145,16 +150,18 @@ function initWebAudioEditor(aUrl) {
     let target = TargetFactory.forTab(tab);
     let debuggee = target.window.wrappedJSObject;
 
     yield target.makeRemote();
 
     Services.prefs.setBoolPref("devtools.webaudioeditor.enabled", true);
     let toolbox = yield gDevTools.showToolbox(target, "webaudioeditor");
     let panel = toolbox.getCurrentPanel();
+
+    loadFrameScripts();
     return [target, debuggee, panel];
   });
 }
 
 function teardown(aPanel) {
   info("Destroying the web audio editor.");
 
   return Promise.all([
@@ -382,19 +389,22 @@ function countGraphObjects (win) {
     edges: win.document.querySelectorAll(".edgePaths > .edgePath").length
   }
 }
 
 /**
 * Forces cycle collection and GC, used in AudioNode destruction tests.
 */
 function forceCC () {
-  SpecialPowers.DOMWindowUtils.cycleCollect();
-  SpecialPowers.DOMWindowUtils.garbageCollect();
-  SpecialPowers.DOMWindowUtils.garbageCollect();
+  mm.sendAsyncMessage("devtools:test:forceCC");
+}
+
+function loadFrameScripts () {
+  mm = gBrowser.selectedBrowser.messageManager;
+  mm.loadFrameScript(FRAME_SCRIPT_UTILS_URL, false);
 }
 
 /**
  * List of audio node properties to test against expectations of the AudioNode actor
  */
 
 const NODE_DEFAULT_VALUES = {
   "AudioDestinationNode": {},

--- a/browser/devtools/webaudioeditor/webaudioeditor-controller.js
+++ b/browser/devtools/webaudioeditor/webaudioeditor-controller.js
@@ -15,18 +15,19 @@ const { defer, all } = Cu.import("resour
 
 const { Task } = Cu.import("resource://gre/modules/Task.jsm", {});
 const require = Cu.import("resource://gre/modules/devtools/Loader.jsm", {}).devtools.require;
 const EventEmitter = require("devtools/toolkit/event-emitter");
 const STRINGS_URI = "chrome://browser/locale/devtools/webaudioeditor.properties"
 const L10N = new ViewHelpers.L10N(STRINGS_URI);
 const Telemetry = require("devtools/shared/telemetry");
 const telemetry = new Telemetry();
+let { console } = Cu.import("resource://gre/modules/devtools/Console.jsm", {});
 
-let { console } = Cu.import("resource://gre/modules/devtools/Console.jsm", {});
+let PARAM_POLLING_FREQUENCY = 1000;
 
 // The panel's window global is an EventEmitter firing the following events:
 const EVENTS = {
   // Fired when the first AudioNode has been created, signifying
   // that the AudioContext is being used and should be tracked via the editor.
   START_CONTEXT: "WebAudioEditor:StartContext",
 
   // On node creation, connect and disconnect.
@@ -168,16 +169,18 @@ function shutdownWebAudioEditor() {
 let WebAudioEditorController = {
   /**
    * Listen for events emitted by the current tab target.
    */
   initialize: function() {
     telemetry.toolOpened("webaudioeditor");
     this._onTabNavigated = this._onTabNavigated.bind(this);
     this._onThemeChange = this._onThemeChange.bind(this);
+    this._onSelectNode = this._onSelectNode.bind(this);
+    this._onChangeParam = this._onChangeParam.bind(this);
     gTarget.on("will-navigate", this._onTabNavigated);
     gTarget.on("navigate", this._onTabNavigated);
     gFront.on("start-context", this._onStartContext);
     gFront.on("create-node", this._onCreateNode);
     gFront.on("connect-node", this._onConnectNode);
     gFront.on("connect-param", this._onConnectParam);
     gFront.on("disconnect-node", this._onDisconnectNode);
     gFront.on("change-param", this._onChangeParam);
@@ -189,39 +192,45 @@ let WebAudioEditorController = {
     gDevTools.on("pref-changed", this._onThemeChange);
 
     // Set up events to refresh the Graph view
     window.on(EVENTS.CREATE_NODE, this._onUpdatedContext);
     window.on(EVENTS.CONNECT_NODE, this._onUpdatedContext);
     window.on(EVENTS.DISCONNECT_NODE, this._onUpdatedContext);
     window.on(EVENTS.DESTROY_NODE, this._onUpdatedContext);
     window.on(EVENTS.CONNECT_PARAM, this._onUpdatedContext);
+
+    // Set up a controller for managing parameter changes per audio node
+    window.on(EVENTS.UI_SELECT_NODE, this._onSelectNode);
   },
 
   /**
    * Remove events emitted by the current tab target.
    */
-  destroy: function() {
+  destroy: Task.async(function* () {
     telemetry.toolClosed("webaudioeditor");
     gTarget.off("will-navigate", this._onTabNavigated);
     gTarget.off("navigate", this._onTabNavigated);
     gFront.off("start-context", this._onStartContext);
     gFront.off("create-node", this._onCreateNode);
     gFront.off("connect-node", this._onConnectNode);
     gFront.off("connect-param", this._onConnectParam);
     gFront.off("disconnect-node", this._onDisconnectNode);
     gFront.off("change-param", this._onChangeParam);
     gFront.off("destroy-node", this._onDestroyNode);
     window.off(EVENTS.CREATE_NODE, this._onUpdatedContext);
     window.off(EVENTS.CONNECT_NODE, this._onUpdatedContext);
     window.off(EVENTS.DISCONNECT_NODE, this._onUpdatedContext);
     window.off(EVENTS.DESTROY_NODE, this._onUpdatedContext);
     window.off(EVENTS.CONNECT_PARAM, this._onUpdatedContext);
+    window.off(EVENTS.UI_SELECT_NODE, this._onSelectNode);
     gDevTools.off("pref-changed", this._onThemeChange);
-  },
+
+    yield gFront.disableChangeParamEvents();
+  }),
 
   /**
    * Called when page is reloaded to show the reload notice and waiting
    * for an audio context notice.
    */
   reset: function () {
     $("#reload-notice").hidden = true;
     $("#waiting-notice").hidden = false;
@@ -340,19 +349,31 @@ let WebAudioEditorController = {
     let node = getViewNodeByActor(nodeActor);
     node.disconnect();
     window.emit(EVENTS.DISCONNECT_NODE, node.id);
   },
 
   /**
    * Called when a node param is changed.
    */
-  _onChangeParam: function({ actor, param, value }) {
-    window.emit(EVENTS.CHANGE_PARAM, getViewNodeByActor(actor), param, value);
-  }
+  _onChangeParam: function (args) {
+    window.emit(EVENTS.CHANGE_PARAM, args);
+  },
+
+  /**
+   * Called on UI_SELECT_NODE, used to manage
+   * `change-param` events on that node.
+   */
+  _onSelectNode: function (_, id) {
+    let node = getViewNodeById(id);
+
+    if (node && node.actor) {
+      gFront.enableChangeParamEvents(node.actor, PARAM_POLLING_FREQUENCY);
+    }
+  },
 };
 
 /**
  * Convenient way of emitting events from the panel window.
  */
 EventEmitter.decorate(this);
 
 /**

--- a/browser/devtools/webaudioeditor/webaudioeditor-view.js
+++ b/browser/devtools/webaudioeditor/webaudioeditor-view.js
@@ -372,32 +372,35 @@ let WebAudioInspectorView = {
     // Hide inspector view on startup
     this._inspectorPane.setAttribute("width", INSPECTOR_WIDTH);
     this.toggleInspector({ visible: false, delayed: false, animated: false });
 
     this._onEval = this._onEval.bind(this);
     this._onNodeSelect = this._onNodeSelect.bind(this);
     this._onTogglePaneClick = this._onTogglePaneClick.bind(this);
     this._onDestroyNode = this._onDestroyNode.bind(this);
+    this._onChangeParam = this._onChangeParam.bind(this);
 
     this._inspectorPaneToggleButton.addEventListener("mousedown", this._onTogglePaneClick, false);
     this._propsView = new VariablesView($("#properties-tabpanel-content"), GENERIC_VARIABLES_VIEW_SETTINGS);
     this._propsView.eval = this._onEval;
 
     window.on(EVENTS.UI_SELECT_NODE, this._onNodeSelect);
     window.on(EVENTS.DESTROY_NODE, this._onDestroyNode);
+    window.on(EVENTS.CHANGE_PARAM, this._onChangeParam);
   },
 
   /**
    * Destruction function called when the tool cleans up.
    */
   destroy: function () {
     this._inspectorPaneToggleButton.removeEventListener("mousedown", this._onTogglePaneClick);
     window.off(EVENTS.UI_SELECT_NODE, this._onNodeSelect);
     window.off(EVENTS.DESTROY_NODE, this._onDestroyNode);
+    window.off(EVENTS.CHANGE_PARAM, this._onChangeParam);
 
     this._inspectorPane = null;
     this._inspectorPaneToggleButton = null;
     this._tabsPane = null;
   },
 
   /**
    * Toggles the visibility of the AudioNode Inspector.
@@ -607,17 +610,32 @@ let WebAudioInspectorView = {
   /**
    * Called when `DESTROY_NODE` is fired to remove the node from props view if
    * it's currently selected.
    */
   _onDestroyNode: function (_, id) {
     if (this._currentNode && this._currentNode.id === id) {
       this.setCurrentAudioNode(null);
     }
-  }
+  },
+
+  /**
+   * Called when `CHANGE_PARAM` is fired. We should ensure that this event is
+   * for the same node that is currently selected. We check the existence
+   * of each part of the scope to make sure that if this event was fired
+   * during a VariablesView rebuild, then we just ignore it.
+   */
+  _onChangeParam: function (_, { param, newValue, oldValue, actorID }) {
+    if (!this._currentNode || this._currentNode.actor.actorID !== actorID) return;
+    let scope = this._getAudioPropertiesScope();
+    if (!scope) return;
+    let property = scope.get(param);
+    if (!property) return;
+    property.setGrip(newValue);
+  },
 };
 
 /**
  * Takes an element in an SVG graph and iterates over
  * ancestors until it finds the graph node container. If not found,
  * returns null.
  */
 

--- a/browser/devtools/webconsole/test/browser.ini
+++ b/browser/devtools/webconsole/test/browser.ini
@@ -108,17 +108,20 @@ support-files =
   test-bug_939783_console_trace_duplicates.html
   test-bug-952277-highlight-nodes-in-vview.html
   test-bug-609872-cd-iframe-parent.html
   test-bug-609872-cd-iframe-child.html
   test-bug-989025-iframe-parent.html
   test-console-api-stackframe.html
   test_bug_1010953_cspro.html^headers^
   test_bug_1010953_cspro.html
+  test_bug1045902_console_csp_ignore_reflected_xss_message.html^headers^
+  test_bug1045902_console_csp_ignore_reflected_xss_message.html
 
+[browser_bug1045902_console_csp_ignore_reflected_xss_message.js]
 [browser_bug664688_sandbox_update_after_navigation.js]
 [browser_bug_638949_copy_link_location.js]
 [browser_bug_862916_console_dir_and_filter_off.js]
 [browser_bug_865288_repeat_different_objects.js]
 [browser_bug_865871_variables_view_close_on_esc_key.js]
 [browser_bug_869003_inspect_cross_domain_object.js]
 [browser_bug_871156_ctrlw_close_tab.js]
 [browser_cached_messages.js]

new file mode 100644
--- /dev/null
+++ b/browser/devtools/webconsole/test/browser_bug1045902_console_csp_ignore_reflected_xss_message.js
@@ -0,0 +1,53 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+/* Description of the test:
+ * We are loading a file with the following CSP:
+ *     'reflected-xss filter'
+ * This directive is not supported, hence we confirm that
+ * the according message is displayed in the web console.
+ */
+
+const EXPECTED_RESULT = "Not supporting directive 'reflected-xss'. Directive and values will be ignored.";
+const TEST_FILE = "http://example.com/browser/browser/devtools/webconsole/test/" +
+                  "test_bug1045902_console_csp_ignore_reflected_xss_message.html";
+
+let hud = undefined;
+
+function test() {
+  addTab("data:text/html;charset=utf8,Web Console CSP ignoring reflected XSS (bug 1045902)");
+  browser.addEventListener("load", function _onLoad() {
+    browser.removeEventListener("load", _onLoad, true);
+    openConsole(null, loadDocument);
+  }, true);
+}
+
+function loadDocument(theHud) {
+  hud = theHud;
+  hud.jsterm.clearOutput()
+  browser.addEventListener("load", onLoad, true);
+  content.location = TEST_FILE;
+}
+
+function onLoad(aEvent) {
+  browser.removeEventListener("load", onLoad, true);
+  testViolationMessage();
+}
+
+function testViolationMessage() {
+  let aOutputNode = hud.outputNode;
+
+  waitForSuccess({
+      name: "Confirming that CSP logs messages to the console when 'reflected-xss' directive is used!",
+      validatorFn: function() {
+        console.log(hud.outputNode.textContent);
+        let success = false;
+        success = hud.outputNode.textContent.indexOf(EXPECTED_RESULT) > -1;
+        return success;
+      },
+      successFn: finishTest,
+      failureFn: finishTest,
+    });
+}

new file mode 100644
--- /dev/null
+++ b/browser/devtools/webconsole/test/test_bug1045902_console_csp_ignore_reflected_xss_message.html
@@ -0,0 +1,10 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Bug 1045902 - CSP: Log console message for 'reflected-xss'</title>
+</head>
+<body>
+Bug 1045902 - CSP: Log console message for 'reflected-xss'
+</body>
+</html>

new file mode 100644
--- /dev/null
+++ b/browser/devtools/webconsole/test/test_bug1045902_console_csp_ignore_reflected_xss_message.html^headers^
@@ -0,0 +1,1 @@
+Content-Security-Policy: reflected-xss filter;

--- a/browser/devtools/webide/content/webide.xul
+++ b/browser/devtools/webide/content/webide.xul
@@ -54,17 +54,17 @@
   </commandset>
 
   <menubar id="main-menubar">
     <menu id="menu-project" label="&projectMenu_label;" accesskey="&projectMenu_accesskey;">
       <menupopup id="menu-project-popup">
         <menuitem command="cmd_newApp" accesskey="&projectMenu_newApp_accesskey;"/>
         <menuitem command="cmd_importPackagedApp" accesskey="&projectMenu_importPackagedApp_accesskey;"/>
         <menuitem command="cmd_importHostedApp" accesskey="&projectMenu_importHostedApp_accesskey;"/>
-        <menuitem command="cmd_showProjectPanel" key="key_showProjectPanel" label="&projectMenu_selectApp_label;" accesskey="&projectMenu_selectApp_accessley;"/>
+        <menuitem command="cmd_showProjectPanel" key="key_showProjectPanel" label="&projectMenu_selectApp_label;" accesskey="&projectMenu_selectApp_accesskey;"/>
         <menuseparator/>
         <menuitem command="cmd_play" key="key_play" label="&projectMenu_play_label;" accesskey="&projectMenu_play_accesskey;"/>
         <menuitem command="cmd_stop" accesskey="&projectMenu_stop_accesskey;"/>
         <menuitem command="cmd_toggleToolbox" key="key_toggleToolbox" label="&projectMenu_debug_label;" accesskey="&projectMenu_debug_accesskey;"/>
         <menuseparator/>
         <menuitem command="cmd_removeProject" accesskey="&projectMenu_remove_accesskey;"/>
         <menuseparator/>
         <menuitem command="cmd_showPrefs" label="&projectMenu_showPrefs_label;" accesskey="&projectMenu_showPrefs_accesskey;"/>

--- a/browser/experiments/Experiments.jsm
+++ b/browser/experiments/Experiments.jsm
@@ -354,17 +354,17 @@ Experiments.Experiments = function (poli
   let log = Log.repository.getLoggerWithMessagePrefix(
       "Browser.Experiments.Experiments",
       "Experiments #" + gExperimentsCounter++ + "::");
 
   // At the time of this writing, Experiments.jsm has severe
   // crashes. For forensics purposes, keep the last few log
   // messages in memory and upload them in case of crash.
   this._forensicsLogs = [];
-  this._forensicsLogs.length = 3;
+  this._forensicsLogs.length = 10;
   this._log = Object.create(log);
   this._log.log = (level, string, params) => {
     this._forensicsLogs.shift();
     this._forensicsLogs.push(level + ": " + string);
     log.log(level, string, params);
   };
 
   this._log.trace("constructor");

--- a/browser/installer/package-manifest.in
+++ b/browser/installer/package-manifest.in
@@ -298,16 +298,17 @@
 #endif
 @BINPATH@/browser/components/shellservice.xpt
 @BINPATH@/components/shistory.xpt
 @BINPATH@/components/spellchecker.xpt
 @BINPATH@/components/storage.xpt
 @BINPATH@/components/toolkit_finalizationwitness.xpt
 @BINPATH@/components/toolkit_formautofill.xpt
 @BINPATH@/components/toolkit_osfile.xpt
+@BINPATH@/components/toolkit_xulstore.xpt
 @BINPATH@/components/toolkitprofile.xpt
 #ifdef MOZ_ENABLE_XREMOTE
 @BINPATH@/components/toolkitremote.xpt
 #endif
 @BINPATH@/components/txtsvc.xpt
 @BINPATH@/components/txmgr.xpt
 @BINPATH@/components/uconv.xpt
 @BINPATH@/components/unicharutil.xpt
@@ -498,16 +499,18 @@
 #ifdef MOZ_CAPTIVEDETECT
 @BINPATH@/components/CaptivePortalDetectComponents.manifest
 @BINPATH@/components/captivedetect.js
 #endif
 @BINPATH@/components/servicesComponents.manifest
 @BINPATH@/components/cryptoComponents.manifest
 @BINPATH@/components/TelemetryStartup.js
 @BINPATH@/components/TelemetryStartup.manifest
+@BINPATH@/components/XULStore.js
+@BINPATH@/components/XULStore.manifest
 @BINPATH@/components/messageWakeupService.js
 @BINPATH@/components/messageWakeupService.manifest
 @BINPATH@/components/SettingsManager.js
 @BINPATH@/components/SettingsManager.manifest
 @BINPATH@/components/Webapps.js
 @BINPATH@/components/Webapps.manifest
 @BINPATH@/components/AppsService.js
 @BINPATH@/components/AppsService.manifest

--- a/browser/locales/en-US/chrome/browser/devtools/toolbox.dtd
+++ b/browser/locales/en-US/chrome/browser/devtools/toolbox.dtd
@@ -109,18 +109,16 @@
   -  the explanation of the * marker on a tool which is currently not supported
   -  for the target of the toolbox. -->
 <!ENTITY options.toolNotSupported.label  "* Not supported for current toolbox target">
 
 <!-- LOCALIZATION NOTE (options.selectDevToolsTheme.label): This is the label for
   -  the heading of the radiobox corresponding to the theme of the developer
   -  tools. -->
 <!ENTITY options.selectDevToolsTheme.label   "Choose DevTools theme:">
-<!ENTITY options.darkTheme.label             "Dark theme">
-<!ENTITY options.lightTheme.label            "Light theme">
 
 <!-- LOCALIZATION NOTE (options.webconsole.label): This is the label for the
   -  heading of the group of Web Console preferences in the options panel. -->
 <!ENTITY options.webconsole.label            "Web Console">
 
 <!-- LOCALIZATION NOTE (options.timestampMessages.label): This is the
    - label for the checkbox that toggles timestamps in the Web Console -->
 <!ENTITY options.timestampMessages.label      "Enable timestamps">

--- a/browser/locales/en-US/chrome/browser/devtools/toolbox.properties
+++ b/browser/locales/en-US/chrome/browser/devtools/toolbox.properties
@@ -65,8 +65,16 @@ scratchpad.keycode=VK_F4
 # LOCALIZATION NOTE (browserConsoleCmd.commandkey)
 # Used for toggling the browser console from the detached toolbox window
 # Needs to match browserConsoleCmd.commandkey from browser.dtd
 browserConsoleCmd.commandkey=j
 
 # LOCALIZATION NOTE (pickButton.tooltip)
 # This is the tooltip of the pick button in the toolbox toolbar
 pickButton.tooltip=Pick an element from the page
+
+# LOCALIZATION NOTE (options.darkTheme.label)
+# Used as a label for dark theme
+options.darkTheme.label=Dark theme
+
+# LOCALIZATION NOTE (options.lightTheme.label)
+# Used as a label for light theme
+options.lightTheme.label=Light theme

--- a/browser/locales/en-US/chrome/browser/devtools/webide.dtd
+++ b/browser/locales/en-US/chrome/browser/devtools/webide.dtd
@@ -8,17 +8,17 @@
 <!ENTITY projectMenu_accesskey "P">
 <!ENTITY projectMenu_newApp_label "New App…">
 <!ENTITY projectMenu_newApp_accesskey "N">
 <!ENTITY projectMenu_importPackagedApp_label "Open Packaged App…">
 <!ENTITY projectMenu_importPackagedApp_accesskey "P">
 <!ENTITY projectMenu_importHostedApp_label "Open Hosted App…">
 <!ENTITY projectMenu_importHostedApp_accesskey "H">
 <!ENTITY projectMenu_selectApp_label "Open App…">
-<!ENTITY projectMenu_selectApp_accessley "S">
+<!ENTITY projectMenu_selectApp_accesskey "O">
 <!ENTITY projectMenu_play_label "Install and Run">
 <!ENTITY projectMenu_play_accesskey "I">
 <!ENTITY projectMenu_stop_label "Stop App">
 <!ENTITY projectMenu_stop_accesskey "S">
 <!ENTITY projectMenu_debug_label "Debug App">
 <!ENTITY projectMenu_debug_accesskey "D">
 <!ENTITY projectMenu_remove_label "Remove Project">
 <!ENTITY projectMenu_remove_accesskey "R">

--- a/browser/locales/en-US/chrome/browser/devtools/webide.properties
+++ b/browser/locales/en-US/chrome/browser/devtools/webide.properties
@@ -35,16 +35,20 @@ error_operationFail=Operation failed: %1
 # Variable: app name
 error_cantConnectToApp=Can't connect to app: %1$S
 
 # Variable: error message (in english)
 error_cantFetchAddonsJSON=Can't fetch the add-on list: %S
 
 addons_stable=stable
 addons_unstable=unstable
+# LOCALIZATION NOTE (addons_simulator_label): This label is shown as the name of
+# a given simulator version in the "Manage Simulators" pane.  %1$S: Firefox OS
+# version in the simulator, ex. 1.3.  %2$S: Simulator stability label, ex.
+# "stable" or "unstable".
 addons_simulator_label=Firefox OS %1$S Simulator (%2$S)
 addons_install_button=install
 addons_uninstall_button=uninstall
 addons_adb_label=ADB Helper Add-on
 addons_adb_warning=USB devices won't be detected without this add-on
 addons_status_unknown=?
 addons_status_installed=Installed
 addons_status_uninstalled=Not Installed

--- a/browser/themes/linux/customizableui/panelUIOverlay.css
+++ b/browser/themes/linux/customizableui/panelUIOverlay.css
@@ -72,16 +72,20 @@ menu.subviewbutton > .menu-right {
   width: 16px;
   height: 16px;
 }
 
 menu[disabled="true"].subviewbutton > .menu-right {
   -moz-image-region: rect(0, 32px, 16px, 16px);
 }
 
+menu.subviewbutton > .menu-right:-moz-locale-dir(rtl) {
+  transform: scaleX(-1);
+}
+
 .subviewbutton > .toolbarbutton-icon {
   -moz-margin-end: 5px !important;
 }
 
 .subviewbutton > .menu-right,
 .subviewbutton > .menu-iconic-left {
   padding-top: 1px;
   /* These need !important to override menu.css */

--- a/browser/themes/windows/customizableui/panelUIOverlay.css
+++ b/browser/themes/windows/customizableui/panelUIOverlay.css
@@ -121,16 +121,20 @@ menu.subviewbutton > .menu-right {
   list-style-image: url(chrome://browser/skin/places/bookmarks-menu-arrow.png);
   -moz-image-region: rect(0, 16px, 16px, 0);
 }
 
 menu[disabled="true"].subviewbutton > .menu-right {
   -moz-image-region: rect(0, 32px, 16px, 16px);
 }
 
+menu.subviewbutton > .menu-right:-moz-locale-dir(rtl) {
+  transform: scaleX(-1);
+}
+
 %ifdef WINDOWS_AERO
 /* Win8 and beyond. */
 @media not all and (-moz-os-version: windows-vista) {
   @media not all and (-moz-os-version: windows-win7) {
     panelview .toolbarbutton-1,
     .subviewbutton,
     .widget-overflow-list .toolbarbutton-1,
     .panelUI-grid .toolbarbutton-1 > .toolbarbutton-menubutton-button,

--- a/build/sanitizers/lsan_suppressions.txt
+++ b/build/sanitizers/lsan_suppressions.txt
@@ -56,16 +56,20 @@ leak:fsmdef_ev_createanswer
 leak:vcmRxAllocICE_s
 leak:vcmRxStartICE_m
 # About 50KB of leaks under this stack.
 leak:ccsnap_EscapeStrToLocaleStr
 leak:gsmsdp_add_default_audio_formats_to_local_sdp
 leak:gsmsdp_add_default_video_formats_to_local_sdp
 leak:CCAPI_CallInfo_getMediaStreams
 
+# Intermittent Mochitest 3 WebRTC leaks, as seen in bug 1055910.
+leak:sdp_build_attr_ice_attr
+leak:VcmSIPCCBinding::CandidateReady
+
 
 ###
 ### Many leaks only affect some test suites.  The suite annotations are not checked.
 ###
 
 # Bug 981195 - Small leak in the parser. m4
 leak:TypeCompartment::fixObjectType
 

--- a/content/base/src/nsCSPParser.cpp
+++ b/content/base/src/nsCSPParser.cpp
@@ -779,16 +779,27 @@ nsCSPParser::directiveName()
   // Check if it is a valid directive
   if (!CSP_IsValidDirective(mCurToken)) {
     const char16_t* params[] = { mCurToken.get() };
     logWarningErrorToConsole(nsIScriptError::warningFlag, "couldNotProcessUnknownDirective",
                              params, ArrayLength(params));
     return nullptr;
   }
 
+  // The directive 'reflected-xss' is part of CSP 1.1, see:
+  // http://www.w3.org/TR/2014/WD-CSP11-20140211/#reflected-xss
+  // Currently we are not supporting that directive, hence we log a
+  // warning to the console and ignore the directive including its values.
+  if (CSP_IsDirective(mCurToken, CSP_REFLECTED_XSS)) {
+    const char16_t* params[] = { mCurToken.get() };
+    logWarningErrorToConsole(nsIScriptError::warningFlag, "notSupportingDirective",
+                             params, ArrayLength(params));
+    return nullptr;
+  }
+
   // Make sure the directive does not already exist
   // (see http://www.w3.org/TR/CSP11/#parsing)
   if (mPolicy->directiveExists(CSP_DirectiveToEnum(mCurToken))) {
     const char16_t* params[] = { mCurToken.get() };
     logWarningErrorToConsole(nsIScriptError::warningFlag, "duplicateDirective",
                              params, ArrayLength(params));
     return nullptr;
   }

--- a/content/base/src/nsCSPUtils.h
+++ b/content/base/src/nsCSPUtils.h
@@ -65,33 +65,35 @@ enum CSPDirective {
   CSP_STYLE_SRC,
   CSP_IMG_SRC,
   CSP_MEDIA_SRC,
   CSP_FRAME_SRC,
   CSP_FONT_SRC,
   CSP_CONNECT_SRC,
   CSP_REPORT_URI,
   CSP_FRAME_ANCESTORS,
+  CSP_REFLECTED_XSS,
   // CSP_LAST_DIRECTIVE_VALUE always needs to be the last element in the enum
   // because we use it to calculate the size for the char* array.
   CSP_LAST_DIRECTIVE_VALUE
 };
 
 static const char* CSPStrDirectives[] = {
-  "default-src",    // CSP_DEFAULT_SRC = 0
-  "script-src",     // CSP_SCRIPT_SRC
-  "object-src",     // CSP_OBJECT_SRC
-  "style-src",      // CSP_STYLE_SRC
-  "img-src",        // CSP_IMG_SRC
-  "media-src",      // CSP_MEDIA_SRC
-  "frame-src",      // CSP_FRAME_SRC
-  "font-src",       // CSP_FONT_SRC
-  "connect-src",    // CSP_CONNECT_SRC
-  "report-uri",     // CSP_REPORT_URI
-  "frame-ancestors" // CSP_FRAME_ANCESTORS
+  "default-src",     // CSP_DEFAULT_SRC = 0
+  "script-src",      // CSP_SCRIPT_SRC
+  "object-src",      // CSP_OBJECT_SRC
+  "style-src",       // CSP_STYLE_SRC
+  "img-src",         // CSP_IMG_SRC
+  "media-src",       // CSP_MEDIA_SRC
+  "frame-src",       // CSP_FRAME_SRC
+  "font-src",        // CSP_FONT_SRC
+  "connect-src",     // CSP_CONNECT_SRC
+  "report-uri",      // CSP_REPORT_URI
+  "frame-ancestors", // CSP_FRAME_ANCESTORS
+  "reflected-xss"    // CSP_REFLECTED_XSS
 };
 
 inline const char* CSP_EnumToDirective(enum CSPDirective aDir)
 {
   // Make sure all elements in enum CSPDirective got added to CSPStrDirectives.
   static_assert((sizeof(CSPStrDirectives) / sizeof(CSPStrDirectives[0]) ==
                 static_cast<uint32_t>(CSP_LAST_DIRECTIVE_VALUE)),
                 "CSP_LAST_DIRECTIVE_VALUE does not match length of CSPStrDirectives");