patchset.patch

# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1517405006 -3600
#      Wed Jan 31 14:23:26 2018 +0100
# Node ID 533807979becdb02dc086494a3973f27e63a1a32
# Parent  2667f0b010c959940d7a12b4311d54a6abd74ac5
Readd DeferredSave.jsm

e.g. DTA compat
Backed out changeset c6099f497e32

diff --git a/toolkit/mozapps/extensions/DeferredSave.jsm b/toolkit/mozapps/extensions/DeferredSave.jsm
new file mode 100644
--- /dev/null
+++ b/toolkit/mozapps/extensions/DeferredSave.jsm
@@ -0,0 +1,299 @@
+/* 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 Cu = Components.utils;
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+
+Cu.import("resource://gre/modules/osfile.jsm");
+/* globals OS*/
+Cu.import("resource://gre/modules/PromiseUtils.jsm");
+
+// Make it possible to mock out timers for testing
+var MakeTimer = () => Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+
+this.EXPORTED_SYMBOLS = ["DeferredSave"];
+
+// If delay parameter is not provided, default is 50 milliseconds.
+const DEFAULT_SAVE_DELAY_MS = 50;
+
+Cu.import("resource://gre/modules/Log.jsm");
+// Configure a logger at the parent 'DeferredSave' level to format
+// messages for all the modules under DeferredSave.*
+const DEFERREDSAVE_PARENT_LOGGER_ID = "DeferredSave";
+var parentLogger = Log.repository.getLogger(DEFERREDSAVE_PARENT_LOGGER_ID);
+parentLogger.level = Log.Level.Warn;
+var formatter = new Log.BasicFormatter();
+// Set parent logger (and its children) to append to
+// the Javascript section of the Browser Console
+parentLogger.addAppender(new Log.ConsoleAppender(formatter));
+// Set parent logger (and its children) to
+// also append to standard out
+parentLogger.addAppender(new Log.DumpAppender(formatter));
+
+// Provide the ability to enable/disable logging
+// messages at runtime.
+// If the "extensions.logging.enabled" preference is
+// missing or 'false', messages at the WARNING and higher
+// severity should be logged to the JS console and standard error.
+// If "extensions.logging.enabled" is set to 'true', messages
+// at DEBUG and higher should go to JS console and standard error.
+Cu.import("resource://gre/modules/Services.jsm");
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "AsyncShutdown",
+                                  "resource://gre/modules/AsyncShutdown.jsm");
+
+const PREF_LOGGING_ENABLED = "extensions.logging.enabled";
+const NS_PREFBRANCH_PREFCHANGE_TOPIC_ID = "nsPref:changed";
+
+/**
+* Preference listener which listens for a change in the
+* "extensions.logging.enabled" preference and changes the logging level of the
+* parent 'addons' level logger accordingly.
+*/
+var PrefObserver = {
+ init() {
+   Services.prefs.addObserver(PREF_LOGGING_ENABLED, this);
+   Services.obs.addObserver(this, "xpcom-shutdown");
+   this.observe(null, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, PREF_LOGGING_ENABLED);
+ },
+
+ observe(aSubject, aTopic, aData) {
+   if (aTopic == "xpcom-shutdown") {
+     Services.prefs.removeObserver(PREF_LOGGING_ENABLED, this);
+     Services.obs.removeObserver(this, "xpcom-shutdown");
+   } else if (aTopic == NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) {
+     let debugLogEnabled = Services.prefs.getBoolPref(PREF_LOGGING_ENABLED, false);
+     if (debugLogEnabled) {
+       parentLogger.level = Log.Level.Debug;
+     } else {
+       parentLogger.level = Log.Level.Warn;
+     }
+   }
+ }
+};
+
+PrefObserver.init();
+
+/**
+ * A module to manage deferred, asynchronous writing of data files
+ * to disk. Writing is deferred by waiting for a specified delay after
+ * a request to save the data, before beginning to write. If more than
+ * one save request is received during the delay, all requests are
+ * fulfilled by a single write.
+ *
+ * @constructor
+ * @param {string} aPath
+ *        String representing the full path of the file where the data
+ *        is to be written.
+ * @param {function} aDataProvider
+ *        Callback function that takes no argument and returns the data to
+ *        be written. If aDataProvider returns an ArrayBufferView, the
+ *        bytes it contains are written to the file as is.
+ *        If aDataProvider returns a String the data are UTF-8 encoded
+ *        and then written to the file.
+ * @param {object | integer} [aOptions]
+ *        The delay in milliseconds between the first saveChanges() call
+ *        that marks the data as needing to be saved, and when the DeferredSave
+ *        begins writing the data to disk. Default 50 milliseconds.
+ *
+ *        Or, an options object containing:
+ *         - delay: A delay in milliseconds.
+ *         - finalizeAt: An AsyncShutdown blocker during which to
+ *           finalize any pending writes.
+ */
+this.DeferredSave = function(aPath, aDataProvider, aOptions = {}) {
+  if (typeof aOptions == "number") {
+    aOptions = {delay: aOptions};
+  }
+
+  // Create a new logger (child of 'DeferredSave' logger)
+  // for use by this particular instance of DeferredSave object
+  let leafName = OS.Path.basename(aPath);
+  let logger_id = DEFERREDSAVE_PARENT_LOGGER_ID + "." + leafName;
+  this.logger = Log.repository.getLogger(logger_id);
+
+  // @type {Deferred|null}, null when no data needs to be written
+  // @resolves with the result of OS.File.writeAtomic when all writes complete
+  // @rejects with the error from OS.File.writeAtomic if the write fails,
+  //          or with the error from aDataProvider() if that throws.
+  this._pending = null;
+
+  // @type {Promise}, completes when the in-progress write (if any) completes,
+  //       kept as a resolved promise at other times to simplify logic.
+  //       Because _deferredSave() always uses _writing.then() to execute
+  //       its next action, we don't need a special case for whether a write
+  //       is in progress - if the previous write is complete (and the _writing
+  //       promise is already resolved/rejected), _writing.then() starts
+  //       the next action immediately.
+  //
+  // @resolves with the result of OS.File.writeAtomic
+  // @rejects with the error from OS.File.writeAtomic
+  this._writing = Promise.resolve(0);
+
+  // Are we currently waiting for a write to complete
+  this.writeInProgress = false;
+
+  this._path = aPath;
+  this._dataProvider = aDataProvider;
+
+  this._timer = null;
+
+  // Some counters for telemetry
+  // The total number of times the file was written
+  this.totalSaves = 0;
+
+  // The number of times the data became dirty while
+  // another save was in progress
+  this.overlappedSaves = 0;
+
+  // Error returned by the most recent write (if any)
+  this._lastError = null;
+
+  if (aOptions.delay && (aOptions.delay > 0))
+    this._delay = aOptions.delay;
+  else
+    this._delay = DEFAULT_SAVE_DELAY_MS;
+
+  this._finalizeAt = aOptions.finalizeAt || AsyncShutdown.profileBeforeChange;
+  this._finalize = this._finalize.bind(this);
+  this._finalizeAt.addBlocker(`DeferredSave: writing data to ${aPath}`,
+                              this._finalize);
+};
+
+this.DeferredSave.prototype = {
+  get dirty() {
+    return this._pending || this.writeInProgress;
+  },
+
+  get lastError() {
+    return this._lastError;
+  },
+
+  get path() {
+    return this._path;
+  },
+
+  // Start the pending timer if data is dirty
+  _startTimer() {
+    if (!this._pending) {
+      return;
+    }
+
+      this.logger.debug("Starting timer");
+    if (!this._timer)
+      this._timer = MakeTimer();
+    this._timer.initWithCallback(() => this._timerCallback(),
+                                 this._delay, Ci.nsITimer.TYPE_ONE_SHOT);
+  },
+
+  /**
+   * Mark the current stored data dirty, and schedule a flush to disk
+   * @return A Promise<integer> that will be resolved after the data is written to disk;
+   *         the promise is resolved with the number of bytes written.
+   */
+  saveChanges() {
+      this.logger.debug("Save changes");
+    if (!this._pending) {
+      if (this.writeInProgress) {
+          this.logger.debug("Data changed while write in progress");
+        this.overlappedSaves++;
+      }
+      this._pending = PromiseUtils.defer();
+      // Wait until the most recent write completes or fails (if it hasn't already)
+      // and then restart our timer
+      this._writing.then(count => this._startTimer(), error => this._startTimer());
+    }
+    return this._pending.promise;
+  },
+
+  _timerCallback() {
+    Services.tm.idleDispatchToMainThread(() => this._deferredSave());
+  },
+
+  _deferredSave() {
+    let pending = this._pending;
+    this._pending = null;
+    let writing = this._writing;
+    this._writing = pending.promise;
+
+    // In either the success or the exception handling case, we don't need to handle
+    // the error from _writing here; it's already being handled in another then()
+    let toSave = null;
+    try {
+      toSave = this._dataProvider();
+    } catch (e) {
+        this.logger.error("Deferred save dataProvider failed", e);
+      writing.catch(error => {})
+        .then(count => {
+          pending.reject(e);
+        });
+      return;
+    }
+
+    writing.catch(error => { return 0; })
+    .then(count => {
+        this.logger.debug("Starting write");
+      this.totalSaves++;
+      this.writeInProgress = true;
+
+      OS.File.writeAtomic(this._path, toSave, {tmpPath: this._path + ".tmp"})
+      .then(
+        result => {
+          this._lastError = null;
+          this.writeInProgress = false;
+              this.logger.debug("Write succeeded");
+          pending.resolve(result);
+        },
+        error => {
+          this._lastError = error;
+          this.writeInProgress = false;
+              this.logger.warn("Write failed", error);
+          pending.reject(error);
+        });
+    });
+  },
+
+  /**
+   * Immediately save the dirty data to disk, skipping
+   * the delay of normal operation. Note that the write
+   * still happens asynchronously in the worker
+   * thread from OS.File.
+   *
+   * There are four possible situations:
+   * 1) Nothing to flush
+   * 2) Data is not currently being written, in-memory copy is dirty
+   * 3) Data is currently being written, in-memory copy is clean
+   * 4) Data is being written and in-memory copy is dirty
+   *
+   * @return Promise<integer> that will resolve when all in-memory data
+   *         has finished being flushed, returning the number of bytes
+   *         written. If all in-memory data is clean, completes with the
+   *         result of the most recent write.
+   */
+  flush() {
+    // If we have pending changes, cancel our timer and set up the write
+    // immediately (_deferredSave queues the write for after the most
+    // recent write completes, if it hasn't already)
+    if (this._pending) {
+        this.logger.debug("Flush called while data is dirty");
+      if (this._timer) {
+        this._timer.cancel();
+        this._timer = null;
+      }
+      this._deferredSave();
+    }
+
+    return this._writing;
+  },
+
+  _finalize() {
+    return this.flush().catch(Cu.reportError);
+  },
+
+};
diff --git a/toolkit/mozapps/extensions/moz.build b/toolkit/mozapps/extensions/moz.build
--- a/toolkit/mozapps/extensions/moz.build
+++ b/toolkit/mozapps/extensions/moz.build
@@ -35,16 +35,17 @@ EXTRA_COMPONENTS += [
 
 EXTRA_PP_COMPONENTS += [
     'extensions.manifest',
 ]
 
 EXTRA_JS_MODULES += [
     'AddonManager.jsm',
     'ChromeManifestParser.jsm',
+    'DeferredSave.jsm',
     'LightweightThemeManager.jsm',
 ]
 
 JAR_MANIFESTS += ['jar.mn']
 
 EXPORTS.mozilla += [
     'AddonContentPolicy.h',
     'AddonManagerStartup.h',
diff --git a/toolkit/mozapps/extensions/test/xpcshell/test_DeferredSave.js b/toolkit/mozapps/extensions/test/xpcshell/test_DeferredSave.js
new file mode 100644
--- /dev/null
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_DeferredSave.js
@@ -0,0 +1,545 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+// Test behaviour of module to perform deferred save of data
+// files to disk
+
+"use strict";
+
+const testFile = gProfD.clone();
+testFile.append("DeferredSaveTest");
+
+Components.utils.import("resource://gre/modules/Promise.jsm");
+
+var DSContext = Components.utils.import("resource://gre/modules/DeferredSave.jsm", {});
+var DeferredSave = DSContext.DeferredSave;
+
+// Test wrapper to let us do promise/task based testing of DeferredSave
+function DeferredSaveTester(aDataProvider) {
+  let tester = {
+    // Deferred for the promise returned by the mock writeAtomic
+    waDeferred: null,
+
+    // The most recent data "written" by the mock OS.File.writeAtomic
+    writtenData: undefined,
+
+    dataToSave: "Data to save",
+
+    save: (aData, aWriteHandler) => {
+      tester.writeHandler = aWriteHandler || writer;
+      tester.dataToSave = aData;
+      return tester.saver.saveChanges();
+    },
+
+    flush: (aWriteHandler) => {
+      tester.writeHandler = aWriteHandler || writer;
+      return tester.saver.flush();
+    },
+
+    get lastError() {
+      return tester.saver.lastError;
+    }
+  };
+
+  // Default write handler for most cases where the test case doesn't need
+  // to do anything while the write is in progress; just completes the write
+  // on the next event loop
+  function writer(aTester) {
+    do_print("default write callback");
+    let length = aTester.writtenData.length;
+    do_execute_soon(() => aTester.waDeferred.resolve(length));
+  }
+
+  if (!aDataProvider)
+    aDataProvider = () => tester.dataToSave;
+
+  tester.saver = new DeferredSave(testFile.path, aDataProvider);
+
+  // Install a mock for OS.File.writeAtomic to let us control the async
+  // behaviour of the promise
+  DSContext.OS.File.writeAtomic = function mock_writeAtomic(aFile, aData, aOptions) {
+      do_print("writeAtomic: " + aFile + " data: '" + aData + "', " + aOptions.toSource());
+      tester.writtenData = aData;
+      tester.waDeferred = Promise.defer();
+      tester.writeHandler(tester);
+      return tester.waDeferred.promise;
+    };
+
+  return tester;
+}
+
+/**
+ * Install a mock nsITimer factory that triggers on the next spin of
+ * the event loop after it is scheduled
+ */
+function setQuickMockTimer() {
+  let quickTimer = {
+    initWithCallback(aFunction, aDelay, aType) {
+      do_print("Starting quick timer, delay = " + aDelay);
+      do_execute_soon(aFunction);
+    },
+    cancel() {
+      do_throw("Attempted to cancel a quickMockTimer");
+    }
+  };
+  DSContext.MakeTimer = () => {
+    do_print("Creating quick timer");
+    return quickTimer;
+  };
+}
+
+/**
+ * Install a mock nsITimer factory in DeferredSave.jsm, returning a promise that resolves
+ * when the client code sets the timer. Test cases can use this to wait for client code to
+ * be ready for a timer event, and then signal the event by calling mockTimer.callback().
+ * This could use some enhancement; clients can re-use the returned timer,
+ * but with this implementation it's not possible for the test to wait for
+ * a second call to initWithCallback() on the re-used timer.
+ * @return Promise{mockTimer} that resolves when initWithCallback()
+ *         is called
+ */
+function setPromiseMockTimer() {
+  return new Promise(resolve => {
+    let mockTimer = {
+      callback: null,
+      delay: null,
+      type: null,
+      isCancelled: false,
+
+      initWithCallback(aFunction, aDelay, aType) {
+        do_print("Starting timer, delay = " + aDelay);
+        this.callback = aFunction;
+        this.delay = aDelay;
+        this.type = aType;
+        // cancelled timers can be re-used
+        this.isCancelled = false;
+        resolve(this);
+      },
+      cancel() {
+        do_print("Cancelled mock timer");
+        this.callback = null;
+        this.delay = null;
+        this.type = null;
+        this.isCancelled = true;
+        // If initWithCallback was never called, resolve to let tests check for cancel
+        resolve(this);
+      }
+    };
+    DSContext.MakeTimer = () => {
+      do_print("Creating mock timer");
+      return mockTimer;
+    };
+  });
+}
+
+/**
+ * Return a Promise<null> that resolves after the specified number of milliseconds
+ */
+function delay(aDelayMS) {
+  return new Promise(resolve => {
+    do_timeout(aDelayMS, () => resolve(null));
+  });
+}
+
+// Modify set data once, ask for save, make sure it saves cleanly
+add_task(async function test_basic_save_succeeds() {
+  setQuickMockTimer();
+  let tester = DeferredSaveTester();
+  let data = "Test 1 Data";
+
+  await tester.save(data);
+  do_check_eq(tester.writtenData, data);
+  do_check_eq(1, tester.saver.totalSaves);
+});
+
+// Two saves called during the same event loop, both with callbacks
+// Make sure we save only the second version of the data
+add_task(async function test_two_saves() {
+  setQuickMockTimer();
+  let tester = DeferredSaveTester();
+  let firstCallback_happened = false;
+  let firstData = "Test first save";
+  let secondData = "Test second save";
+
+  // first save should not resolve until after the second one is called,
+  // so we can't just yield this promise
+  tester.save(firstData).then(count => {
+    do_check_eq(secondData, tester.writtenData);
+    do_check_false(firstCallback_happened);
+    firstCallback_happened = true;
+  }, do_report_unexpected_exception);
+
+  await tester.save(secondData);
+  do_check_true(firstCallback_happened);
+  do_check_eq(secondData, tester.writtenData);
+  do_check_eq(1, tester.saver.totalSaves);
+});
+
+// Two saves called with a delay in between, both with callbacks
+// Make sure we save the second version of the data
+add_task(async function test_two_saves_delay() {
+  let timerPromise = setPromiseMockTimer();
+  let tester = DeferredSaveTester();
+  let firstCallback_happened = false;
+  let delayDone = false;
+
+  let firstData = "First data to save with delay";
+  let secondData = "Modified data to save with delay";
+
+  tester.save(firstData).then(count => {
+    do_check_false(firstCallback_happened);
+    do_check_true(delayDone);
+    do_check_eq(secondData, tester.writtenData);
+    firstCallback_happened = true;
+  }, do_report_unexpected_exception);
+
+  // Wait a short time to let async events possibly spawned by the
+  // first tester.save() to run
+  await delay(2);
+  delayDone = true;
+  // request to save modified data
+  let saving = tester.save(secondData);
+  // Yield to wait for client code to set the timer
+  let activeTimer = await timerPromise;
+  // and then trigger it
+  activeTimer.callback();
+  // now wait for the DeferredSave to finish saving
+  await saving;
+  do_check_true(firstCallback_happened);
+  do_check_eq(secondData, tester.writtenData);
+  do_check_eq(1, tester.saver.totalSaves);
+  do_check_eq(0, tester.saver.overlappedSaves);
+});
+
+// Test case where OS.File immediately reports an error when the write begins
+// Also check that the "error" getter correctly returns the error
+// Then do a write that succeeds, and make sure the error is cleared
+add_task(async function test_error_immediate() {
+  let tester = DeferredSaveTester();
+  let testError = new Error("Forced failure");
+  function writeFail(aTester) {
+    aTester.waDeferred.reject(testError);
+  }
+
+  setQuickMockTimer();
+  await tester.save("test_error_immediate", writeFail).then(
+    count => do_throw("Did not get expected error"),
+    error => do_check_eq(testError.message, error.message)
+    );
+  do_check_eq(testError, tester.lastError);
+
+  // This write should succeed and clear the error
+  await tester.save("test_error_immediate succeeds");
+  do_check_eq(null, tester.lastError);
+  // The failed save attempt counts in our total
+  do_check_eq(2, tester.saver.totalSaves);
+});
+
+// Save one set of changes, then while the write is in progress, modify the
+// data two more times. Test that we re-write the dirty data exactly once
+// after the first write succeeds
+add_task(async function dirty_while_writing() {
+  let tester = DeferredSaveTester();
+  let firstData = "First data";
+  let secondData = "Second data";
+  let thirdData = "Third data";
+  let firstCallback_happened = false;
+  let secondCallback_happened = false;
+  let writer = await new Promise(resolve => {
+
+    function writeCallback(aTester) {
+      resolve(aTester.waDeferred);
+    }
+
+    setQuickMockTimer();
+    do_print("First save");
+    tester.save(firstData, writeCallback).then(
+      count => {
+        do_check_false(firstCallback_happened);
+        do_check_false(secondCallback_happened);
+        do_check_eq(tester.writtenData, firstData);
+        firstCallback_happened = true;
+      }, do_report_unexpected_exception);
+
+    do_print("waiting for writer");
+  });
+  do_print("Write started");
+
+  // Delay a bit, modify the data and call saveChanges, delay a bit more,
+  // modify the data and call saveChanges again, another delay,
+  // then complete the in-progress write
+  await delay(1);
+
+  tester.save(secondData).then(
+    count => {
+      do_check_true(firstCallback_happened);
+      do_check_false(secondCallback_happened);
+      do_check_eq(tester.writtenData, thirdData);
+      secondCallback_happened = true;
+    }, do_report_unexpected_exception);
+
+  // wait and then do the third change
+  await delay(1);
+  let thirdWrite = tester.save(thirdData);
+
+  // wait a bit more and then finally finish the first write
+  await delay(1);
+  writer.resolve(firstData.length);
+
+  // Now let everything else finish
+  await thirdWrite;
+  do_check_true(firstCallback_happened);
+  do_check_true(secondCallback_happened);
+  do_check_eq(tester.writtenData, thirdData);
+  do_check_eq(2, tester.saver.totalSaves);
+  do_check_eq(1, tester.saver.overlappedSaves);
+});
+
+// A write callback for the OS.File.writeAtomic mock that rejects write attempts
+function disabled_write_callback(aTester) {
+  do_throw("Should not have written during clean flush");
+}
+
+// special write callback that disables itself to make sure
+// we don't try to write twice
+function write_then_disable(aTester) {
+  do_print("write_then_disable");
+  let length = aTester.writtenData.length;
+  aTester.writeHandler = disabled_write_callback;
+  do_execute_soon(() => aTester.waDeferred.resolve(length));
+}
+
+// Flush tests. First, do an ordinary clean save and then call flush;
+// there should not be another save
+add_task(async function flush_after_save() {
+  setQuickMockTimer();
+  let tester = DeferredSaveTester();
+  let dataToSave = "Flush after save";
+
+  await tester.save(dataToSave);
+  await tester.flush(disabled_write_callback);
+  do_check_eq(1, tester.saver.totalSaves);
+});
+
+// Flush while a write is in progress, but the in-memory data is clean
+add_task(async function flush_during_write() {
+  let tester = DeferredSaveTester();
+  let dataToSave = "Flush during write";
+  let firstCallback_happened = false;
+  let writer = await new Promise(resolve => {
+
+    function writeCallback(aTester) {
+      resolve(aTester.waDeferred);
+    }
+
+    setQuickMockTimer();
+    tester.save(dataToSave, writeCallback).then(
+      count => {
+        do_check_false(firstCallback_happened);
+        firstCallback_happened = true;
+      }, do_report_unexpected_exception);
+
+  });
+
+  // call flush with the write callback disabled, delay a bit more, complete in-progress write
+  let flushing = tester.flush(disabled_write_callback);
+  await delay(2);
+  writer.resolve(dataToSave.length);
+
+  // now wait for the flush to finish
+  await flushing;
+  do_check_true(firstCallback_happened);
+  do_check_eq(1, tester.saver.totalSaves);
+});
+
+// Flush while dirty but write not in progress
+// The data written should be the value at the time
+// flush() is called, even if it is changed later
+add_task(async function flush_while_dirty() {
+  let timerPromise = setPromiseMockTimer();
+  let tester = DeferredSaveTester();
+  let firstData = "Flush while dirty, valid data";
+  let firstCallback_happened = false;
+
+  tester.save(firstData, write_then_disable).then(
+    count => {
+      do_check_false(firstCallback_happened);
+      firstCallback_happened = true;
+      do_check_eq(tester.writtenData, firstData);
+    }, do_report_unexpected_exception);
+
+  // Wait for the timer to be set, but don't trigger it so the write won't start
+  let activeTimer = await timerPromise;
+
+  let flushing = tester.flush();
+
+  // Make sure the timer was cancelled
+  do_check_true(activeTimer.isCancelled);
+
+  // Also make sure that data changed after the flush call
+  // (even without a saveChanges() call) doesn't get written
+  tester.dataToSave = "Flush while dirty, invalid data";
+
+  await flushing;
+  do_check_true(firstCallback_happened);
+  do_check_eq(tester.writtenData, firstData);
+  do_check_eq(1, tester.saver.totalSaves);
+});
+
+// And the grand finale - modify the data, start writing,
+// modify the data again so we're in progress and dirty,
+// then flush, then modify the data again
+// Data for the second write should be taken at the time
+// flush() is called, even if it is modified later
+add_task(async function flush_writing_dirty() {
+  let timerPromise = setPromiseMockTimer();
+  let tester = DeferredSaveTester();
+  let firstData = "Flush first pass data";
+  let secondData = "Flush second pass data";
+  let firstCallback_happened = false;
+  let secondCallback_happened = false;
+  let writeStarted = Promise.defer();
+
+  function writeCallback(aTester) {
+    writeStarted.resolve(aTester.waDeferred);
+  }
+
+  tester.save(firstData, writeCallback).then(
+    count => {
+      do_check_false(firstCallback_happened);
+      do_check_eq(tester.writtenData, firstData);
+      firstCallback_happened = true;
+    }, do_report_unexpected_exception);
+
+  // Trigger the timer callback as soon as the DeferredSave sets it
+  let activeTimer = await timerPromise;
+  activeTimer.callback();
+  let writer = await writeStarted.promise;
+  // the first write has started
+
+  // dirty the data and request another save
+  // after the second save completes, there should not be another write
+  tester.save(secondData, write_then_disable).then(
+    count => {
+      do_check_true(firstCallback_happened);
+      do_check_false(secondCallback_happened);
+      do_check_eq(tester.writtenData, secondData);
+      secondCallback_happened = true;
+    }, do_report_unexpected_exception);
+
+  let flushing = tester.flush(write_then_disable);
+  // Flush should have cancelled our timer
+  do_check_true(activeTimer.isCancelled);
+  tester.dataToSave = "Flush, invalid data: changed late";
+  // complete the first write
+  writer.resolve(firstData.length);
+  // now wait for the second write / flush to complete
+  await flushing;
+  do_check_true(firstCallback_happened);
+  do_check_true(secondCallback_happened);
+  do_check_eq(tester.writtenData, secondData);
+  do_check_eq(2, tester.saver.totalSaves);
+  do_check_eq(1, tester.saver.overlappedSaves);
+});
+
+// A data provider callback that throws an error the first
+// time it is called, and a different error the second time
+// so that tests can (a) make sure the promise is rejected
+// with the error and (b) make sure the provider is only
+// called once in case of error
+const expectedDataError = "Failed to serialize data";
+var badDataError = null;
+function badDataProvider() {
+  let err = new Error(badDataError);
+  badDataError = "badDataProvider called twice";
+  throw err;
+}
+
+// Handle cases where data provider throws
+// First, throws during a normal save
+add_task(async function data_throw() {
+  setQuickMockTimer();
+  badDataError = expectedDataError;
+  let tester = DeferredSaveTester(badDataProvider);
+  await tester.save("data_throw").then(
+    count => do_throw("Expected serialization failure"),
+    error => do_check_eq(error.message, expectedDataError));
+});
+
+// Now, throws during flush
+add_task(async function data_throw_during_flush() {
+  badDataError = expectedDataError;
+  let tester = DeferredSaveTester(badDataProvider);
+  let firstCallback_happened = false;
+
+  setPromiseMockTimer();
+  // Write callback should never be called
+  tester.save("data_throw_during_flush", disabled_write_callback).then(
+    count => do_throw("Expected serialization failure"),
+    error => {
+      do_check_false(firstCallback_happened);
+      do_check_eq(error.message, expectedDataError);
+      firstCallback_happened = true;
+    });
+
+  // flush() will cancel the timer
+  await tester.flush(disabled_write_callback).then(
+    count => do_throw("Expected serialization failure"),
+    error => do_check_eq(error.message, expectedDataError)
+    );
+
+  do_check_true(firstCallback_happened);
+});
+
+// Try to reproduce race condition. The observed sequence of events:
+// saveChanges
+// start writing
+// saveChanges
+// finish writing (need to restart delayed timer)
+// saveChanges
+// flush
+// write starts
+// actually restart timer for delayed write
+// write completes
+// delayed timer goes off, throws error because DeferredSave has been torn down
+add_task(async function delay_flush_race() {
+  let timerPromise = setPromiseMockTimer();
+  let tester = DeferredSaveTester();
+  let firstData = "First save";
+  let secondData = "Second save";
+  let thirdData = "Third save";
+  let writeStarted = Promise.defer();
+
+  function writeCallback(aTester) {
+    writeStarted.resolve(aTester.waDeferred);
+  }
+
+  // This promise won't resolve until after writeStarted
+  let firstSave = tester.save(firstData, writeCallback);
+  (await timerPromise).callback();
+
+  let writer = await writeStarted.promise;
+  // the first write has started
+
+  // dirty the data and request another save
+  let secondSave = tester.save(secondData);
+
+  // complete the first write
+  writer.resolve(firstData.length);
+  await firstSave;
+  do_check_eq(tester.writtenData, firstData);
+
+  tester.save(thirdData);
+  let flushing = tester.flush();
+
+  await secondSave;
+  do_check_eq(tester.writtenData, thirdData);
+
+  await flushing;
+  do_check_eq(tester.writtenData, thirdData);
+
+  // Our DeferredSave should not have a _timer here; if it
+  // does, the bug caused a reschedule
+  do_check_eq(null, tester.saver._timer);
+});
diff --git a/toolkit/mozapps/extensions/test/xpcshell/xpcshell.ini b/toolkit/mozapps/extensions/test/xpcshell/xpcshell.ini
--- a/toolkit/mozapps/extensions/test/xpcshell/xpcshell.ini
+++ b/toolkit/mozapps/extensions/test/xpcshell/xpcshell.ini
@@ -12,16 +12,17 @@ support-files =
 [test_addonStartup.js]
 [test_asyncBlocklistLoad.js]
 tags = blocklist
 [test_blocklist_gfx.js]
 tags = blocklist
 [test_cache_certdb.js]
 run-if = addon_signing
 [test_cacheflush.js]
+[test_DeferredSave.js]
 [test_gmpProvider.js]
 skip-if = appname != "firefox"
 [test_invalid_install_rdf.js]
 [test_isReady.js]
 [test_pluginInfoURL.js]
 tags = blocklist
 [test_provider_markSafe.js]
 [test_provider_shutdown.js]
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1517409436 -3600
#      Wed Jan 31 15:37:16 2018 +0100
# Node ID b8488b438fb75bcd1e50faa150dcad2989b86010
# Parent  533807979becdb02dc086494a3973f27e63a1a32
Make prefwindows work again

diff --git a/toolkit/content/jar.mn b/toolkit/content/jar.mn
--- a/toolkit/content/jar.mn
+++ b/toolkit/content/jar.mn
@@ -80,16 +80,17 @@ toolkit.jar:
    content/global/bindings/general.xml         (widgets/general.xml)
    content/global/bindings/groupbox.xml        (widgets/groupbox.xml)
    content/global/bindings/listbox.xml         (widgets/listbox.xml)
    content/global/bindings/menu.xml            (widgets/menu.xml)
    content/global/bindings/menulist.xml        (widgets/menulist.xml)
    content/global/bindings/notification.xml    (widgets/notification.xml)
    content/global/bindings/numberbox.xml       (widgets/numberbox.xml)
    content/global/bindings/popup.xml           (widgets/popup.xml)
+*  content/global/bindings/preferences.xml     (widgets/preferences.xml)
    content/global/bindings/progressmeter.xml   (widgets/progressmeter.xml)
    content/global/bindings/radio.xml           (widgets/radio.xml)
    content/global/bindings/remote-browser.xml  (widgets/remote-browser.xml)
    content/global/bindings/resizer.xml         (widgets/resizer.xml)
    content/global/bindings/richlistbox.xml     (widgets/richlistbox.xml)
    content/global/bindings/scale.xml           (widgets/scale.xml)
    content/global/bindings/scrollbar.xml       (widgets/scrollbar.xml)
    content/global/bindings/scrollbox.xml       (widgets/scrollbox.xml)
diff --git a/toolkit/content/xul.css b/toolkit/content/xul.css
--- a/toolkit/content/xul.css
+++ b/toolkit/content/xul.css
@@ -946,16 +946,66 @@ wizardpage {
 .wizard-header {
   -moz-binding: url("chrome://global/content/bindings/wizard.xml#wizard-header");
 }
 
 .wizard-buttons {
   -moz-binding: url("chrome://global/content/bindings/wizard.xml#wizard-buttons");
 }
 
+/********** preferences ********/
+
+prefwindow,
+prefwindow:root /* override :root from above */ {
+  -moz-binding: url("chrome://global/content/bindings/preferences.xml#prefwindow");
+  -moz-box-orient: vertical;
+}
+
+prefpane {
+  -moz-binding: url("chrome://global/content/bindings/preferences.xml#prefpane");
+  -moz-box-orient: vertical;
+}
+
+prefwindow > .paneDeckContainer {
+  overflow: hidden;
+}
+
+prefpane > .content-box {
+  overflow: hidden;
+}
+
+prefwindow[type="child"] > .paneDeckContainer {
+  overflow: -moz-hidden-unscrollable;
+}
+
+prefwindow[type="child"] > prefpane > .content-box {
+  -moz-box-flex: 1;
+  overflow: -moz-hidden-unscrollable;
+}
+
+preferences {
+  -moz-binding: url("chrome://global/content/bindings/preferences.xml#preferences");
+  visibility: collapse;
+}
+
+preference {
+  -moz-binding: url("chrome://global/content/bindings/preferences.xml#preference");
+  visibility: collapse;
+}
+
+radio[pane] {
+  -moz-binding: url("chrome://global/content/bindings/preferences.xml#panebutton") !important;
+  -moz-box-orient: vertical;
+  -moz-box-align: center;
+}
+
+prefwindow[chromehidden~="toolbar"] .chromeclass-toolbar {
+  display: none;
+}
+
 /********** Rich Listbox ********/
 
 richlistbox {
   -moz-binding: url('chrome://global/content/bindings/richlistbox.xml#richlistbox');
   -moz-user-focus: normal;
   -moz-box-orient: vertical;
 }
 
diff --git a/toolkit/themes/linux/global/global.css b/toolkit/themes/linux/global/global.css
--- a/toolkit/themes/linux/global/global.css
+++ b/toolkit/themes/linux/global/global.css
@@ -35,16 +35,17 @@ progressmeter[mode="undetermined"] {
   --arrowpanel-border-color: ThreeDShadow;
 }
 
 /* ::::: root elements ::::: */
 
 window,
 page,
 dialog,
+prefwindow,
 wizard {
   -moz-appearance: window;
   background-color: -moz-Dialog;
   color: -moz-DialogText;
   font: message-box;
 }
 
 /* deprecated */
diff --git a/toolkit/themes/linux/global/jar.mn b/toolkit/themes/linux/global/jar.mn
--- a/toolkit/themes/linux/global/jar.mn
+++ b/toolkit/themes/linux/global/jar.mn
@@ -16,16 +16,17 @@ toolkit.jar:
    skin/classic/global/groupbox.css
    skin/classic/global/listbox.css
    skin/classic/global/menu.css
    skin/classic/global/menulist.css
    skin/classic/global/netError.css
 *  skin/classic/global/notification.css
    skin/classic/global/numberbox.css
    skin/classic/global/popup.css
+   skin/classic/global/preferences.css
    skin/classic/global/printPreview.css
    skin/classic/global/radio.css
    skin/classic/global/scrollbox.css
    skin/classic/global/splitter.css
    skin/classic/global/tabbox.css
    skin/classic/global/textbox.css
    skin/classic/global/toolbar.css
    skin/classic/global/toolbarbutton.css
diff --git a/toolkit/themes/osx/global/global.css b/toolkit/themes/osx/global/global.css
--- a/toolkit/themes/osx/global/global.css
+++ b/toolkit/themes/osx/global/global.css
@@ -24,16 +24,17 @@ menulist > menupopup {
   --focus-ring-box-shadow: @focusRingShadow@;
 }
 
 /* ::::: root elements ::::: */
 
 window,
 page,
 dialog,
+prefwindow,
 wizard {
   -moz-appearance: dialog;
   background-color: #FFFFFF;
   color: -moz-DialogText;
   font: message-box;
 }
 
 /* deprecated */
diff --git a/toolkit/themes/osx/global/jar.mn b/toolkit/themes/osx/global/jar.mn
--- a/toolkit/themes/osx/global/jar.mn
+++ b/toolkit/themes/osx/global/jar.mn
@@ -19,16 +19,17 @@ toolkit.jar:
   skin/classic/global/groupbox.css
   skin/classic/global/listbox.css
   skin/classic/global/menu.css
   skin/classic/global/menulist.css
 * skin/classic/global/notification.css
   skin/classic/global/netError.css
   skin/classic/global/numberbox.css
   skin/classic/global/popup.css
+  skin/classic/global/preferences.css
   skin/classic/global/progressmeter.css
   skin/classic/global/radio.css
   skin/classic/global/resizer.css
   skin/classic/global/richlistbox.css
   skin/classic/global/scrollbars.css                                 (nativescrollbars.css)
   skin/classic/global/scrollbox.css
   skin/classic/global/splitter.css
   skin/classic/global/tabprompts.css
diff --git a/toolkit/themes/windows/global/global.css b/toolkit/themes/windows/global/global.css
--- a/toolkit/themes/windows/global/global.css
+++ b/toolkit/themes/windows/global/global.css
@@ -31,16 +31,17 @@ menulist > menupopup {
   }
 }
 
 /* ::::: root elements ::::: */
 
 window,
 page,
 dialog,
+prefwindow,
 wizard {
   -moz-appearance: window;
   background-color: -moz-Dialog;
   color: -moz-DialogText;
   font: message-box;
 }
 
 /* deprecated */
diff --git a/toolkit/themes/windows/global/jar.mn b/toolkit/themes/windows/global/jar.mn
--- a/toolkit/themes/windows/global/jar.mn
+++ b/toolkit/themes/windows/global/jar.mn
@@ -8,16 +8,17 @@ toolkit.jar:
   skin/classic/global/autocomplete.css
   skin/classic/global/button.css
   skin/classic/global/checkbox.css
   skin/classic/global/dropmarker.css
   skin/classic/global/groupbox.css
 * skin/classic/global/menu.css
   skin/classic/global/menulist.css
 * skin/classic/global/popup.css
+  skin/classic/global/preferences.css
   skin/classic/global/radio.css
   skin/classic/global/tabbox.css
   skin/classic/global/textbox.css
   skin/classic/global/colorpicker.css
   skin/classic/global/commonDialog.css
   skin/classic/global/findBar.css
 * skin/classic/global/global.css
   skin/classic/global/listbox.css
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1519346343 -3600
#      Fri Feb 23 01:39:03 2018 +0100
# Node ID 87d538b498ac26ae6b826c233823ba6eeb24a146
# Parent  b8488b438fb75bcd1e50faa150dcad2989b86010
Readd tree progress meters

Backed out changeset f2f92fe82b0e

diff --git a/accessible/tests/mochitest/treeview.js b/accessible/tests/mochitest/treeview.js
--- a/accessible/tests/mochitest/treeview.js
+++ b/accessible/tests/mochitest/treeview.js
@@ -102,16 +102,17 @@ nsTreeView.prototype =
     return info.parentIndex;
   },
   hasNextSibling: function hasNextSibling(aRowIndex, aAfterIndex) { },
   getLevel: function getLevel(aIndex) {
     var info = this.getInfoByIndex(aIndex);
     return info.level;
   },
   getImageSrc: function getImageSrc(aRow, aCol) {},
+  getProgressMode: function getProgressMode(aRow, aCol) {},
   isContainer: function isContainer(aIndex) {
     var data = this.getDataForIndex(aIndex);
     return data.open != undefined;
   },
   isContainerOpen: function isContainerOpen(aIndex) {
     var data = this.getDataForIndex(aIndex);
     return data.open;
   },
diff --git a/browser/base/content/pageinfo/pageInfo.js b/browser/base/content/pageinfo/pageInfo.js
--- a/browser/base/content/pageinfo/pageInfo.js
+++ b/browser/base/content/pageinfo/pageInfo.js
@@ -122,16 +122,17 @@ pageInfoTreeView.prototype = {
   isSeparator(index) { return false; },
   isSorted() { return this.sortcol > -1; },
   canDrop(index, orientation) { return false; },
   drop(row, orientation) { return false; },
   getParentIndex(index) { return 0; },
   hasNextSibling(index, after) { return false; },
   getLevel(index) { return 0; },
   getImageSrc(row, column) { },
+  getProgressMode(row, column) { },
   getCellValue(row, column) { },
   toggleOpenState(index) { },
   cycleHeader(col) { },
   selectionChanged() { },
   cycleCell(row, column) { },
   isEditable(row, column) { return false; },
   isSelectable(row, column) { return false; },
   performAction(action) { },
diff --git a/browser/components/places/content/treeView.js b/browser/components/places/content/treeView.js
--- a/browser/components/places/content/treeView.js
+++ b/browser/components/places/content/treeView.js
@@ -1538,16 +1538,17 @@ PlacesTreeView.prototype = {
     // Only the title column has an image.
     if (this._getColumnType(aColumn) != this.COLUMN_TYPE_TITLE)
       return "";
 
     let node = this._getNodeForRow(aRow);
     return node.icon;
   },
 
+  getProgressMode(aRow, aColumn) { },
   getCellValue(aRow, aColumn) { },
 
   getCellText: function PTV_getCellText(aRow, aColumn) {
     let node = this._getNodeForRow(aRow);
     switch (this._getColumnType(aColumn)) {
       case this.COLUMN_TYPE_TITLE:
         // normally, this is just the title, but we don't want empty items in
         // the tree view so return a special string if the title is empty.
diff --git a/browser/components/preferences/blocklists.js b/browser/components/preferences/blocklists.js
--- a/browser/components/preferences/blocklists.js
+++ b/browser/components/preferences/blocklists.js
@@ -32,16 +32,17 @@ var gBlocklistManager = {
       return "";
     },
 
     isSeparator(index) { return false; },
     isSorted() { return false; },
     isContainer(index) { return false; },
     setTree(tree) {},
     getImageSrc(row, column) {},
+    getProgressMode(row, column) {},
     getCellValue(row, column) {
       if (column.id == "selectionCol")
         return gBlocklistManager._blockLists[row].selected;
       return undefined;
     },
     cycleHeader(column) {},
     getRowProperties(row) { return ""; },
     getColumnProperties(column) { return ""; },
diff --git a/browser/components/preferences/cookies.js b/browser/components/preferences/cookies.js
--- a/browser/components/preferences/cookies.js
+++ b/browser/components/preferences/cookies.js
@@ -400,16 +400,17 @@ var gCookiesWindow = {
       if (!this._filtered) {
         var item = this._getItemAtIndex(aIndex);
         if (!item) return 0;
         return item.level;
       }
       return 0;
     },
     getImageSrc(aIndex, aColumn) {},
+    getProgressMode(aIndex, aColumn) {},
     getCellValue(aIndex, aColumn) {},
     setTree(aTree) {},
     toggleOpenState(aIndex) {
       if (!this._filtered) {
         var item = this._getItemAtIndex(aIndex);
         if (!item) return;
         this._invalidateCache(aIndex);
         var multiplier = item.open ? -1 : 1;
diff --git a/browser/components/preferences/in-content/search.js b/browser/components/preferences/in-content/search.js
--- a/browser/components/preferences/in-content/search.js
+++ b/browser/components/preferences/in-content/search.js
@@ -638,16 +638,17 @@ EngineView.prototype = {
   isContainer(index) { return false; },
   isContainerOpen(index) { return false; },
   isContainerEmpty(index) { return false; },
   isSeparator(index) { return false; },
   isSorted(index) { return false; },
   getParentIndex(index) { return -1; },
   hasNextSibling(parentIndex, index) { return false; },
   getLevel(index) { return 0; },
+  getProgressMode(index, column) { },
   getCellValue(index, column) {
     if (column.id == "engineShown")
       return this._engineStore.engines[index].shown;
     return undefined;
   },
   toggleOpenState(index) { },
   cycleHeader(column) { },
   selectionChanged() { },
diff --git a/browser/components/preferences/permissions.js b/browser/components/preferences/permissions.js
--- a/browser/components/preferences/permissions.js
+++ b/browser/components/preferences/permissions.js
@@ -42,16 +42,17 @@ var gPermissionManager = {
       return "";
     },
 
     isSeparator(aIndex) { return false; },
     isSorted() { return false; },
     isContainer(aIndex) { return false; },
     setTree(aTree) {},
     getImageSrc(aRow, aColumn) {},
+    getProgressMode(aRow, aColumn) {},
     getCellValue(aRow, aColumn) {},
     cycleHeader(column) {},
     getRowProperties(row) { return ""; },
     getColumnProperties(column) { return ""; },
     getCellProperties(row, column) {
       if (column.element.getAttribute("id") == "siteCol")
         return "ltr";
 
diff --git a/browser/components/preferences/siteDataRemoveSelected.js b/browser/components/preferences/siteDataRemoveSelected.js
--- a/browser/components/preferences/siteDataRemoveSelected.js
+++ b/browser/components/preferences/siteDataRemoveSelected.js
@@ -36,9 +36,10 @@ let gSiteDataRemoveSelected = {
     },
     getCellText(index, column) {
       return this._hosts[index];
     },
     getLevel(index) {
       return 0;
     },
   },
+    getProgressMode() {},
 };
diff --git a/browser/components/preferences/translation.js b/browser/components/preferences/translation.js
--- a/browser/components/preferences/translation.js
+++ b/browser/components/preferences/translation.js
@@ -57,16 +57,17 @@ Tree.prototype = {
   isSorted() {
     return false;
   },
   isContainer(aIndex) {
     return false;
   },
   setTree(aTree) {},
   getImageSrc(aRow, aColumn) {},
+  getProgressMode(aRow, aColumn) {},
   getCellValue(aRow, aColumn) {},
   cycleHeader(column) {},
   getRowProperties(row) {
     return "";
   },
   getColumnProperties(column) {
     return "";
   },
diff --git a/browser/components/sessionstore/content/aboutSessionRestore.js b/browser/components/sessionstore/content/aboutSessionRestore.js
--- a/browser/components/sessionstore/content/aboutSessionRestore.js
+++ b/browser/components/sessionstore/content/aboutSessionRestore.js
@@ -355,15 +355,16 @@ var treeView = {
   },
 
   getImageSrc(idx, column) {
     if (column.id == "title")
       return gTreeData[idx].src || null;
     return null;
   },
 
+  getProgressMode(idx, column) { },
   cycleHeader(column) { },
   cycleCell(idx, column) { },
   selectionChanged() { },
   performAction(action) { },
   performActionOnCell(action, index, column) { },
   getColumnProperties(column) { return ""; }
 };
diff --git a/dom/webidl/TreeView.webidl b/dom/webidl/TreeView.webidl
--- a/dom/webidl/TreeView.webidl
+++ b/dom/webidl/TreeView.webidl
@@ -118,16 +118,26 @@ interface TreeView
    * The image path for a given cell. For defining an icon for a cell.
    * If the empty string is returned, the :moz-tree-image pseudoelement
    * will be used.
    */
   [Throws]
   DOMString getImageSrc(long row, TreeColumn column);
 
   /**
+   * The progress mode for a given cell. This method is only called for
+   * columns of type |progressmeter|.
+   */
+  const short PROGRESS_NORMAL = 1;
+  const short PROGRESS_UNDETERMINED = 2;
+  const short PROGRESS_NONE = 3;
+  [Throws]
+  long getProgressMode(long row, TreeColumn column);
+
+  /**
    * The value for a given cell. This method is only called for columns
    * of type other than |text|.
    */
   [Throws]
   DOMString getCellValue(long row, TreeColumn column);
 
   /**
    * The text for a given cell.  If a column consists only of an image, then
diff --git a/layout/inspector/inDOMView.cpp b/layout/inspector/inDOMView.cpp
--- a/layout/inspector/inDOMView.cpp
+++ b/layout/inspector/inDOMView.cpp
@@ -345,16 +345,22 @@ inDOMView::GetColumnProperties(nsITreeCo
 
 NS_IMETHODIMP
 inDOMView::GetImageSrc(int32_t row, nsITreeColumn* col, nsAString& _retval)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
+inDOMView::GetProgressMode(int32_t row, nsITreeColumn* col, int32_t* _retval)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
 inDOMView::GetCellValue(int32_t row, nsITreeColumn* col, nsAString& _retval)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
 inDOMView::GetCellText(int32_t row, nsITreeColumn* col, nsAString& _retval)
 {
diff --git a/layout/style/nsCSSAnonBoxList.h b/layout/style/nsCSSAnonBoxList.h
--- a/layout/style/nsCSSAnonBoxList.h
+++ b/layout/style/nsCSSAnonBoxList.h
@@ -120,16 +120,17 @@ CSS_ANON_BOX(mozTreeRow, ":-moz-tree-row
 CSS_ANON_BOX(mozTreeSeparator, ":-moz-tree-separator")
 CSS_ANON_BOX(mozTreeCell, ":-moz-tree-cell")
 CSS_ANON_BOX(mozTreeIndentation, ":-moz-tree-indentation")
 CSS_ANON_BOX(mozTreeLine, ":-moz-tree-line")
 CSS_ANON_BOX(mozTreeTwisty, ":-moz-tree-twisty")
 CSS_ANON_BOX(mozTreeImage, ":-moz-tree-image")
 CSS_ANON_BOX(mozTreeCellText, ":-moz-tree-cell-text")
 CSS_ANON_BOX(mozTreeCheckbox, ":-moz-tree-checkbox")
+CSS_ANON_BOX(mozTreeProgressmeter, ":-moz-tree-progressmeter")
 CSS_ANON_BOX(mozTreeDropFeedback, ":-moz-tree-drop-feedback")
 #endif
 
 CSS_ANON_BOX(mozSVGMarkerAnonChild, ":-moz-svg-marker-anon-child")
 CSS_ANON_BOX(mozSVGOuterSVGAnonChild, ":-moz-svg-outer-svg-anon-child")
 CSS_ANON_BOX(mozSVGForeignContent, ":-moz-svg-foreign-content")
 CSS_ANON_BOX(mozSVGText, ":-moz-svg-text")
 
diff --git a/layout/xul/tree/crashtests/454186-1.xul b/layout/xul/tree/crashtests/454186-1.xul
new file mode 100644
--- /dev/null
+++ b/layout/xul/tree/crashtests/454186-1.xul
@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
+<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+
+<tree flex="1">
+  <treecols>
+    <treecol label="test" flex="1" type="progressmeter" />
+  </treecols>
+  <treechildren>
+    <treeitem>
+      <treerow>
+        <treecell value="50" mode="normal" />
+      </treerow>
+    </treeitem>
+    <treeitem>
+      <treerow>
+        <treecell mode="undetermined" />
+      </treerow>
+    </treeitem>
+  </treechildren>
+</tree>
+
+</window>
diff --git a/layout/xul/tree/crashtests/crashtests.list b/layout/xul/tree/crashtests/crashtests.list
--- a/layout/xul/tree/crashtests/crashtests.list
+++ b/layout/xul/tree/crashtests/crashtests.list
@@ -9,15 +9,16 @@ load 391178-2.xul
 load 393665-1.xul
 load 399227-1.xul
 load 399227-2.xul
 load 399692-1.xhtml
 load 399715-1.xhtml
 load 409807-1.xul
 load 414170-1.xul
 load 430394-1.xul
+load 454186-1.xul
 load 479931-1.xhtml
 load 509602-1.xul
 load 585815.html
 load 601427.html
 load 730441-1.xul
 load 730441-2.xul
 load 730441-3.xul
diff --git a/layout/xul/tree/nsITreeColumns.idl b/layout/xul/tree/nsITreeColumns.idl
--- a/layout/xul/tree/nsITreeColumns.idl
+++ b/layout/xul/tree/nsITreeColumns.idl
@@ -24,17 +24,18 @@ interface nsITreeColumn : nsISupports
 
   readonly attribute boolean primary;
   readonly attribute boolean cycler;
   readonly attribute boolean editable;
   readonly attribute boolean selectable;
 
   const short TYPE_TEXT                = 1;
   const short TYPE_CHECKBOX            = 2;
-  const short TYPE_PASSWORD            = 3;
+  const short TYPE_PROGRESSMETER       = 3;
+  const short TYPE_PASSWORD            = 4;
   readonly attribute short type;
 
   nsITreeColumn getNext();
   nsITreeColumn getPrevious();
 
   void invalidate();
 };
 
diff --git a/layout/xul/tree/nsITreeView.idl b/layout/xul/tree/nsITreeView.idl
--- a/layout/xul/tree/nsITreeView.idl
+++ b/layout/xul/tree/nsITreeView.idl
@@ -110,16 +110,25 @@ interface nsITreeView : nsISupports
   /**
    * The image path for a given cell. For defining an icon for a cell.
    * If the empty string is returned, the :moz-tree-image pseudoelement
    * will be used.
    */
   AString getImageSrc(in long row, in nsITreeColumn col);
 
   /**
+   * The progress mode for a given cell. This method is only called for
+   * columns of type |progressmeter|.
+   */
+  const short PROGRESS_NORMAL = 1;
+  const short PROGRESS_UNDETERMINED = 2;
+  const short PROGRESS_NONE = 3;
+  long getProgressMode(in long row, in nsITreeColumn col);
+
+  /**
    * The value for a given cell. This method is only called for columns
    * of type other than |text|.
    */
   AString getCellValue(in long row, in nsITreeColumn col);
 
   /**
    * The text for a given cell.  If a column consists only of an image, then
    * the empty string is returned.  
diff --git a/layout/xul/tree/nsTreeBodyFrame.cpp b/layout/xul/tree/nsTreeBodyFrame.cpp
--- a/layout/xul/tree/nsTreeBodyFrame.cpp
+++ b/layout/xul/tree/nsTreeBodyFrame.cpp
@@ -2028,16 +2028,28 @@ nsTreeBodyFrame::PrefillPropertyArray(in
 
       if (aRowIndex != -1) {
         nsAutoString value;
         mView->GetCellValue(aRowIndex, aCol, value);
         if (value.EqualsLiteral("true"))
           mScratchArray.AppendElement(nsGkAtoms::checked);
       }
     }
+    else if (aCol->GetType() == nsITreeColumn::TYPE_PROGRESSMETER) {
+      mScratchArray.AppendElement(nsGkAtoms::progressmeter);
+
+      if (aRowIndex != -1) {
+        int32_t state;
+        mView->GetProgressMode(aRowIndex, aCol, &state);
+        if (state == nsITreeView::PROGRESS_NORMAL)
+          mScratchArray.AppendElement(nsGkAtoms::progressNormal);
+        else if (state == nsITreeView::PROGRESS_UNDETERMINED)
+          mScratchArray.AppendElement(nsGkAtoms::progressUndetermined);
+      }
+    }
 
     // Read special properties from attributes on the column content node
     if (aCol->mContent->IsElement() &&
         aCol->mContent->AsElement()->AttrValueIs(kNameSpaceID_None,
                                                  nsGkAtoms::insertbefore,
                                                  nsGkAtoms::_true,
                                                  eCaseMatters))
       mScratchArray.AppendElement(nsGkAtoms::insertbefore);
@@ -3401,16 +3413,33 @@ nsTreeBodyFrame::PaintCell(int32_t      
         case nsITreeColumn::TYPE_PASSWORD:
           result &= PaintText(aRowIndex, aColumn, elementRect, aPresContext,
                               aRenderingContext, aDirtyRect, currX);
           break;
         case nsITreeColumn::TYPE_CHECKBOX:
           result &= PaintCheckbox(aRowIndex, aColumn, elementRect, aPresContext,
                                   aRenderingContext, aDirtyRect);
           break;
+        case nsITreeColumn::TYPE_PROGRESSMETER:
+          int32_t state;
+          mView->GetProgressMode(aRowIndex, aColumn, &state);
+          switch (state) {
+            case nsITreeView::PROGRESS_NORMAL:
+            case nsITreeView::PROGRESS_UNDETERMINED:
+              result &= PaintProgressMeter(aRowIndex, aColumn, elementRect,
+                                           aPresContext, aRenderingContext,
+                                           aDirtyRect, aBuilder);
+              break;
+            case nsITreeView::PROGRESS_NONE:
+            default:
+              result &= PaintText(aRowIndex, aColumn, elementRect, aPresContext,
+                                  aRenderingContext, aDirtyRect, currX);
+              break;
+          }
+          break;
       }
     }
   }
 
   aCurrX = currX;
 
   return result;
 }
@@ -3900,16 +3929,120 @@ nsTreeBodyFrame::PaintCheckbox(int32_t  
         image, SamplingFilter::POINT, pt, &aDirtyRect,
         imgIContainer::FLAG_NONE, &imageSize);
   }
 
   return result;
 }
 
 ImgDrawResult
+nsTreeBodyFrame::PaintProgressMeter(int32_t               aRowIndex,
+                                    nsTreeColumn*         aColumn,
+                                    const nsRect&         aProgressMeterRect,
+                                    nsPresContext*        aPresContext,
+                                    gfxContext&           aRenderingContext,
+                                    const nsRect&         aDirtyRect,
+                                    nsDisplayListBuilder* aBuilder)
+{
+  NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");
+
+  // Resolve style for the progress meter.  It contains all the info we need
+  // to lay ourselves out and to paint.
+  nsStyleContext* meterContext = GetPseudoStyleContext(nsCSSAnonBoxes::mozTreeProgressmeter);
+
+  // Obtain the margins for the progress meter and then deflate our rect by that
+  // amount. The progress meter is assumed to be contained within the deflated
+  // rect.
+  nsRect meterRect(aProgressMeterRect);
+  nsMargin meterMargin;
+  meterContext->StyleMargin()->GetMargin(meterMargin);
+  meterRect.Deflate(meterMargin);
+
+  // Paint our borders and background for our progress meter rect.
+  ImgDrawResult result = PaintBackgroundLayer(meterContext, aPresContext,
+                                           aRenderingContext, meterRect,
+                                           aDirtyRect);
+
+  // Time to paint our progress.
+  int32_t state;
+  mView->GetProgressMode(aRowIndex, aColumn, &state);
+  if (state == nsITreeView::PROGRESS_NORMAL) {
+    // Adjust the rect for its border and padding.
+    AdjustForBorderPadding(meterContext, meterRect);
+
+    // Now obtain the value for our cell.
+    nsAutoString value;
+    mView->GetCellValue(aRowIndex, aColumn, value);
+
+    nsresult rv;
+    int32_t intValue = value.ToInteger(&rv);
+    if (intValue < 0)
+      intValue = 0;
+    else if (intValue > 100)
+      intValue = 100;
+
+    nscoord meterWidth = NSToCoordRound((float)intValue / 100 * meterRect.width);
+    if (StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL)
+      meterRect.x += meterRect.width - meterWidth; // right align
+    meterRect.width = meterWidth;
+    bool useImageRegion = true;
+    nsCOMPtr<imgIContainer> image;
+    GetImage(aRowIndex, aColumn, true, meterContext, useImageRegion, getter_AddRefs(image));
+    if (image) {
+      int32_t width, height;
+      image->GetWidth(&width);
+      image->GetHeight(&height);
+      nsSize size(width*nsDeviceContext::AppUnitsPerCSSPixel(),
+                  height*nsDeviceContext::AppUnitsPerCSSPixel());
+      uint32_t drawFlags = aBuilder && aBuilder->IsPaintingToWindow() ?
+        imgIContainer::FLAG_HIGH_QUALITY_SCALING : imgIContainer::FLAG_NONE;
+      result &=
+        nsLayoutUtils::DrawImage(aRenderingContext, meterContext,
+          aPresContext, image,
+          nsLayoutUtils::GetSamplingFilterForFrame(this),
+          nsRect(meterRect.TopLeft(), size), meterRect, meterRect.TopLeft(),
+          aDirtyRect, drawFlags);
+    } else {
+      DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
+      int32_t appUnitsPerDevPixel = PresContext()->AppUnitsPerDevPixel();
+      Rect rect =
+        NSRectToSnappedRect(meterRect, appUnitsPerDevPixel, *drawTarget);
+      ColorPattern color(ToDeviceColor(meterContext->StyleColor()->mColor));
+      drawTarget->FillRect(rect, color);
+    }
+  }
+  else if (state == nsITreeView::PROGRESS_UNDETERMINED) {
+    // Adjust the rect for its border and padding.
+    AdjustForBorderPadding(meterContext, meterRect);
+
+    bool useImageRegion = true;
+    nsCOMPtr<imgIContainer> image;
+    GetImage(aRowIndex, aColumn, true, meterContext, useImageRegion, getter_AddRefs(image));
+    if (image) {
+      int32_t width, height;
+      image->GetWidth(&width);
+      image->GetHeight(&height);
+      nsSize size(width*nsDeviceContext::AppUnitsPerCSSPixel(),
+                  height*nsDeviceContext::AppUnitsPerCSSPixel());
+      uint32_t drawFlags = aBuilder && aBuilder->IsPaintingToWindow() ?
+        imgIContainer::FLAG_HIGH_QUALITY_SCALING : imgIContainer::FLAG_NONE;
+      result &=
+        nsLayoutUtils::DrawImage(aRenderingContext, meterContext,
+          aPresContext, image,
+          nsLayoutUtils::GetSamplingFilterForFrame(this),
+          nsRect(meterRect.TopLeft(), size), meterRect, meterRect.TopLeft(),
+          aDirtyRect, drawFlags);
+    }
+  }
+
+  return result;
+}
+
+
+ImgDrawResult
 nsTreeBodyFrame::PaintDropFeedback(const nsRect&        aDropFeedbackRect,
                                    nsPresContext*      aPresContext,
                                    gfxContext&          aRenderingContext,
                                    const nsRect&        aDirtyRect,
                                    nsPoint              aPt)
 {
   // Paint the drop feedback in between rows.
 
diff --git a/layout/xul/tree/nsTreeBodyFrame.h b/layout/xul/tree/nsTreeBodyFrame.h
--- a/layout/xul/tree/nsTreeBodyFrame.h
+++ b/layout/xul/tree/nsTreeBodyFrame.h
@@ -272,16 +272,25 @@ protected:
   // This method paints the checkbox inside a particular cell of the tree.
   ImgDrawResult PaintCheckbox(int32_t              aRowIndex,
                            nsTreeColumn*        aColumn,
                            const nsRect&        aCheckboxRect,
                            nsPresContext*       aPresContext,
                            gfxContext&          aRenderingContext,
                            const nsRect&        aDirtyRect);
 
+  // This method paints the progress meter inside a particular cell of the tree.
+  ImgDrawResult PaintProgressMeter(int32_t               aRowIndex,
+                                nsTreeColumn*         aColumn,
+                                const nsRect&         aProgressMeterRect,
+                                nsPresContext*        aPresContext,
+                                gfxContext&           aRenderingContext,
+                                const nsRect&         aDirtyRect,
+                                nsDisplayListBuilder* aBuilder);
+
   // This method paints a drop feedback of the tree.
   ImgDrawResult PaintDropFeedback(const nsRect&        aDropFeedbackRect,
                                nsPresContext*       aPresContext,
                                gfxContext&          aRenderingContext,
                                const nsRect&        aDirtyRect,
                                nsPoint              aPt);
 
   // This method is called with a specific style context and rect to
diff --git a/layout/xul/tree/nsTreeColumns.cpp b/layout/xul/tree/nsTreeColumns.cpp
--- a/layout/xul/tree/nsTreeColumns.cpp
+++ b/layout/xul/tree/nsTreeColumns.cpp
@@ -315,24 +315,25 @@ nsTreeColumn::Invalidate()
 
   mOverflow =
     mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::overflow,
                                        nsGkAtoms::_true, eCaseMatters);
 
   // Figure out our column type. Default type is text.
   mType = nsITreeColumn::TYPE_TEXT;
   static Element::AttrValuesArray typestrings[] =
-    {&nsGkAtoms::checkbox, &nsGkAtoms::password,
+    {&nsGkAtoms::checkbox, &nsGkAtoms::progressmeter, &nsGkAtoms::password,
      nullptr};
   switch (mContent->AsElement()->FindAttrValueIn(kNameSpaceID_None,
                                                  nsGkAtoms::type,
                                                  typestrings,
                                                  eCaseMatters)) {
     case 0: mType = nsITreeColumn::TYPE_CHECKBOX; break;
-    case 1: mType = nsITreeColumn::TYPE_PASSWORD; break;
+    case 1: mType = nsITreeColumn::TYPE_PROGRESSMETER; break;
+    case 2: mType = nsITreeColumn::TYPE_PASSWORD; break;
   }
 
   // Fetch the crop style.
   mCropStyle = 0;
   static Element::AttrValuesArray cropstrings[] =
     {&nsGkAtoms::center, &nsGkAtoms::left, &nsGkAtoms::start, nullptr};
   switch (mContent->AsElement()->FindAttrValueIn(kNameSpaceID_None,
                                                  nsGkAtoms::crop, cropstrings,
diff --git a/layout/xul/tree/nsTreeContentView.cpp b/layout/xul/tree/nsTreeContentView.cpp
--- a/layout/xul/tree/nsTreeContentView.cpp
+++ b/layout/xul/tree/nsTreeContentView.cpp
@@ -490,16 +490,62 @@ nsTreeContentView::GetImageSrc(int32_t a
   RefPtr<nsTreeColumn> col = nsTreeColumn::From(aCol);
   NS_ENSURE_ARG(col);
 
   ErrorResult rv;
   GetImageSrc(aRow, *col, _retval, rv);
   return rv.StealNSResult();
 }
 
+int32_t
+nsTreeContentView::GetProgressMode(int32_t aRow, nsTreeColumn& aColumn,
+                                   ErrorResult& aError)
+{
+  if (!IsValidRowIndex(aRow)) {
+    aError.Throw(NS_ERROR_INVALID_ARG);
+    return 0;
+  }
+
+  Row* row = mRows[aRow].get();
+
+  nsIContent* realRow =
+    nsTreeUtils::GetImmediateChild(row->mContent, nsGkAtoms::treerow);
+  if (realRow) {
+    Element* cell = GetCell(realRow, aColumn);
+    if (cell) {
+      static Element::AttrValuesArray strings[] =
+        {&nsGkAtoms::normal, &nsGkAtoms::undetermined, nullptr};
+      switch (cell->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::mode,
+                                    strings, eCaseMatters)) {
+        case 0:
+        {
+          return nsITreeView::PROGRESS_NORMAL;
+        }
+        case 1:
+        {
+          return nsITreeView::PROGRESS_UNDETERMINED;
+        }
+      }
+    }
+  }
+
+  return nsITreeView::PROGRESS_NONE;
+}
+
+NS_IMETHODIMP
+nsTreeContentView::GetProgressMode(int32_t aRow, nsITreeColumn* aCol, int32_t* _retval)
+{
+  RefPtr<nsTreeColumn> col = nsTreeColumn::From(aCol);
+  NS_ENSURE_ARG(col);
+
+  ErrorResult rv;
+  *_retval = GetProgressMode(aRow, *col, rv);
+  return rv.StealNSResult();
+}
+
 void
 nsTreeContentView::GetCellValue(int32_t aRow, nsTreeColumn& aColumn,
                                 nsAString& aValue, ErrorResult& aError)
 {
   if (!IsValidRowIndex(aRow)) {
     aError.Throw(NS_ERROR_INVALID_ARG);
     return;
   }
diff --git a/layout/xul/tree/nsTreeContentView.h b/layout/xul/tree/nsTreeContentView.h
--- a/layout/xul/tree/nsTreeContentView.h
+++ b/layout/xul/tree/nsTreeContentView.h
@@ -77,16 +77,18 @@ class nsTreeContentView final : public n
               mozilla::dom::DataTransfer* aDataTransfer,
               mozilla::ErrorResult& aError);
     int32_t GetParentIndex(int32_t aRow, mozilla::ErrorResult& aError);
     bool HasNextSibling(int32_t aRow, int32_t aAfterIndex,
                         mozilla::ErrorResult& aError);
     int32_t GetLevel(int32_t aRow, mozilla::ErrorResult& aError);
     void GetImageSrc(int32_t aRow, nsTreeColumn& aColumn, nsAString& aSrc,
                      mozilla::ErrorResult& aError);
+    int32_t GetProgressMode(int32_t aRow, nsTreeColumn& aColumn,
+                            mozilla::ErrorResult& aError);
     void GetCellValue(int32_t aRow, nsTreeColumn& aColumn, nsAString& aValue,
                       mozilla::ErrorResult& aError);
     void GetCellText(int32_t aRow, nsTreeColumn& aColumn, nsAString& aText,
                      mozilla::ErrorResult& aError);
     void SetTree(mozilla::dom::TreeBoxObject* aTree,
                  mozilla::ErrorResult& aError);
     void ToggleOpenState(int32_t aRow, mozilla::ErrorResult& aError);
     void CycleHeader(nsTreeColumn& aColumn, mozilla::ErrorResult& aError);
diff --git a/security/manager/pki/nsASN1Tree.cpp b/security/manager/pki/nsASN1Tree.cpp
--- a/security/manager/pki/nsASN1Tree.cpp
+++ b/security/manager/pki/nsASN1Tree.cpp
@@ -263,16 +263,22 @@ nsNSSASN1Tree::GetLevel(int32_t index, i
 
 NS_IMETHODIMP
 nsNSSASN1Tree::GetImageSrc(int32_t, nsITreeColumn*, nsAString&)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
+nsNSSASN1Tree::GetProgressMode(int32_t, nsITreeColumn*, int32_t*)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
 nsNSSASN1Tree::GetCellValue(int32_t, nsITreeColumn*, nsAString&)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsNSSASN1Tree::GetCellText(int32_t row, nsITreeColumn*, nsAString& _retval)
 {
diff --git a/security/manager/ssl/nsCertTree.cpp b/security/manager/ssl/nsCertTree.cpp
--- a/security/manager/ssl/nsCertTree.cpp
+++ b/security/manager/ssl/nsCertTree.cpp
@@ -996,16 +996,22 @@ NS_IMETHODIMP
 nsCertTree::GetImageSrc(int32_t row, nsITreeColumn* col,
                         nsAString& _retval)
 {
   _retval.Truncate();
   return NS_OK;
 }
 
 NS_IMETHODIMP
+nsCertTree::GetProgressMode(int32_t row, nsITreeColumn* col, int32_t* _retval)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
 nsCertTree::GetCellValue(int32_t row, nsITreeColumn* col,
                          nsAString& _retval)
 {
   _retval.Truncate();
   return NS_OK;
 }
 
 NS_IMETHODIMP
diff --git a/toolkit/components/autocomplete/nsAutoCompleteController.cpp b/toolkit/components/autocomplete/nsAutoCompleteController.cpp
--- a/toolkit/components/autocomplete/nsAutoCompleteController.cpp
+++ b/toolkit/components/autocomplete/nsAutoCompleteController.cpp
@@ -871,19 +871,16 @@ nsAutoCompleteController::Notify(nsITime
 
 NS_IMETHODIMP
 nsAutoCompleteController::GetName(nsACString& aName)
 {
   aName.AssignLiteral("nsAutoCompleteController");
   return NS_OK;
 }
 
-////////////////////////////////////////////////////////////////////////
-//// nsAutoCompleteController
-
 nsresult
 nsAutoCompleteController::OpenPopup()
 {
   uint32_t minResults;
   mInput->GetMinResultsForPopup(&minResults);
 
   if (mMatchCount >= minResults) {
     return mInput->SetPopupOpen(true);
diff --git a/toolkit/components/passwordmgr/content/passwordManager.js b/toolkit/components/passwordmgr/content/passwordManager.js
--- a/toolkit/components/passwordmgr/content/passwordManager.js
+++ b/toolkit/components/passwordmgr/content/passwordManager.js
@@ -150,16 +150,17 @@ let signonsTreeView = {
     PlacesUtils.promiseFaviconLinkUrl(signon.hostname)
       .then(faviconURI => {
         this._faviconMap.set(signon.hostname, faviconURI.spec);
         this._invalidateTask.arm();
       }).catch(Cu.reportError);
 
     return "";
   },
+  getProgressMode(row, column) {},
   getCellValue(row, column) {},
   getCellText(row, column) {
     let time;
     let signon = GetVisibleLogins()[row];
     switch (column.id) {
       case "siteCol":
         return signon.httpRealm ?
                (signon.hostname + " (" + signon.httpRealm + ")") :
diff --git a/toolkit/content/tests/chrome/test_tree_view.xul b/toolkit/content/tests/chrome/test_tree_view.xul
--- a/toolkit/content/tests/chrome/test_tree_view.xul
+++ b/toolkit/content/tests/chrome/test_tree_view.xul
@@ -30,16 +30,17 @@ var view =
   setTree: function(tree) { this.tree = tree; },
   isContainer: function(row) { return false; },
   isContainerOpen: function(row) { return false; },
   isContainerEmpty: function(row) { return false; },
   isSeparator: function(row) { return false; },
   isSorted: function(row) { return false; },
   isSelectable: function(row, column) { return true; },
   isEditable: function(row, column) { return row != 2 || column.index != 1; },
+  getProgressMode: function(row, column) { return Components.interfaces.nsITreeView.PROGRESS_NORMAL; },
   getParentIndex: function(row, column) { return -1; },
   getLevel: function(row) { return 0; },
   hasNextSibling: function(row, column) { return row != this.rowCount - 1; },
   getImageSrc: function(row, column) { return ""; },
   cycleHeader: function(column) { },
   getRowProperties: function(row) { return ""; },
   getCellProperties: function(row, column) { return ""; },
   getColumnProperties: function(column)
@@ -59,17 +60,18 @@ function getCustomTreeViewCellInfo()
   for (var row = 0; row < view.rowCount; row++) {
     var cellInfo = [ ];
     for (var column = 0; column < 1; column++) {
       cellInfo.push({ label: "" + view.treeData[row % 4][column],
                       value: "",
                       properties: "",
                       editable: row != 2 || column.index != 1,
                       selectable: true,
-                      image: "" });
+                      image: "",
+                      mode: Components.interfaces.nsITreeView.PROGRESS_NORMAL });
     }
 
     obj.rows.push({ cells: cellInfo,
                     properties: "",
                     container: false,
                     separator: false,
                     children: null,
                     level: 0,
diff --git a/toolkit/content/tests/widgets/tree_shared.js b/toolkit/content/tests/widgets/tree_shared.js
--- a/toolkit/content/tests/widgets/tree_shared.js
+++ b/toolkit/content/tests/widgets/tree_shared.js
@@ -14,17 +14,17 @@ var columns_hiertree =
 [
   { name: "name", label: "Name", primary: true, key: true, properties: "one two" },
   { name: "address", label: "Address" },
   { name: "planet", label: "Planet" },
   { name: "gender", label: "Gender", cycler: true }
 ];
 
 // XXXndeakin still to add some tests for:
-//   cycler columns, checkbox cells
+//   cycler columns, checkbox cells, progressmeter cells
 
 // this test function expects a tree to have 8 rows in it when it isn't
 // expanded. The tree should only display four rows at a time. If editable,
 // the cell at row 1 and column 0 must be editable, and the cell at row 2 and
 // column 1 must not be editable.
 function testtag_tree(treeid, treerowinfoid, seltype, columnstype, testid) {
   // Stop keystrokes that aren't handled by the tree from leaking out and
   // scrolling the main Mochitests window!
@@ -908,16 +908,17 @@ function testtag_tree_TreeView_rows(tree
   var checkCellMethods =
   {
     getCellText(row, cell) { return cell.label; },
     getCellValue(row, cell) { return cell.value; },
     getCellProperties(row, cell) { return cell.properties; },
     isEditable(row, cell) { return cell.editable; },
     isSelectable(row, cell) { return cell.selectable; },
     getImageSrc(row, cell) { return cell.image; },
+    getProgressMode(row, cell) { return cell.mode; }
   };
 
   var failedMethods = { };
   var checkMethod, actual, expected;
   var toggleOpenStateOK = true;
 
   for (r = startRow; r < length; r++) {
     var row = rowInfo.rows[r];
diff --git a/toolkit/themes/linux/global/tree.css b/toolkit/themes/linux/global/tree.css
--- a/toolkit/themes/linux/global/tree.css
+++ b/toolkit/themes/linux/global/tree.css
@@ -169,16 +169,31 @@ treechildren::-moz-tree-cell-text(primar
 
 treechildren::-moz-tree-drop-feedback {
   background-color: Highlight;
   width: 50px;
   height: 2px;
   margin-inline-start: 5px;
 }
 
+/* ::::: tree progress meter ::::: */
+
+treechildren::-moz-tree-progressmeter {
+  margin: 2px 4px;
+  padding: 1px;
+  border: 1px solid;
+  border-color: ThreeDShadow ThreeDHighlight ThreeDHighlight ThreeDShadow;
+  background-color: -moz-Dialog;
+  color: ThreeDShadow;
+}
+
+treechildren::-moz-tree-cell-text(progressmeter) {
+  margin: 2px 4px;
+}
+
 /* ::::: tree columns ::::: */
 
 treecol,
 treecolpicker {
   -moz-appearance: treeheadercell;
   -moz-box-align: center;
   -moz-box-pack: center;
   color: -moz-DialogText;
diff --git a/toolkit/themes/osx/global/tree.css b/toolkit/themes/osx/global/tree.css
--- a/toolkit/themes/osx/global/tree.css
+++ b/toolkit/themes/osx/global/tree.css
@@ -139,16 +139,29 @@ treechildren::-moz-tree-cell-text(primar
 
 treechildren::-moz-tree-drop-feedback {
   background-color: #A1A1A1;
   width: 50px;
   height: 2px;
   margin-inline-start: 5px;
 }
 
+/* ::::: tree progress meter ::::: */
+
+treechildren::-moz-tree-progressmeter {
+  margin: 2px 4px;
+  border: 1px solid;
+  border-color: ThreeDShadow ThreeDHighlight ThreeDHighlight ThreeDShadow;
+}
+
+treechildren::-moz-tree-cell-text(progressmeter) {
+  margin: 2px 4px;
+  -moz-appearance: progressbar;
+}
+
 /* ::::: tree columns ::::: */
 
 treecol,
 treecolpicker {
   -moz-appearance: treeheadercell;
   -moz-box-align: center;
   -moz-box-pack: center;
   color: -moz-DialogText;
diff --git a/toolkit/themes/windows/global/tree.css b/toolkit/themes/windows/global/tree.css
--- a/toolkit/themes/windows/global/tree.css
+++ b/toolkit/themes/windows/global/tree.css
@@ -168,16 +168,31 @@ treechildren::-moz-tree-cell-text(primar
 
 treechildren::-moz-tree-drop-feedback {
   background-color: Highlight;
   width: 50px;
   height: 2px;
   margin-inline-start: 5px;
 }
 
+/* ::::: tree progress meter ::::: */
+
+treechildren::-moz-tree-progressmeter {
+  margin: 2px 4px;
+  padding: 1px;
+  border: 1px solid;
+  border-color: ThreeDShadow ThreeDHighlight ThreeDHighlight ThreeDShadow;
+  background-color: -moz-Dialog;
+  color: ThreeDShadow;
+}
+
+treechildren::-moz-tree-cell-text(progressmeter) {
+  margin: 2px 4px;
+}
+
 /* ::::: tree columns ::::: */
 
 treecol,
 treecolpicker {
   -moz-appearance: treeheadercell;
   -moz-box-align: center;
   -moz-box-pack: center;
   color: -moz-DialogText;
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1517419857 -3600
#      Wed Jan 31 18:30:57 2018 +0100
# Node ID f44e1e3ccf77e70103b2e842137927cdfc016c0c
# Parent  87d538b498ac26ae6b826c233823ba6eeb24a146
Readd statusbar bindings

Backed out changeset 38f11a0d4111
Backed out changeset 2e0ea0c63d14

diff --git a/accessible/tests/mochitest/role/test_general.xul b/accessible/tests/mochitest/role/test_general.xul
--- a/accessible/tests/mochitest/role/test_general.xul
+++ b/accessible/tests/mochitest/role/test_general.xul
@@ -20,16 +20,18 @@
     {
       ok(!isAccessible("image"),
                       "image without tooltiptext shouldn't be accessible.");
       testRole("image-tooltiptext", ROLE_GRAPHIC);
       testRole("image-onclick", ROLE_PUSHBUTTON);
 
       ok(!isAccessible("statusbarpanel"),
                       "statusbarpanel shouldn't be accessible.");
+      testRole("statusbarpanel-iconic", ROLE_PUSHBUTTON);
+      testRole("statusbarpanel-iconic-text", ROLE_PUSHBUTTON);
       testRole("statusbar", ROLE_STATUSBAR);
 
       SimpleTest.finish();
     }
 
     SimpleTest.waitForExplicitFinish();
     addA11yLoadEvent(doTest);
   ]]>
@@ -50,13 +52,15 @@
     </pre>
   </body>
 
   <image id="image" src="../moz.png"/>
   <image id="image-tooltiptext" src="../moz.png" tooltiptext="hello"/>
   <image id="image-onclick" src="../moz.png" onclick=""/>
 
   <statusbarpanel id="statusbarpanel"></statusbarpanel>
+  <statusbarpanel id="statusbarpanel-iconic" class="statusbarpanel-iconic"></statusbarpanel>
+  <statusbarpanel id="statusbarpanel-iconic-text" class="statusbarpanel-iconic-text"></statusbarpanel>
   <statusbar id="statusbar"></statusbar>
 
   </hbox>
 </window>
 
diff --git a/toolkit/content/widgets/general.xml b/toolkit/content/widgets/general.xml
--- a/toolkit/content/widgets/general.xml
+++ b/toolkit/content/widgets/general.xml
@@ -71,16 +71,68 @@
       <property name="webNavigation"
                 onget="return this.docShell.QueryInterface(Components.interfaces.nsIWebNavigation);"
                 readonly="true"/>
       <property name="contentDocument" readonly="true"
                 onget="return this.webNavigation.document;"/>
     </implementation>
   </binding>
 
+  <binding id="statusbarpanel" display="xul:button">
+    <content>
+      <children>
+        <xul:label xbl:inherits="value=label,crop" crop="right" flex="1"/>
+      </children>
+    </content>
+
+    <implementation>
+      <property name="label"
+                onget="return this.getAttribute('label');"
+                onset="this.setAttribute('label',val); return val;"/>
+      <property name="image"
+                onget="return this.getAttribute('image');"
+                onset="this.setAttribute('image',val); return val;"/>
+      <property name="src"
+                onget="return this.getAttribute('src');"
+                onset="this.setAttribute('src',val); return val;"/>
+    </implementation>
+  </binding>
+
+  <binding id="statusbarpanel-menu-iconic" display="xul:menu"
+           extends="chrome://global/content/bindings/general.xml#statusbarpanel">
+    <content>
+      <xul:image class="statusbarpanel-icon" xbl:inherits="src,src=image"/>
+      <children/>
+    </content>
+  </binding>
+
+  <binding id="statusbar" role="xul:statusbar">
+    <content>
+      <children/>
+      <xul:statusbarpanel class="statusbar-resizerpanel">
+        <xul:resizer dir="bottomend"/>
+      </xul:statusbarpanel>
+    </content>
+  </binding>
+
+  <binding id="statusbarpanel-iconic" display="xul:button" role="xul:button"
+           extends="chrome://global/content/bindings/general.xml#statusbarpanel">
+    <content>
+      <xul:image class="statusbarpanel-icon" xbl:inherits="src,src=image"/>
+    </content>
+  </binding>
+
+  <binding id="statusbarpanel-iconic-text" display="xul:button" role="xul:button"
+           extends="chrome://global/content/bindings/general.xml#statusbarpanel">
+    <content>
+      <xul:image class="statusbarpanel-icon" xbl:inherits="src,src=image"/>
+      <xul:label class="statusbarpanel-text" xbl:inherits="value=label,crop"/>
+    </content>
+  </binding>
+
   <binding id="deck">
     <implementation>
       <property name="selectedIndex"
                 onget="return this.getAttribute('selectedIndex') || '0'">
         <setter>
         <![CDATA[
           if (this.selectedIndex == val)
             return val;
diff --git a/toolkit/content/xul.css b/toolkit/content/xul.css
--- a/toolkit/content/xul.css
+++ b/toolkit/content/xul.css
@@ -251,16 +251,17 @@ caption {
   -moz-box-orient: vertical;
 }
 
 /******** draggable elements *********/
 
 %ifndef MOZ_WIDGET_GTK
 titlebar,
 toolbar:not([nowindowdrag="true"]):not([customizing="true"]),
+statusbar:not([nowindowdrag="true"]),
 %endif
 windowdragbox {
   -moz-window-dragging: drag;
 }
 
 /* The list below is non-comprehensive and will probably need some tweaking. */
 toolbaritem,
 toolbarbutton,
@@ -482,16 +483,26 @@ panel[type="arrow"][side][animate="cance
   transform: none;
 }
 
 %endif
 panel[type="arrow"][animating] {
   pointer-events: none;
 }
 
+%ifdef XP_MACOSX
+.statusbar-resizerpanel {
+  display: none;
+}
+%else
+window[sizemode="maximized"] statusbarpanel.statusbar-resizerpanel {
+  visibility: collapse;
+}
+%endif
+
 /******** grid **********/
 
 grid {
   display: -moz-grid;
 }
 
 rows,
 columns {
@@ -897,16 +908,41 @@ arrowscrollbox {
 arrowscrollbox[clicktoscroll="true"] {
   -moz-binding: url("chrome://global/content/bindings/scrollbox.xml#arrowscrollbox-clicktoscroll");
 }
 
 autorepeatbutton {
   -moz-binding: url("chrome://global/content/bindings/scrollbox.xml#autorepeatbutton");
 }
 
+/********** statusbar **********/
+
+statusbar {
+  -moz-binding: url("chrome://global/content/bindings/general.xml#statusbar");
+%ifdef XP_MACOSX
+  padding-right: 14px;
+%endif
+}
+
+statusbarpanel {
+  -moz-binding: url("chrome://global/content/bindings/general.xml#statusbarpanel");
+}
+
+.statusbarpanel-iconic {
+  -moz-binding: url("chrome://global/content/bindings/general.xml#statusbarpanel-iconic");
+}
+
+.statusbarpanel-iconic-text {
+  -moz-binding: url("chrome://global/content/bindings/general.xml#statusbarpanel-iconic-text");
+}
+
+.statusbarpanel-menu-iconic {
+  -moz-binding: url("chrome://global/content/bindings/general.xml#statusbarpanel-menu-iconic");
+}
+
 /********** stringbundle **********/
 
 stringbundleset {
   visibility: collapse;
 }
 
 stringbundle {
   -moz-binding: url("chrome://global/content/bindings/stringbundle.xml#stringbundle");
diff --git a/toolkit/themes/linux/global/global.css b/toolkit/themes/linux/global/global.css
--- a/toolkit/themes/linux/global/global.css
+++ b/toolkit/themes/linux/global/global.css
@@ -35,18 +35,18 @@ progressmeter[mode="undetermined"] {
   --arrowpanel-border-color: ThreeDShadow;
 }
 
 /* ::::: root elements ::::: */
 
 window,
 page,
 dialog,
-prefwindow,
-wizard {
+wizard,
+prefwindow {
   -moz-appearance: window;
   background-color: -moz-Dialog;
   color: -moz-DialogText;
   font: message-box;
 }
 
 /* deprecated */
 window.dialog {
@@ -92,16 +92,47 @@ iframe {
 @supports -moz-bool-pref("layout.css.emulate-moz-box-with-flex") {
   /* In emulation, <iframe> is block instead of inline, so reset the width/height */
   iframe {
     width: auto;
     height: auto;
   }
 }
 
+/* ::::: statusbar ::::: */
+
+statusbar {
+  -moz-appearance: statusbar;
+  min-height: 22px;
+}
+
+statusbar:-moz-lwtheme {
+  -moz-appearance: none;
+}
+
+statusbarpanel {
+  -moz-appearance: statusbarpanel;
+  -moz-box-align: center;
+  -moz-box-pack: center;
+  padding: 0 4px;
+}
+
+.statusbar-resizerpanel {
+  -moz-box-align: end;
+  -moz-box-pack: end;
+  -moz-appearance: resizerpanel;
+  padding: 0;
+}
+
+.statusbarpanel-iconic,
+.statusbarpanel-iconic-text,
+.statusbarpanel-menu-iconic {
+  padding: 0 1px;
+}
+
 /* XXXBlake yeah, shoot me -- these don't belong here.  I'll move them later. */
 
 sidebarheader {
   min-height: 25px;
   text-shadow: none;
 }
 
 sidebarheader > label {
@@ -114,17 +145,18 @@ sidebarheader > label {
 
 toolbar[mode="text"] .toolbarbutton-text {
   padding: 0 !important;
   margin: 3px 5px !important;
 }
 
 /* ::::: miscellaneous formatting ::::: */
 
-:root:-moz-lwtheme {
+:root:-moz-lwtheme,
+statusbarpanel:-moz-lwtheme {
   -moz-appearance: none;
 }
 
 :root[lwtheme-image]:-moz-lwtheme-darktext {
   text-shadow: 0 -0.5px 1.5px white;
 }
 
 :root[lwtheme-image]:-moz-lwtheme-brighttext {
@@ -220,16 +252,20 @@ label[disabled="true"] {
 .box-padded {
   padding: 5px;
 }
 
 .spaced {
   margin: 3px 5px 4px;
 }
 
+.wizard-box {
+  padding: 20px 44px 10px;
+}
+
 .text-link {
   color: -moz-nativehyperlinktext;
   cursor: pointer;
 }
 
 .text-link:hover {
   text-decoration: underline;
 }
diff --git a/toolkit/themes/osx/global/global.css b/toolkit/themes/osx/global/global.css
--- a/toolkit/themes/osx/global/global.css
+++ b/toolkit/themes/osx/global/global.css
@@ -24,24 +24,31 @@ menulist > menupopup {
   --focus-ring-box-shadow: @focusRingShadow@;
 }
 
 /* ::::: root elements ::::: */
 
 window,
 page,
 dialog,
-prefwindow,
-wizard {
+wizard,
+prefwindow {
   -moz-appearance: dialog;
   background-color: #FFFFFF;
   color: -moz-DialogText;
   font: message-box;
 }
 
+prefwindow[type="child"] {
+  padding-top: 18px;
+  padding-bottom: 15px;
+  padding-inline-start: 18px;
+  padding-inline-end: 20px;
+}
+
 /* deprecated */
 window.dialog {
   padding-top: 8px;
   padding-bottom: 10px;
   padding-inline-start: 8px;
   padding-inline-end: 10px;
 }
 
@@ -87,16 +94,39 @@ iframe {
 @supports -moz-bool-pref("layout.css.emulate-moz-box-with-flex") {
   /* In emulation, <iframe> is block instead of inline, so reset the width/height */
   iframe {
     width: auto;
     height: auto;
   }
 }
 
+/* ::::: statusbar ::::: */
+
+statusbar {
+  min-width: 1px; /* DON'T DELETE!
+  Prevents hiding of scrollbars in browser when window is made smaller.*/
+  min-height: 15px !important;
+  margin: 0px !important;
+  /* need to use padding-inline-end when/if bug 631729 gets fixed: */
+  padding: 0px 16px 1px 1px;
+  -moz-appearance: statusbar;
+  text-shadow: rgba(255, 255, 255, 0.4) 0 1px;
+}
+
+statusbarpanel {
+  -moz-box-align: center;
+  -moz-box-pack: center;
+  padding: 0 4px;
+}
+
+.statusbarpanel-iconic {
+  padding: 0px;
+}
+
 /* ::::: miscellaneous formatting ::::: */
 
 sidebarheader {
   background-color: -moz-Dialog;
   color: -moz-dialogText;
   text-shadow: none;
 }
 
@@ -107,16 +137,23 @@ sidebarheader {
 :root[lwtheme-image]:-moz-lwtheme-darktext {
   text-shadow: 0 -0.5px 1.5px white;
 }
 
 :root[lwtheme-image]:-moz-lwtheme-brighttext {
   text-shadow: 1px 1px 1.5px black;
 }
 
+statusbar:-moz-lwtheme {
+  -moz-appearance: none;
+  background: none;
+  border-style: none;
+  text-shadow: inherit;
+}
+
 .inset {
   border: 1px solid ThreeDShadow;
   border-right-color: ThreeDHighlight;
   border-bottom-color: ThreeDHighlight;
   margin: 0 5px 5px;
 }
 
 .outset {
@@ -195,16 +232,20 @@ label[disabled="true"] {
 .box-padded {
   padding: 5px;
 }
 
 .spaced {
   margin: 3px 5px 4px;
 }
 
+.wizard-box {
+  padding: 20px 44px 10px;
+}
+
 .text-link {
   color: -moz-nativehyperlinktext;
   cursor: pointer;
 }
 
 .text-link:hover {
   text-decoration: underline;
 }
diff --git a/toolkit/themes/windows/global/global.css b/toolkit/themes/windows/global/global.css
--- a/toolkit/themes/windows/global/global.css
+++ b/toolkit/themes/windows/global/global.css
@@ -31,18 +31,18 @@ menulist > menupopup {
   }
 }
 
 /* ::::: root elements ::::: */
 
 window,
 page,
 dialog,
-prefwindow,
-wizard {
+wizard,
+prefwindow {
   -moz-appearance: window;
   background-color: -moz-Dialog;
   color: -moz-DialogText;
   font: message-box;
 }
 
 /* deprecated */
 window.dialog {
@@ -103,16 +103,60 @@ iframe {
 @supports -moz-bool-pref("layout.css.emulate-moz-box-with-flex") {
   /* In emulation, <iframe> is block instead of inline, so reset the width/height */
   iframe {
     width: auto;
     height: auto;
   }
 }
 
+/* ::::: statusbar ::::: */
+
+statusbar {
+  -moz-appearance: statusbar;
+  border-top: 1px solid ThreeDLightShadow;
+  border-left: 1px solid ThreeDShadow;
+  border-right: 1px solid ThreeDHighlight;
+  border-bottom: 1px solid ThreeDHighlight;
+  background-color: -moz-Dialog;
+  min-height: 22px;
+}
+
+statusbarpanel {
+  -moz-appearance: statusbarpanel;
+  -moz-box-align: center;
+  -moz-box-pack: center;
+  border-left: 1px solid ThreeDHighlight;
+  border-top: 1px solid ThreeDHighlight;
+  border-right: 1px solid ThreeDShadow;
+  border-bottom: 1px solid ThreeDShadow;
+  padding: 0 4px;
+}
+
+statusbarpanel:not(.statusbar-resizerpanel):-moz-lwtheme {
+  -moz-appearance: none;
+  border-top-style: none;
+  border-bottom-style: none;
+  border-inline-start-style: none;
+}
+
+.statusbar-resizerpanel {
+  -moz-box-align: end;
+  -moz-box-pack: end;
+  -moz-appearance: resizerpanel;
+  padding: 0;
+  border: none;
+}
+
+.statusbarpanel-iconic,
+.statusbarpanel-iconic-text,
+.statusbarpanel-menu-iconic {
+  padding: 0 1px;
+}
+
 /* XXXBlake yeah, shoot me -- these don't belong here.  I'll move them later. */
 
 sidebarheader {
   min-height: 25px;
   text-shadow: none;
 }
 
 sidebarheader > label {
@@ -133,16 +177,22 @@ toolbar[mode="text"] .toolbarbutton-text
 :root[lwtheme-image]:-moz-lwtheme-darktext {
   text-shadow: 0 -0.5px 1.5px white;
 }
 
 :root[lwtheme-image]:-moz-lwtheme-brighttext {
   text-shadow: 1px 1px 1.5px black;
 }
 
+statusbar:-moz-lwtheme {
+  -moz-appearance: none;
+  background: none;
+  border-style: none;
+}
+
 .inset {
   border: 1px solid ThreeDShadow;
   border-right-color: ThreeDHighlight;
   border-bottom-color: ThreeDHighlight;
   margin: 0 5px 5px;
 }
 
 .outset {
@@ -235,16 +285,20 @@ label[disabled="true"] {
 .box-padded {
   padding: 5px;
 }
 
 .spaced {
   margin: 3px 5px 4px;
 }
 
+.wizard-box {
+  padding: 20px 44px 10px;
+}
+
 .text-link {
   color: -moz-nativehyperlinktext;
   cursor: pointer;
 }
 
 .text-link:hover {
   text-decoration: underline;
 }
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1517467292 -3600
#      Thu Feb 01 07:41:32 2018 +0100
# Node ID efe09e7cec7fefd4c200b40a2bcfc4d8f555009c
# Parent  f44e1e3ccf77e70103b2e842137927cdfc016c0c
Put pack default pref loading

Backed out changeset 1e5c582b5f3e

diff --git a/modules/libpref/Preferences.cpp b/modules/libpref/Preferences.cpp
--- a/modules/libpref/Preferences.cpp
+++ b/modules/libpref/Preferences.cpp
@@ -3,16 +3,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "mozilla/Assertions.h"
 #include "base/basictypes.h"
 #include "GeckoProfiler.h"
 #include "MainThreadUtils.h"
 #include "mozilla/ArenaAllocatorExtensions.h"
 #include "mozilla/ArenaAllocator.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/dom/ContentPrefs.h"
@@ -49,16 +50,18 @@
 #include "nsIDirectoryService.h"
 #include "nsIFile.h"
 #include "nsIInputStream.h"
 #include "nsIMemoryReporter.h"
 #include "nsIObserver.h"
 #include "nsIObserverService.h"
 #include "nsIOutputStream.h"
 #include "nsIPrefBranch.h"
+#include "nsIPrefBranch2.h"
+#include "nsIPrefBranchInternal.h"
 #include "nsIPrefLocalizedString.h"
 #include "nsIRelativeFilePref.h"
 #include "nsISafeOutputStream.h"
 #include "nsISimpleEnumerator.h"
 #include "nsIStringBundle.h"
 #include "nsIStringEnumerator.h"
 #include "nsISupportsImpl.h"
 #include "nsISupportsPrimitives.h"
@@ -1322,17 +1325,17 @@ private:
 
   // We need a canonical nsISupports pointer, per bug 578392.
   nsISupports* mCanonical;
 
   bool IsWeak() const { return !!mWeakRef; }
 };
 
 class nsPrefBranch final
-  : public nsIPrefBranch
+  : public nsIPrefBranchInternal
   , public nsIObserver
   , public nsSupportsWeakReference
 {
   friend class mozilla::PreferenceServiceReporter;
 
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIPREFBRANCH
@@ -1484,16 +1487,18 @@ nsPrefBranch::~nsPrefBranch()
     mozilla::services::GetObserverService();
   if (observerService) {
     observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
   }
 }
 
 NS_IMPL_ISUPPORTS(nsPrefBranch,
                   nsIPrefBranch,
+                  nsIPrefBranch2,
+                  nsIPrefBranchInternal,
                   nsIObserver,
                   nsISupportsWeakReference)
 
 NS_IMETHODIMP
 nsPrefBranch::GetRoot(nsACString& aRoot)
 {
   aRoot = mPrefRoot;
   return NS_OK;
@@ -1804,16 +1809,30 @@ nsPrefBranch::GetComplexValue(const char
     if (NS_FAILED(rv)) {
       return rv;
     }
 
     relativePref.forget(reinterpret_cast<nsIRelativeFilePref**>(aRetVal));
     return NS_OK;
   }
 
+  if (aType.Equals(NS_GET_IID(nsISupportsString))) {
+    nsCOMPtr<nsISupportsString> theString(
+      do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv));
+
+    if (NS_SUCCEEDED(rv)) {
+      // Debugging to see why we end up with very long strings here with
+      // some addons, see bug 836263.
+      NS_ConvertUTF8toUTF16 wdata(utf8String);
+      theString->SetData(wdata);
+      theString.forget(reinterpret_cast<nsISupportsString**>(aRetVal));
+    }
+    return rv;
+  }
+
   NS_WARNING("nsPrefBranch::GetComplexValue - Unsupported interface type");
   return NS_NOINTERFACE;
 }
 
 nsresult
 nsPrefBranch::CheckSanityOfStringLength(const char* aPrefName,
                                         const nsAString& aValue)
 {
@@ -1921,17 +1940,18 @@ nsPrefBranch::SetComplexValue(const char
     nsAutoCString descriptorString;
     descriptorString.Append('[');
     descriptorString.Append(relativeToKey);
     descriptorString.Append(']');
     descriptorString.Append(relDescriptor);
     return SetCharPrefNoLengthCheck(aPrefName, descriptorString);
   }
 
-  if (aType.Equals(NS_GET_IID(nsIPrefLocalizedString))) {
+  if (aType.Equals(NS_GET_IID(nsISupportsString)) ||
+      aType.Equals(NS_GET_IID(nsIPrefLocalizedString))) {
     nsCOMPtr<nsISupportsString> theString = do_QueryInterface(aValue);
 
     if (theString) {
       nsString wideString;
 
       rv = theString->GetData(wideString);
       if (NS_SUCCEEDED(rv)) {
         // Check sanity of string length before any lengthy conversion
@@ -2410,16 +2430,19 @@ Preferences::HandleDirty()
         PREF_DELAY_MS);
     }
   }
 }
 
 static nsresult
 openPrefFile(nsIFile* aFile);
 
+static nsresult
+pref_LoadPrefsInDirList(const char* aListId);
+
 static const char kTelemetryPref[] = "toolkit.telemetry.enabled";
 static const char kChannelPref[] = "app.update.channel";
 
 // clang-format off
 static const char kPrefFileHeader[] =
   "// Mozilla User Preferences"
   NS_LINEBREAK
   NS_LINEBREAK
@@ -2922,16 +2945,18 @@ Preferences::GetInstanceForService()
 
     observerService->AddObserver(
       sPreferences, "profile-before-change-telemetry", true);
     rv =
       observerService->AddObserver(sPreferences, "profile-before-change", true);
 
     observerService->AddObserver(
       sPreferences, "suspend_process_notification", true);
+    observerService->AddObserver(
+      sPreferences, "load-extension-defaults", true);
 
     if (NS_FAILED(rv)) {
       sPreferences = nullptr;
       gCacheDataDesc = "AddObserver(\"profile-before-change\") failed";
       return nullptr;
     }
   }
 
@@ -3014,16 +3039,18 @@ Preferences::~Preferences()
 
   gPrefNameArena.Clear();
 }
 
 NS_IMPL_ISUPPORTS(Preferences,
                   nsIPrefService,
                   nsIObserver,
                   nsIPrefBranch,
+                  nsIPrefBranch2,
+                  nsIPrefBranchInternal,
                   nsISupportsWeakReference)
 
 /* static */ void
 Preferences::SetEarlyPreferences(const nsTArray<dom::Pref>* aDomPrefs)
 {
   MOZ_ASSERT(!XRE_IsParentProcess());
 
   gEarlyDomPrefs = new InfallibleTArray<dom::Pref>(mozilla::Move(*aDomPrefs));
@@ -3101,16 +3128,19 @@ Preferences::Observe(nsISupports* aSubje
     SavePrefFileBlocking();
     MOZ_ASSERT(!mDirty, "Preferences should not be dirty");
     mProfileShutdown = true;
 
   } else if (!nsCRT::strcmp(aTopic, "reload-default-prefs")) {
     // Reload the default prefs from file.
     Unused << InitInitialObjects();
 
+  } else if (!strcmp(aTopic, "load-extension-defaults")) {
+    pref_LoadPrefsInDirList(NS_EXT_PREFS_DEFAULTS_DIR_LIST);
+
   } else if (!nsCRT::strcmp(aTopic, "suspend_process_notification")) {
     // Our process is being suspended. The OS may wake our process later,
     // or it may kill the process. In case our process is going to be killed
     // from the suspended state, we save preferences before suspending.
     rv = SavePrefFileBlocking();
   }
 
   return rv;
@@ -3213,16 +3243,51 @@ Preferences::SavePrefFileAsynchronous()
 
 NS_IMETHODIMP
 Preferences::SavePrefFile(nsIFile* aFile)
 {
   // This is the method accessible from service API. Make it off main thread.
   return SavePrefFileInternal(aFile, SaveMethod::Asynchronous);
 }
 
+static nsresult
+pref_ReadPrefFromJar(nsZipArchive* aJarReader, const char* aName);
+
+static nsresult
+ReadExtensionPrefs(nsIFile* aFile)
+{
+  nsresult rv;
+  RefPtr<nsZipArchive> zip = new nsZipArchive();
+  rv = zip->OpenArchive(aFile);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsZipFind* findPtr;
+  nsAutoPtr<nsZipFind> find;
+  rv = zip->FindInit("defaults/preferences/*.[Jj][Ss]$", &findPtr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  const char* entryName;
+  uint16_t entryNameLen;
+  nsTArray<nsCString> prefEntries;
+  find = findPtr;
+  while (NS_SUCCEEDED(find->FindNext(&entryName, &entryNameLen))) {
+    prefEntries.AppendElement(Substring(entryName, entryNameLen));
+  }
+  prefEntries.Sort();
+  for (uint32_t i = prefEntries.Length(); i--;) {
+    rv = pref_ReadPrefFromJar(zip, prefEntries[i].get());
+    if (NS_FAILED(rv)) {
+      NS_WARNING("Error parsing preferences.");
+    }
+  }
+
+  return rv;
+}
+
+
 /* static */ void
 Preferences::SetPreference(const dom::Pref& aDomPref)
 {
   MOZ_ASSERT(!XRE_IsParentProcess());
   NS_ENSURE_TRUE(InitStaticMembers(), (void)0);
 
   const char* prefName = aDomPref.name().get();
 
@@ -3680,16 +3745,59 @@ pref_LoadPrefsInDir(nsIFile* aDir,
       }
     }
   }
 
   return rv;
 }
 
 static nsresult
+pref_LoadPrefsInDirList(const char* aListId)
+{
+  nsresult rv;
+  nsCOMPtr<nsIProperties> dirSvc(
+    do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  nsCOMPtr<nsISimpleEnumerator> list;
+  dirSvc->Get(aListId, NS_GET_IID(nsISimpleEnumerator), getter_AddRefs(list));
+  if (!list) {
+    return NS_OK;
+  }
+
+  bool hasMore;
+  while (NS_SUCCEEDED(list->HasMoreElements(&hasMore)) && hasMore) {
+    nsCOMPtr<nsISupports> elem;
+    list->GetNext(getter_AddRefs(elem));
+    if (!elem) {
+      continue;
+    }
+
+    nsCOMPtr<nsIFile> path = do_QueryInterface(elem);
+    if (!path) {
+      continue;
+    }
+
+    // Do we care if a file provided by this process fails to load?
+    nsAutoCString leaf;
+    path->GetNativeLeafName(leaf);
+    if (Substring(leaf, leaf.Length() - 4).EqualsLiteral(".xpi")) {
+      ReadExtensionPrefs(path);
+    }
+    else {
+      pref_LoadPrefsInDir(path, nullptr, 0);
+    }
+  }
+
+  return NS_OK;
+}
+
+static nsresult
 pref_ReadPrefFromJar(nsZipArchive* aJarReader, const char* aName)
 {
   TimeStamp startTime = TimeStamp::Now();
 
   nsCString manifest;
   MOZ_TRY_VAR(manifest,
               URLPreloader::ReadZip(aJarReader, nsDependentCString(aName)));
 
@@ -3835,43 +3943,19 @@ Preferences::InitInitialObjects()
     for (uint32_t i = prefEntries.Length(); i--;) {
       rv = pref_ReadPrefFromJar(appJarReader, prefEntries[i].get());
       if (NS_FAILED(rv)) {
         NS_WARNING("Error parsing preferences.");
       }
     }
   }
 
-  nsCOMPtr<nsIProperties> dirSvc(
-    do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv));
+  rv = pref_LoadPrefsInDirList(NS_APP_PREFS_DEFAULTS_DIR_LIST);
   NS_ENSURE_SUCCESS(
-    rv, Err("do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID) failed"));
-
-  nsCOMPtr<nsISimpleEnumerator> list;
-  dirSvc->Get(NS_APP_PREFS_DEFAULTS_DIR_LIST,
-              NS_GET_IID(nsISimpleEnumerator),
-              getter_AddRefs(list));
-  if (list) {
-    bool hasMore;
-    while (NS_SUCCEEDED(list->HasMoreElements(&hasMore)) && hasMore) {
-      nsCOMPtr<nsISupports> elem;
-      list->GetNext(getter_AddRefs(elem));
-      if (!elem) {
-        continue;
-      }
-
-      nsCOMPtr<nsIFile> path = do_QueryInterface(elem);
-      if (!path) {
-        continue;
-      }
-
-      // Do we care if a file provided by this process fails to load?
-      pref_LoadPrefsInDir(path, nullptr, 0);
-    }
-  }
+    rv, Err("pref_LoadPrefsInDirList(NS_APP_PREFS_DEFAULTS_DIR_LIST) failed"));
 
 #ifdef MOZ_WIDGET_ANDROID
   // Set up the correct default for toolkit.telemetry.enabled. If this build
   // has MOZ_TELEMETRY_ON_BY_DEFAULT *or* we're on the beta channel, telemetry
   // is on by default, otherwise not. This is necessary so that beta users who
   // are testing final release builds don't flipflop defaults.
   if (Preferences::GetType(kTelemetryPref) == nsIPrefBranch::PREF_INVALID) {
     bool prerelease = false;
@@ -3928,16 +4012,20 @@ Preferences::InitInitialObjects()
 
   nsCOMPtr<nsIObserverService> observerService =
     mozilla::services::GetObserverService();
   NS_ENSURE_SUCCESS(rv, Err("GetObserverService() failed (2)"));
 
   observerService->NotifyObservers(
     nullptr, NS_PREFSERVICE_APPDEFAULTS_TOPIC_ID, nullptr);
 
+  rv = pref_LoadPrefsInDirList(NS_EXT_PREFS_DEFAULTS_DIR_LIST);
+  NS_ENSURE_SUCCESS(
+    rv, Err("pref_LoadPrefsInDirList(NS_EXT_PREFS_DEFAULTS_DIR_LIST) failed"));
+
   return Ok();
 }
 
 /* static */ nsresult
 Preferences::GetBool(const char* aPrefName, bool* aResult, PrefValueKind aKind)
 {
   NS_PRECONDITION(aResult, "aResult must not be NULL");
   NS_ENSURE_TRUE(InitStaticMembers(), NS_ERROR_NOT_AVAILABLE);
diff --git a/modules/libpref/Preferences.h b/modules/libpref/Preferences.h
--- a/modules/libpref/Preferences.h
+++ b/modules/libpref/Preferences.h
@@ -13,16 +13,18 @@
 
 #include "mozilla/Atomics.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/Result.h"
 #include "mozilla/StaticPtr.h"
 #include "nsCOMPtr.h"
 #include "nsIObserver.h"
 #include "nsIPrefBranch.h"
+#include "nsIPrefBranch2.h"
+#include "nsIPrefBranchInternal.h"
 #include "nsIPrefService.h"
 #include "nsPrintfCString.h"
 #include "nsString.h"
 #include "nsTArray.h"
 #include "nsWeakReference.h"
 
 class nsIFile;
 
@@ -46,17 +48,17 @@ enum class PrefValueKind : uint8_t
 {
   Default,
   User
 };
 
 class Preferences final
   : public nsIPrefService
   , public nsIObserver
-  , public nsIPrefBranch
+  , public nsIPrefBranchInternal
   , public nsSupportsWeakReference
 {
   friend class ::nsPrefBranch;
 
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIPREFSERVICE
   NS_FORWARD_NSIPREFBRANCH(mRootBranch->)
diff --git a/modules/libpref/init/all.js b/modules/libpref/init/all.js
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -5995,16 +5995,20 @@ pref("layers.advanced.columnRule-layers"
 pref("layers.advanced.image-layers", 2);
 pref("layers.advanced.outline-layers", 2);
 pref("layers.advanced.solid-color", false);
 pref("layers.advanced.table", false);
 
 // Enable lowercased response header name
 pref("dom.xhr.lowercase_header.enabled", false);
 
+// Compat
+pref("intl.locale.matchOS", false);
+pref("general.useragent.locale", "en-US");
+
 // Control whether clients.openWindow() opens windows in the same process
 // that called the API vs following our normal multi-process selection
 // algorithm.  Restricting openWindow to same process improves service worker
 // web compat in the short term.  Once the SW multi-e10s refactor is complete
 // this can be removed.
 pref("dom.clients.openwindow_favors_same_process", true);
 
 // When a crash happens, whether to include heap regions of the crash context
diff --git a/modules/libpref/moz.build b/modules/libpref/moz.build
--- a/modules/libpref/moz.build
+++ b/modules/libpref/moz.build
@@ -12,16 +12,18 @@ if CONFIG['ENABLE_TESTS']:
 
 XPCSHELL_TESTS_MANIFESTS += [
     'test/unit/xpcshell.ini',
     'test/unit_ipc/xpcshell.ini',
 ]
 
 XPIDL_SOURCES += [
     'nsIPrefBranch.idl',
+    'nsIPrefBranch2.idl',
+    'nsIPrefBranchInternal.idl',
     'nsIPrefLocalizedString.idl',
     'nsIPrefService.idl',
     'nsIRelativeFilePref.idl',
 ]
 
 XPIDL_MODULE = 'pref'
 
 EXPORTS.mozilla += [
diff --git a/modules/libpref/nsIPrefBranch2.idl b/modules/libpref/nsIPrefBranch2.idl
new file mode 100644
--- /dev/null
+++ b/modules/libpref/nsIPrefBranch2.idl
@@ -0,0 +1,16 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIPrefBranch.idl"
+
+/**
+ * An empty interface to provide backwards compatibility for existing code.
+ *
+ * @see nsIPrefBranch
+ */
+[scriptable, uuid(8892016d-07f7-4530-b5c1-d73dfcde4a1c)]
+interface nsIPrefBranch2 : nsIPrefBranch
+{
+};
diff --git a/modules/libpref/nsIPrefBranchInternal.idl b/modules/libpref/nsIPrefBranchInternal.idl
new file mode 100644
--- /dev/null
+++ b/modules/libpref/nsIPrefBranchInternal.idl
@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIPrefBranch2.idl"
+
+/**
+ * An empty interface to provide backwards compatibility for existing code that
+ * bsmedberg didn't want to break all at once. Don't use me!
+ *
+ * @status NON-FROZEN interface WHICH WILL PROBABLY GO AWAY.
+ */
+
+[scriptable, uuid(355bd1e9-248a-438b-809d-e0db1b287882)]
+interface nsIPrefBranchInternal : nsIPrefBranch2
+{
+};
diff --git a/toolkit/content/widgets/preferences.xml b/toolkit/content/widgets/preferences.xml
new file mode 100644
--- /dev/null
+++ b/toolkit/content/widgets/preferences.xml
@@ -0,0 +1,1409 @@
+<?xml version="1.0"?>
+
+<!DOCTYPE bindings [
+  <!ENTITY % preferencesDTD SYSTEM "chrome://global/locale/preferences.dtd">
+  %preferencesDTD;
+  <!ENTITY % globalKeysDTD SYSTEM "chrome://global/locale/globalKeys.dtd">
+  %globalKeysDTD;
+]>
+
+<bindings id="preferencesBindings"
+          xmlns="http://www.mozilla.org/xbl"
+          xmlns:xbl="http://www.mozilla.org/xbl"
+          xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+
+#
+# = Preferences Window Framework
+#
+#   The syntax for use looks something like:
+#
+#   <prefwindow>
+#     <prefpane id="prefPaneA">
+#       <preferences>
+#         <preference id="preference1" name="app.preference1" type="bool" onchange="foo();"/>
+#         <preference id="preference2" name="app.preference2" type="bool" useDefault="true"/>
+#       </preferences>
+#       <checkbox label="Preference" preference="preference1"/>
+#     </prefpane>
+#   </prefwindow>
+#
+
+  <binding id="preferences">
+    <implementation implements="nsIObserver">
+      <method name="_constructAfterChildren">
+      <body>
+      <![CDATA[
+      // This method will be called after the last of the child
+      // <preference> elements is constructed. Its purpose is to propagate
+      // the values to the associated form elements. Sometimes the code for
+      // some <preference> initializers depend on other <preference> elements
+      // being initialized so we wait and call updateElements on all of them
+      // once the last one has been constructed. See bugs 997570 and 992185.
+
+      var elements = this.getElementsByTagName("preference");
+      for (let element of elements) {
+        element.updateElements();
+      }
+
+      this._constructAfterChildrenCalled = true;
+      ]]>
+      </body>
+      </method>
+      <method name="observe">
+        <parameter name="aSubject"/>
+        <parameter name="aTopic"/>
+        <parameter name="aData"/>
+        <body>
+        <![CDATA[
+          for (var i = 0; i < this.childNodes.length; ++i) {
+            var preference = this.childNodes[i];
+            if (preference.name == aData) {
+              preference.value = preference.valueFromPreferences;
+            }
+          }
+        ]]>
+        </body>
+      </method>
+
+      <method name="fireChangedEvent">
+        <parameter name="aPreference"/>
+        <body>
+        <![CDATA[
+          // Value changed, synthesize an event
+          try {
+            var event = document.createEvent("Events");
+            event.initEvent("change", true, true);
+            aPreference.dispatchEvent(event);
+          } catch (e) {
+            Components.utils.reportError(e);
+          }
+        ]]>
+        </body>
+      </method>
+
+      <field name="service">
+        Components.classes["@mozilla.org/preferences-service;1"]
+                  .getService(Components.interfaces.nsIPrefService);
+      </field>
+      <field name="rootBranch">
+        Components.classes["@mozilla.org/preferences-service;1"]
+                  .getService(Components.interfaces.nsIPrefBranch);
+      </field>
+      <field name="defaultBranch">
+        this.service.getDefaultBranch("");
+      </field>
+      <field name="rootBranchInternal">
+        Components.classes["@mozilla.org/preferences-service;1"]
+                  .getService(Components.interfaces.nsIPrefBranch);
+      </field>
+      <property name="type" readonly="true">
+        <getter>
+          <![CDATA[
+            return document.documentElement.type || "";
+          ]]>
+        </getter>
+      </property>
+      <property name="instantApply" readonly="true">
+        <getter>
+          <![CDATA[
+            var doc = document.documentElement;
+            return this.type == "child" ? doc.instantApply
+                                        : doc.instantApply || this.rootBranch.getBoolPref("browser.preferences.instantApply");
+          ]]>
+        </getter>
+      </property>
+
+      <!-- We want to call _constructAfterChildren after all child
+           <preference> elements have been constructed. To do this, we get
+           and store the node list of all child <preference> elements in the
+           constructor, and maintain a count which is incremented in the
+           constructor of <preference>. _constructAfterChildren is called
+           when the count matches the length of the list. -->
+      <field name="_constructedChildrenCount">0</field>
+      <field name="_preferenceChildren">null</field>
+      <!-- Some <preference> elements are added dynamically after
+           _constructAfterChildren has already been called - we want to
+           avoid looping over all of them again in this case so we remember
+           if we already called it. -->
+      <field name="_constructAfterChildrenCalled">false</field>
+      <constructor>
+      <![CDATA[
+        this._preferenceChildren = this.getElementsByTagName("preference");
+      ]]>
+      </constructor>
+    </implementation>
+  </binding>
+
+  <binding id="preference">
+    <implementation>
+      <constructor>
+      <![CDATA[
+        // if the element has been inserted without the name attribute set,
+        // we have nothing to do here
+        if (!this.name)
+          return;
+
+        this.preferences.rootBranchInternal
+            .addObserver(this.name, this.preferences);
+        // In non-instant apply mode, we must try and use the last saved state
+        // from any previous opens of a child dialog instead of the value from
+        // preferences, to pick up any edits a user may have made.
+
+        var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
+                    .getService(Components.interfaces.nsIScriptSecurityManager);
+        if (this.preferences.type == "child" &&
+            !this.instantApply && window.opener &&
+            secMan.isSystemPrincipal(window.opener.document.nodePrincipal)) {
+          var pdoc = window.opener.document;
+
+          // Try to find a preference element for the same preference.
+          var preference = null;
+          var parentPreferences = pdoc.getElementsByTagName("preferences");
+          for (var k = 0; (k < parentPreferences.length && !preference); ++k) {
+            var parentPrefs = parentPreferences[k]
+                                    .getElementsByAttribute("name", this.name);
+            for (var l = 0; (l < parentPrefs.length && !preference); ++l) {
+              if (parentPrefs[l].localName == "preference")
+                preference = parentPrefs[l];
+            }
+          }
+
+          // Don't use the value setter here, we don't want updateElements to be prematurely fired.
+          this._value = preference ? preference.value : this.valueFromPreferences;
+        } else {
+          this._value = this.valueFromPreferences;
+        }
+        if (this.preferences._constructAfterChildrenCalled) {
+          // This <preference> was added after _constructAfterChildren() was already called.
+          // We can directly call updateElements().
+          this.updateElements();
+          return;
+        }
+        this.preferences._constructedChildrenCount++;
+        if (this.preferences._constructedChildrenCount ==
+            this.preferences._preferenceChildren.length) {
+          // This is the last <preference>, time to updateElements() on all of them.
+          this.preferences._constructAfterChildren();
+        }
+      ]]>
+      </constructor>
+      <destructor>
+        this.preferences.rootBranchInternal
+            .removeObserver(this.name, this.preferences);
+      </destructor>
+      <field name="_constructed">false</field>
+      <property name="instantApply">
+        <getter>
+          if (this.getAttribute("instantApply") == "false")
+            return false;
+          return this.getAttribute("instantApply") == "true" || this.preferences.instantApply;
+        </getter>
+      </property>
+
+      <property name="preferences" onget="return this.parentNode"/>
+      <property name="name" onget="return this.getAttribute('name');">
+        <setter>
+          if (val == this.name)
+            return val;
+
+          this.preferences.rootBranchInternal
+              .removeObserver(this.name, this.preferences);
+          this.setAttribute("name", val);
+          this.preferences.rootBranchInternal
+              .addObserver(val, this.preferences);
+
+          return val;
+        </setter>
+      </property>
+      <property name="type" onget="return this.getAttribute('type');"
+                            onset="this.setAttribute('type', val); return val;"/>
+      <property name="inverted" onget="return this.getAttribute('inverted') == 'true';"
+                                onset="this.setAttribute('inverted', val); return val;"/>
+      <property name="readonly" onget="return this.getAttribute('readonly') == 'true';"
+                                onset="this.setAttribute('readonly', val); return val;"/>
+
+      <field name="_value">null</field>
+      <method name="_setValue">
+        <parameter name="aValue"/>
+        <body>
+        <![CDATA[
+          if (this.value !== aValue) {
+            this._value = aValue;
+            if (this.instantApply)
+              this.valueFromPreferences = aValue;
+            this.preferences.fireChangedEvent(this);
+          }
+          return aValue;
+        ]]>
+        </body>
+      </method>
+      <property name="value" onget="return this._value" onset="return this._setValue(val);"/>
+
+      <property name="locked">
+        <getter>
+          return this.preferences.rootBranch.prefIsLocked(this.name);
+        </getter>
+      </property>
+
+      <property name="disabled">
+        <getter>
+          return this.getAttribute("disabled") == "true";
+        </getter>
+        <setter>
+        <![CDATA[
+          if (val)
+            this.setAttribute("disabled", "true");
+          else
+            this.removeAttribute("disabled");
+
+          if (!this.id)
+            return val;
+
+          var elements = document.getElementsByAttribute("preference", this.id);
+          for (var i = 0; i < elements.length; ++i) {
+            elements[i].disabled = val;
+
+            var labels = document.getElementsByAttribute("control", elements[i].id);
+            for (var j = 0; j < labels.length; ++j)
+              labels[j].disabled = val;
+          }
+
+          return val;
+        ]]>
+        </setter>
+      </property>
+
+      <property name="tabIndex">
+        <getter>
+          return parseInt(this.getAttribute("tabindex"));
+        </getter>
+        <setter>
+        <![CDATA[
+          if (val)
+            this.setAttribute("tabindex", val);
+          else
+            this.removeAttribute("tabindex");
+
+          if (!this.id)
+            return val;
+
+          var elements = document.getElementsByAttribute("preference", this.id);
+          for (var i = 0; i < elements.length; ++i) {
+            elements[i].tabIndex = val;
+
+            var labels = document.getElementsByAttribute("control", elements[i].id);
+            for (var j = 0; j < labels.length; ++j)
+              labels[j].tabIndex = val;
+          }
+
+          return val;
+        ]]>
+        </setter>
+      </property>
+
+      <property name="hasUserValue">
+        <getter>
+        <![CDATA[
+          return this.preferences.rootBranch.prefHasUserValue(this.name) &&
+                 this.value !== undefined;
+        ]]>
+        </getter>
+      </property>
+
+      <method name="reset">
+        <body>
+          // defer reset until preference update
+          this.value = undefined;
+        </body>
+      </method>
+
+      <field name="_useDefault">false</field>
+      <property name="defaultValue">
+        <getter>
+        <![CDATA[
+          this._useDefault = true;
+          var val = this.valueFromPreferences;
+          this._useDefault = false;
+          return val;
+        ]]>
+        </getter>
+      </property>
+
+      <property name="_branch">
+        <getter>
+          return this._useDefault ? this.preferences.defaultBranch : this.preferences.rootBranch;
+        </getter>
+      </property>
+
+      <field name="batching">false</field>
+
+      <method name="_reportUnknownType">
+        <body>
+        <![CDATA[
+          var consoleService = Components.classes["@mozilla.org/consoleservice;1"]
+                                         .getService(Components.interfaces.nsIConsoleService);
+          var msg = "<preference> with id='" + this.id + "' and name='" +
+                    this.name + "' has unknown type '" + this.type + "'.";
+          consoleService.logStringMessage(msg);
+        ]]>
+        </body>
+      </method>
+
+      <property name="valueFromPreferences">
+        <getter>
+        <![CDATA[
+          try {
+            // Force a resync of value with preferences.
+            switch (this.type) {
+            case "int":
+              return this._branch.getIntPref(this.name);
+            case "bool":
+              var val = this._branch.getBoolPref(this.name);
+              return this.inverted ? !val : val;
+            case "wstring":
+              return this._branch
+                         .getComplexValue(this.name, Components.interfaces.nsIPrefLocalizedString)
+                         .data;
+            case "string":
+            case "unichar":
+              return this._branch.getStringPref(this.name);
+            case "fontname":
+              var family = this._branch.getStringPref(this.name);
+              var fontEnumerator = Components.classes["@mozilla.org/gfx/fontenumerator;1"]
+                                             .createInstance(Components.interfaces.nsIFontEnumerator);
+              return fontEnumerator.getStandardFamilyName(family);
+            case "file":
+              var f = this._branch
+                          .getComplexValue(this.name, Components.interfaces.nsIFile);
+              return f;
+            default:
+              this._reportUnknownType();
+            }
+          } catch (e) { }
+          return null;
+        ]]>
+        </getter>
+        <setter>
+        <![CDATA[
+          // Exit early if nothing to do.
+          if (this.readonly || this.valueFromPreferences == val)
+            return val;
+
+          // The special value undefined means 'reset preference to default'.
+          if (val === undefined) {
+            this.preferences.rootBranch.clearUserPref(this.name);
+            return val;
+          }
+
+          // Force a resync of preferences with value.
+          switch (this.type) {
+          case "int":
+            this.preferences.rootBranch.setIntPref(this.name, val);
+            break;
+          case "bool":
+            this.preferences.rootBranch.setBoolPref(this.name, this.inverted ? !val : val);
+            break;
+          case "wstring":
+            var pls = Components.classes["@mozilla.org/pref-localizedstring;1"]
+                                .createInstance(Components.interfaces.nsIPrefLocalizedString);
+            pls.data = val;
+            this.preferences.rootBranch
+                .setComplexValue(this.name, Components.interfaces.nsIPrefLocalizedString, pls);
+            break;
+          case "string":
+          case "unichar":
+          case "fontname":
+            this.preferences.rootBranch.setStringPref(this.name, val);
+            break;
+          case "file":
+            var lf;
+            if (typeof(val) == "string") {
+              lf = Components.classes["@mozilla.org/file/local;1"]
+                             .createInstance(Components.interfaces.nsIFile);
+              lf.persistentDescriptor = val;
+              if (!lf.exists())
+                lf.initWithPath(val);
+            } else
+              lf = val.QueryInterface(Components.interfaces.nsIFile);
+            this.preferences.rootBranch
+                .setComplexValue(this.name, Components.interfaces.nsIFile, lf);
+            break;
+          default:
+            this._reportUnknownType();
+          }
+          if (!this.batching)
+            this.preferences.service.savePrefFile(null);
+          return val;
+        ]]>
+        </setter>
+      </property>
+
+      <method name="setElementValue">
+        <parameter name="aElement"/>
+        <body>
+        <![CDATA[
+          if (this.locked)
+            aElement.disabled = true;
+
+          if (!this.isElementEditable(aElement))
+            return;
+
+          var rv = undefined;
+          if (aElement.hasAttribute("onsyncfrompreference")) {
+            // Value changed, synthesize an event
+            try {
+              var event = document.createEvent("Events");
+              event.initEvent("syncfrompreference", true, true);
+              var f = new Function("event",
+                                   aElement.getAttribute("onsyncfrompreference"));
+              rv = f.call(aElement, event);
+            } catch (e) {
+              Components.utils.reportError(e);
+            }
+          }
+          var val = rv;
+          if (val === undefined)
+            val = this.instantApply ? this.valueFromPreferences : this.value;
+          // if the preference is marked for reset, show default value in UI
+          if (val === undefined)
+            val = this.defaultValue;
+
+          /**
+           * Initialize a UI element property with a value. Handles the case
+           * where an element has not yet had a XBL binding attached for it and
+           * the property setter does not yet exist by setting the same attribute
+           * on the XUL element using DOM apis and assuming the element's
+           * constructor or property getters appropriately handle this state.
+           */
+          function setValue(element, attribute, value) {
+            if (attribute in element)
+              element[attribute] = value;
+            else
+              element.setAttribute(attribute, value);
+          }
+          if (aElement.localName == "checkbox" ||
+              aElement.localName == "listitem")
+            setValue(aElement, "checked", val);
+          else if (aElement.localName == "colorpicker")
+            setValue(aElement, "color", val);
+          else if (aElement.localName == "textbox") {
+            // XXXmano Bug 303998: Avoid a caret placement issue if either the
+            // preference observer or its setter calls updateElements as a result
+            // of the input event handler.
+            if (aElement.value !== val)
+              setValue(aElement, "value", val);
+          } else
+            setValue(aElement, "value", val);
+        ]]>
+        </body>
+      </method>
+
+      <method name="getElementValue">
+        <parameter name="aElement"/>
+        <body>
+        <![CDATA[
+          if (aElement.hasAttribute("onsynctopreference")) {
+            // Value changed, synthesize an event
+            try {
+              var event = document.createEvent("Events");
+              event.initEvent("synctopreference", true, true);
+              var f = new Function("event",
+                                   aElement.getAttribute("onsynctopreference"));
+              var rv = f.call(aElement, event);
+              if (rv !== undefined)
+                return rv;
+            } catch (e) {
+              Components.utils.reportError(e);
+            }
+          }
+
+          /**
+           * Read the value of an attribute from an element, assuming the
+           * attribute is a property on the element's node API. If the property
+           * is not present in the API, then assume its value is contained in
+           * an attribute, as is the case before a binding has been attached.
+           */
+          function getValue(element, attribute) {
+            if (attribute in element)
+              return element[attribute];
+            return element.getAttribute(attribute);
+          }
+          if (aElement.localName == "checkbox" ||
+              aElement.localName == "listitem")
+            var value = getValue(aElement, "checked");
+          else if (aElement.localName == "colorpicker")
+            value = getValue(aElement, "color");
+          else
+            value = getValue(aElement, "value");
+
+          switch (this.type) {
+          case "int":
+            return parseInt(value, 10) || 0;
+          case "bool":
+            return typeof(value) == "boolean" ? value : value == "true";
+          }
+          return value;
+        ]]>
+        </body>
+      </method>
+
+      <method name="isElementEditable">
+        <parameter name="aElement"/>
+        <body>
+        <![CDATA[
+          switch (aElement.localName) {
+          case "checkbox":
+          case "colorpicker":
+          case "radiogroup":
+          case "textbox":
+          case "listitem":
+          case "listbox":
+          case "menulist":
+            return true;
+          }
+          return aElement.getAttribute("preference-editable") == "true";
+        ]]>
+        </body>
+      </method>
+
+      <method name="updateElements">
+        <body>
+        <![CDATA[
+          if (!this.id)
+            return;
+
+          // This "change" event handler tracks changes made to preferences by
+          // sources other than the user in this window.
+          var elements = document.getElementsByAttribute("preference", this.id);
+          for (var i = 0; i < elements.length; ++i)
+            this.setElementValue(elements[i]);
+        ]]>
+        </body>
+      </method>
+    </implementation>
+
+    <handlers>
+      <handler event="change">
+        this.updateElements();
+      </handler>
+    </handlers>
+  </binding>
+
+  <binding id="prefwindow"
+           extends="chrome://global/content/bindings/dialog.xml#dialog">
+    <resources>
+      <stylesheet src="chrome://global/skin/preferences.css"/>
+    </resources>
+    <content dlgbuttons="accept,cancel" persist="lastSelected screenX screenY"
+             closebuttonlabel="&preferencesCloseButton.label;"
+             closebuttonaccesskey="&preferencesCloseButton.accesskey;"
+             role="dialog"
+#ifdef XP_WIN
+             title="&preferencesDefaultTitleWin.title;">
+#else
+             title="&preferencesDefaultTitleMac.title;">
+#endif
+      <xul:windowdragbox orient="vertical">
+        <xul:radiogroup anonid="selector" orient="horizontal" class="paneSelector chromeclass-toolbar"
+                        role="listbox"/> <!-- Expose to accessibility APIs as a listbox -->
+      </xul:windowdragbox>
+      <xul:hbox flex="1" class="paneDeckContainer">
+        <xul:deck anonid="paneDeck" flex="1">
+          <children includes="prefpane"/>
+        </xul:deck>
+      </xul:hbox>
+      <xul:hbox anonid="dlg-buttons" class="prefWindow-dlgbuttons" pack="end">
+#ifdef XP_UNIX
+        <xul:button dlgtype="disclosure" class="dialog-button" hidden="true"/>
+        <xul:button dlgtype="help" class="dialog-button" hidden="true" icon="help"/>
+        <xul:button dlgtype="extra2" class="dialog-button" hidden="true"/>
+        <xul:button dlgtype="extra1" class="dialog-button" hidden="true"/>
+        <xul:spacer anonid="spacer" flex="1"/>
+        <xul:button dlgtype="cancel" class="dialog-button" icon="cancel"/>
+        <xul:button dlgtype="accept" class="dialog-button" icon="accept"/>
+#else
+        <xul:button dlgtype="extra2" class="dialog-button" hidden="true"/>
+        <xul:spacer anonid="spacer" flex="1"/>
+        <xul:button dlgtype="accept" class="dialog-button" icon="accept"/>
+        <xul:button dlgtype="extra1" class="dialog-button" hidden="true"/>
+        <xul:button dlgtype="cancel" class="dialog-button" icon="cancel"/>
+        <xul:button dlgtype="help" class="dialog-button" hidden="true" icon="help"/>
+        <xul:button dlgtype="disclosure" class="dialog-button" hidden="true"/>
+#endif
+      </xul:hbox>
+      <xul:hbox>
+        <children/>
+      </xul:hbox>
+    </content>
+    <implementation implements="nsITimerCallback">
+      <constructor>
+      <![CDATA[
+        if (this.type != "child") {
+          if (!this._instantApplyInitialized) {
+            let psvc = Components.classes["@mozilla.org/preferences-service;1"]
+                                 .getService(Components.interfaces.nsIPrefBranch);
+            this.instantApply = psvc.getBoolPref("browser.preferences.instantApply");
+          }
+          if (this.instantApply) {
+            var docElt = document.documentElement;
+            var acceptButton = docElt.getButton("accept");
+            acceptButton.hidden = true;
+            var cancelButton  = docElt.getButton("cancel");
+            if (/Mac/.test(navigator.platform)) {
+              // no buttons on Mac except Help
+              cancelButton.hidden = true;
+              // Move Help button to the end
+              document.getAnonymousElementByAttribute(this, "anonid", "spacer").hidden = true;
+              // Also, don't fire onDialogAccept on enter
+              acceptButton.disabled = true;
+            } else {
+              // morph the Cancel button into the Close button
+              cancelButton.setAttribute("icon", "close");
+              cancelButton.label = docElt.getAttribute("closebuttonlabel");
+              cancelButton.accesskey = docElt.getAttribute("closebuttonaccesskey");
+            }
+          }
+        }
+        this.setAttribute("animated", this._shouldAnimate ? "true" : "false");
+        var panes = this.preferencePanes;
+
+        var lastPane = null;
+        if (this.lastSelected) {
+          lastPane = document.getElementById(this.lastSelected);
+          if (!lastPane) {
+            this.lastSelected = "";
+          }
+        }
+
+        var paneToLoad;
+        if ("arguments" in window && window.arguments[0] && document.getElementById(window.arguments[0]) && document.getElementById(window.arguments[0]).nodeName == "prefpane") {
+          paneToLoad = document.getElementById(window.arguments[0]);
+          this.lastSelected = paneToLoad.id;
+        } else if (lastPane)
+          paneToLoad = lastPane;
+        else
+          paneToLoad = panes[0];
+
+        for (var i = 0; i < panes.length; ++i) {
+          this._makePaneButton(panes[i]);
+          if (panes[i].loaded) {
+            // Inline pane content, fire load event to force initialization.
+            this._fireEvent("paneload", panes[i]);
+          }
+        }
+        this.showPane(paneToLoad);
+
+        if (panes.length == 1)
+          this._selector.setAttribute("collapsed", "true");
+      ]]>
+      </constructor>
+
+      <destructor>
+      <![CDATA[
+        // Release timers to avoid reference cycles.
+        if (this._animateTimer) {
+          this._animateTimer.cancel();
+          this._animateTimer = null;
+        }
+        if (this._fadeTimer) {
+          this._fadeTimer.cancel();
+          this._fadeTimer = null;
+        }
+      ]]>
+      </destructor>
+
+      <!-- Derived bindings can set this to true to cause us to skip
+           reading the browser.preferences.instantApply pref in the constructor.
+           Then they can set instantApply to their wished value. -->
+      <field name="_instantApplyInitialized">false</field>
+      <!-- Controls whether changed pref values take effect immediately. -->
+      <field name="instantApply">false</field>
+
+      <property name="preferencePanes"
+                onget="return this.getElementsByTagName('prefpane');"/>
+
+      <property name="type" onget="return this.getAttribute('type');"/>
+      <property name="_paneDeck"
+                onget="return document.getAnonymousElementByAttribute(this, 'anonid', 'paneDeck');"/>
+      <property name="_paneDeckContainer"
+                onget="return document.getAnonymousElementByAttribute(this, 'class', 'paneDeckContainer');"/>
+      <property name="_selector"
+                onget="return document.getAnonymousElementByAttribute(this, 'anonid', 'selector');"/>
+      <property name="lastSelected"
+                onget="return this.getAttribute('lastSelected');">
+        <setter>
+          this.setAttribute("lastSelected", val);
+          document.persist(this.id, "lastSelected");
+          return val;
+        </setter>
+      </property>
+      <property name="currentPane"
+                onset="return this._currentPane = val;">
+        <getter>
+          if (!this._currentPane)
+            this._currentPane = this.preferencePanes[0];
+
+          return this._currentPane;
+        </getter>
+      </property>
+      <field name="_currentPane">null</field>
+
+
+      <method name="_makePaneButton">
+        <parameter name="aPaneElement"/>
+        <body>
+        <![CDATA[
+          var radio = document.createElement("radio");
+          radio.setAttribute("pane", aPaneElement.id);
+          radio.setAttribute("label", aPaneElement.label);
+          // Expose preference group choice to accessibility APIs as an unchecked list item
+          // The parent group is exposed to accessibility APIs as a list
+          if (aPaneElement.image)
+            radio.setAttribute("src", aPaneElement.image);
+          radio.style.listStyleImage = aPaneElement.style.listStyleImage;
+          this._selector.appendChild(radio);
+          return radio;
+        ]]>
+        </body>
+      </method>
+
+      <method name="showPane">
+        <parameter name="aPaneElement"/>
+        <body>
+        <![CDATA[
+          if (!aPaneElement)
+            return;
+
+          this._selector.selectedItem = document.getAnonymousElementByAttribute(this, "pane", aPaneElement.id);
+          if (!aPaneElement.loaded) {
+            let OverlayLoadObserver = function(aPane) {
+              this._pane = aPane;
+            };
+            OverlayLoadObserver.prototype = {
+              _outer: this,
+              observe(aSubject, aTopic, aData) {
+                this._pane.loaded = true;
+                this._outer._fireEvent("paneload", this._pane);
+                this._outer._selectPane(this._pane);
+              }
+            };
+
+            var obs = new OverlayLoadObserver(aPaneElement);
+            document.loadOverlay(aPaneElement.src, obs);
+          } else
+            this._selectPane(aPaneElement);
+        ]]>
+        </body>
+      </method>
+
+      <method name="_fireEvent">
+        <parameter name="aEventName"/>
+        <parameter name="aTarget"/>
+        <body>
+        <![CDATA[
+          // Panel loaded, synthesize a load event.
+          try {
+            var event = document.createEvent("Events");
+            event.initEvent(aEventName, true, true);
+            var cancel = !aTarget.dispatchEvent(event);
+            if (aTarget.hasAttribute("on" + aEventName)) {
+              var fn = new Function("event", aTarget.getAttribute("on" + aEventName));
+              var rv = fn.call(aTarget, event);
+              if (rv == false)
+                cancel = true;
+            }
+            return !cancel;
+          } catch (e) {
+            Components.utils.reportError(e);
+          }
+          return false;
+        ]]>
+        </body>
+      </method>
+
+      <field name="_initialized">false</field>
+      <method name="_selectPane">
+        <parameter name="aPaneElement"/>
+        <body>
+        <![CDATA[
+          if (/Mac/.test(navigator.platform)) {
+            var paneTitle = aPaneElement.label;
+            if (paneTitle != "")
+              document.title = paneTitle;
+          }
+          var helpButton = document.documentElement.getButton("help");
+          if (aPaneElement.helpTopic)
+            helpButton.hidden = false;
+          else
+            helpButton.hidden = true;
+
+          // Find this pane's index in the deck and set the deck's
+          // selectedIndex to that value to switch to it.
+          var prefpanes = this.preferencePanes;
+          for (var i = 0; i < prefpanes.length; ++i) {
+            if (prefpanes[i] == aPaneElement) {
+              this._paneDeck.selectedIndex = i;
+
+              if (this.type != "child") {
+                if (aPaneElement.hasAttribute("flex") && this._shouldAnimate &&
+                    prefpanes.length > 1)
+                  aPaneElement.removeAttribute("flex");
+                // Calling sizeToContent after the first prefpane is loaded
+                // will size the windows contents so style information is
+                // available to calculate correct sizing.
+                if (!this._initialized && prefpanes.length > 1) {
+                  if (this._shouldAnimate)
+                    this.style.minHeight = 0;
+                  window.sizeToContent();
+                }
+
+                var oldPane = this.lastSelected ? document.getElementById(this.lastSelected) : this.preferencePanes[0];
+                oldPane.selected = !(aPaneElement.selected = true);
+                this.lastSelected = aPaneElement.id;
+                this.currentPane = aPaneElement;
+                this._initialized = true;
+
+                // Only animate if we've switched between prefpanes
+                if (this._shouldAnimate && oldPane.id != aPaneElement.id) {
+                  aPaneElement.style.opacity = 0.0;
+                  this.animate(oldPane, aPaneElement);
+                } else if (!this._shouldAnimate && prefpanes.length > 1) {
+                  var targetHeight = parseInt(window.getComputedStyle(this._paneDeckContainer).height);
+                  var verticalPadding = parseInt(window.getComputedStyle(aPaneElement).paddingTop);
+                  verticalPadding += parseInt(window.getComputedStyle(aPaneElement).paddingBottom);
+                  if (aPaneElement.contentHeight > targetHeight - verticalPadding) {
+                    // To workaround the bottom border of a groupbox from being
+                    // cutoff an hbox with a class of bottomBox may enclose it.
+                    // This needs to include its padding to resize properly.
+                    // See bug 394433
+                    var bottomPadding = 0;
+                    var bottomBox = aPaneElement.getElementsByAttribute("class", "bottomBox")[0];
+                    if (bottomBox)
+                      bottomPadding = parseInt(window.getComputedStyle(bottomBox).paddingBottom);
+                    window.innerHeight += bottomPadding + verticalPadding + aPaneElement.contentHeight - targetHeight;
+                  }
+
+                  // XXX rstrong - extend the contents of the prefpane to
+                  // prevent elements from being cutoff (see bug 349098).
+                  if (aPaneElement.contentHeight + verticalPadding < targetHeight)
+                    aPaneElement._content.style.height = targetHeight - verticalPadding + "px";
+                }
+              }
+              break;
+            }
+          }
+        ]]>
+        </body>
+      </method>
+
+      <property name="_shouldAnimate">
+        <getter>
+        <![CDATA[
+          var psvc = Components.classes["@mozilla.org/preferences-service;1"]
+                               .getService(Components.interfaces.nsIPrefBranch);
+          return psvc.getBoolPref("browser.preferences.animateFadeIn",
+                                  /Mac/.test(navigator.platform));
+        ]]>
+        </getter>
+      </property>
+
+      <method name="animate">
+        <parameter name="aOldPane"/>
+        <parameter name="aNewPane"/>
+        <body>
+        <![CDATA[
+          // if we are already resizing, use currentHeight
+          var oldHeight = this._currentHeight ? this._currentHeight : aOldPane.contentHeight;
+
+          this._multiplier = aNewPane.contentHeight > oldHeight ? 1 : -1;
+          var sizeDelta = Math.abs(oldHeight - aNewPane.contentHeight);
+          this._animateRemainder = sizeDelta % this._animateIncrement;
+
+          this._setUpAnimationTimer(oldHeight);
+        ]]>
+        </body>
+      </method>
+
+      <property name="_sizeIncrement">
+        <getter>
+        <![CDATA[
+          var lastSelectedPane = document.getElementById(this.lastSelected);
+          var increment = this._animateIncrement * this._multiplier;
+          var newHeight = this._currentHeight + increment;
+          if ((this._multiplier > 0 && this._currentHeight >= lastSelectedPane.contentHeight) ||
+              (this._multiplier < 0 && this._currentHeight <= lastSelectedPane.contentHeight))
+            return 0;
+
+          if ((this._multiplier > 0 && newHeight > lastSelectedPane.contentHeight) ||
+              (this._multiplier < 0 && newHeight < lastSelectedPane.contentHeight))
+            increment = this._animateRemainder * this._multiplier;
+          return increment;
+        ]]>
+        </getter>
+      </property>
+
+      <method name="notify">
+        <parameter name="aTimer"/>
+        <body>
+        <![CDATA[
+          if (!document)
+            aTimer.cancel();
+
+          if (aTimer == this._animateTimer) {
+            var increment = this._sizeIncrement;
+            if (increment != 0) {
+              window.innerHeight += increment;
+              this._currentHeight += increment;
+            } else {
+              aTimer.cancel();
+              this._setUpFadeTimer();
+            }
+          } else if (aTimer == this._fadeTimer) {
+            var elt = document.getElementById(this.lastSelected);
+            var newOpacity = parseFloat(window.getComputedStyle(elt).opacity) + this._fadeIncrement;
+            if (newOpacity < 1.0)
+              elt.style.opacity = newOpacity;
+            else {
+              aTimer.cancel();
+              elt.style.opacity = 1.0;
+            }
+          }
+        ]]>
+        </body>
+      </method>
+
+      <method name="_setUpAnimationTimer">
+        <parameter name="aStartHeight"/>
+        <body>
+        <![CDATA[
+          if (!this._animateTimer)
+            this._animateTimer = Components.classes["@mozilla.org/timer;1"]
+                                           .createInstance(Components.interfaces.nsITimer);
+          else
+            this._animateTimer.cancel();
+          this._currentHeight = aStartHeight;
+
+          this._animateTimer.initWithCallback(this, this._animateDelay,
+                                              Components.interfaces.nsITimer.TYPE_REPEATING_SLACK);
+        ]]>
+        </body>
+      </method>
+
+      <method name="_setUpFadeTimer">
+        <body>
+        <![CDATA[
+          if (!this._fadeTimer)
+            this._fadeTimer = Components.classes["@mozilla.org/timer;1"]
+                                        .createInstance(Components.interfaces.nsITimer);
+          else
+            this._fadeTimer.cancel();
+
+          this._fadeTimer.initWithCallback(this, this._fadeDelay,
+                                           Components.interfaces.nsITimer.TYPE_REPEATING_SLACK);
+        ]]>
+        </body>
+      </method>
+
+      <field name="_animateTimer">null</field>
+      <field name="_fadeTimer">null</field>
+      <field name="_animateDelay">15</field>
+      <field name="_animateIncrement">40</field>
+      <field name="_fadeDelay">5</field>
+      <field name="_fadeIncrement">0.40</field>
+      <field name="_animateRemainder">0</field>
+      <field name="_currentHeight">0</field>
+      <field name="_multiplier">0</field>
+
+      <method name="addPane">
+        <parameter name="aPaneElement"/>
+        <body>
+        <![CDATA[
+          this.appendChild(aPaneElement);
+
+          // Set up pane button
+          this._makePaneButton(aPaneElement);
+        ]]>
+        </body>
+      </method>
+
+      <method name="openSubDialog">
+        <parameter name="aURL"/>
+        <parameter name="aFeatures"/>
+        <parameter name="aParams"/>
+        <body>
+          return openDialog(aURL, "", "modal,centerscreen,resizable=no" + (aFeatures != "" ? ("," + aFeatures) : ""), aParams);
+        </body>
+      </method>
+
+      <method name="openWindow">
+        <parameter name="aWindowType"/>
+        <parameter name="aURL"/>
+        <parameter name="aFeatures"/>
+        <parameter name="aParams"/>
+        <body>
+        <![CDATA[
+          var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
+                             .getService(Components.interfaces.nsIWindowMediator);
+          var win = aWindowType ? wm.getMostRecentWindow(aWindowType) : null;
+          if (win) {
+            if ("initWithParams" in win)
+              win.initWithParams(aParams);
+            win.focus();
+          } else {
+            var features = "resizable,dialog=no,centerscreen" + (aFeatures != "" ? ("," + aFeatures) : "");
+            var parentWindow = (this.instantApply || !window.opener || window.opener.closed) ? window : window.opener;
+            win = parentWindow.openDialog(aURL, "_blank", features, aParams);
+          }
+          return win;
+        ]]>
+        </body>
+      </method>
+    </implementation>
+    <handlers>
+      <handler event="dialogaccept">
+      <![CDATA[
+        if (!this._fireEvent("beforeaccept", this)) {
+          return false;
+        }
+
+        var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
+                    .getService(Components.interfaces.nsIScriptSecurityManager);
+        if (this.type == "child" && window.opener &&
+            secMan.isSystemPrincipal(window.opener.document.nodePrincipal)) {
+          var pdocEl = window.opener.document.documentElement;
+          if (pdocEl.instantApply) {
+            let panes = this.preferencePanes;
+            for (let i = 0; i < panes.length; ++i)
+              panes[i].writePreferences(true);
+          } else {
+            // Clone all the preferences elements from the child document and
+            // insert them into the pane collection of the parent.
+            var pdoc = window.opener.document;
+            if (pdoc.documentElement.localName == "prefwindow") {
+              var currentPane = pdoc.documentElement.currentPane;
+              var id = window.location.href + "#childprefs";
+              var childPrefs = pdoc.getElementById(id);
+              if (!childPrefs) {
+                childPrefs = pdoc.createElement("preferences");
+                currentPane.appendChild(childPrefs);
+                childPrefs.id = id;
+              }
+              let panes = this.preferencePanes;
+              for (let i = 0; i < panes.length; ++i) {
+                var preferences = panes[i].preferences;
+                for (var j = 0; j < preferences.length; ++j) {
+                  // Try to find a preference element for the same preference.
+                  var preference = null;
+                  var parentPreferences = pdoc.getElementsByTagName("preferences");
+                  for (var k = 0; (k < parentPreferences.length && !preference); ++k) {
+                    var parentPrefs = parentPreferences[k]
+                                         .getElementsByAttribute("name", preferences[j].name);
+                    for (var l = 0; (l < parentPrefs.length && !preference); ++l) {
+                      if (parentPrefs[l].localName == "preference")
+                        preference = parentPrefs[l];
+                    }
+                  }
+                  if (!preference) {
+                    // No matching preference in the parent window.
+                    preference = pdoc.createElement("preference");
+                    childPrefs.appendChild(preference);
+                    preference.name     = preferences[j].name;
+                    preference.type     = preferences[j].type;
+                    preference.inverted = preferences[j].inverted;
+                    preference.readonly = preferences[j].readonly;
+                    preference.disabled = preferences[j].disabled;
+                  }
+                  preference.value = preferences[j].value;
+                }
+              }
+            }
+          }
+        } else {
+          let panes = this.preferencePanes;
+          for (var i = 0; i < panes.length; ++i)
+            panes[i].writePreferences(false);
+
+          let psvc = Components.classes["@mozilla.org/preferences-service;1"]
+                               .getService(Components.interfaces.nsIPrefService);
+          psvc.savePrefFile(null);
+        }
+
+        return true;
+      ]]>
+      </handler>
+      <handler event="command">
+        if (event.originalTarget.hasAttribute("pane")) {
+          var pane = document.getElementById(event.originalTarget.getAttribute("pane"));
+          this.showPane(pane);
+        }
+      </handler>
+
+      <handler event="keypress" key="&windowClose.key;" modifiers="accel" phase="capturing">
+      <![CDATA[
+        if (this.instantApply)
+          window.close();
+        event.stopPropagation();
+        event.preventDefault();
+      ]]>
+      </handler>
+
+      <handler event="keypress"
+#ifdef XP_MACOSX
+               key="&openHelpMac.commandkey;" modifiers="accel"
+#else
+               keycode="&openHelp.commandkey;"
+#endif
+               phase="capturing">
+      <![CDATA[
+        var helpButton = this.getButton("help");
+        if (helpButton.disabled || helpButton.hidden)
+          return;
+        this._fireEvent("dialoghelp", this);
+        event.stopPropagation();
+        event.preventDefault();
+      ]]>
+      </handler>
+    </handlers>
+  </binding>
+
+  <binding id="prefpane">
+    <resources>
+      <stylesheet src="chrome://global/skin/preferences.css"/>
+    </resources>
+    <content>
+      <xul:vbox class="content-box" xbl:inherits="flex">
+        <children/>
+      </xul:vbox>
+    </content>
+    <implementation>
+      <method name="writePreferences">
+        <parameter name="aFlushToDisk"/>
+        <body>
+        <![CDATA[
+          // Write all values to preferences.
+          if (this._deferredValueUpdateElements.size) {
+            this._finalizeDeferredElements();
+          }
+
+          var preferences = this.preferences;
+          for (var i = 0; i < preferences.length; ++i) {
+            var preference = preferences[i];
+            preference.batching = true;
+            preference.valueFromPreferences = preference.value;
+            preference.batching = false;
+          }
+          if (aFlushToDisk) {
+            var psvc = Components.classes["@mozilla.org/preferences-service;1"]
+                                 .getService(Components.interfaces.nsIPrefService);
+            psvc.savePrefFile(null);
+          }
+        ]]>
+        </body>
+      </method>
+
+      <property name="src"
+                onget="return this.getAttribute('src');"
+                onset="this.setAttribute('src', val); return val;"/>
+      <property name="selected"
+                onget="return this.getAttribute('selected') == 'true';"
+                onset="this.setAttribute('selected', val); return val;"/>
+      <property name="image"
+                onget="return this.getAttribute('image');"
+                onset="this.setAttribute('image', val); return val;"/>
+      <property name="label"
+                onget="return this.getAttribute('label');"
+                onset="this.setAttribute('label', val); return val;"/>
+
+      <property name="preferenceElements"
+                onget="return this.getElementsByAttribute('preference', '*');"/>
+      <property name="preferences"
+                onget="return this.getElementsByTagName('preference');"/>
+
+      <property name="helpTopic">
+        <getter>
+        <![CDATA[
+          // if there are tabs, and the selected tab provides a helpTopic, return that
+          var box = this.getElementsByTagName("tabbox");
+          if (box[0]) {
+            var tab = box[0].selectedTab;
+            if (tab && tab.hasAttribute("helpTopic"))
+              return tab.getAttribute("helpTopic");
+          }
+
+          // otherwise, return the helpTopic of the current panel
+          return this.getAttribute("helpTopic");
+        ]]>
+        </getter>
+      </property>
+
+      <field name="_loaded">false</field>
+      <property name="loaded"
+                onget="return !this.src ? true : this._loaded;"
+                onset="this._loaded = val; return val;"/>
+
+      <method name="preferenceForElement">
+        <parameter name="aElement"/>
+        <body>
+          return document.getElementById(aElement.getAttribute("preference"));
+        </body>
+      </method>
+
+      <method name="getPreferenceElement">
+        <parameter name="aStartElement"/>
+        <body>
+        <![CDATA[
+          var temp = aStartElement;
+          while (temp && temp.nodeType == Node.ELEMENT_NODE &&
+                 !temp.hasAttribute("preference"))
+            temp = temp.parentNode;
+          return temp && temp.nodeType == Node.ELEMENT_NODE ?
+                 temp : aStartElement;
+        ]]>
+        </body>
+      </method>
+
+      <property name="DeferredTask" readonly="true">
+        <getter><![CDATA[
+          let module = {};
+          Components.utils.import("resource://gre/modules/DeferredTask.jsm", module);
+          Object.defineProperty(this, "DeferredTask", {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: module.DeferredTask
+          });
+          return module.DeferredTask;
+        ]]></getter>
+      </property>
+      <method name="_deferredValueUpdate">
+        <parameter name="aElement"/>
+        <body>
+        <![CDATA[
+          delete aElement._deferredValueUpdateTask;
+          let preference = document.getElementById(aElement.getAttribute("preference"));
+          let prefVal = preference.getElementValue(aElement);
+          preference.value = prefVal;
+          this._deferredValueUpdateElements.delete(aElement);
+        ]]>
+        </body>
+      </method>
+      <field name="_deferredValueUpdateElements">
+        new Set();
+      </field>
+      <method name="_finalizeDeferredElements">
+        <body>
+        <![CDATA[
+          for (let el of this._deferredValueUpdateElements) {
+            if (el._deferredValueUpdateTask) {
+              el._deferredValueUpdateTask.finalize();
+            }
+          }
+        ]]>
+        </body>
+      </method>
+      <method name="userChangedValue">
+        <parameter name="aElement"/>
+        <body>
+        <![CDATA[
+          let element = this.getPreferenceElement(aElement);
+          if (element.hasAttribute("preference")) {
+            if (element.getAttribute("delayprefsave") != "true") {
+              var preference = document.getElementById(element.getAttribute("preference"));
+              var prefVal = preference.getElementValue(element);
+              preference.value = prefVal;
+            } else {
+              if (!element._deferredValueUpdateTask) {
+                element._deferredValueUpdateTask = new this.DeferredTask(this._deferredValueUpdate.bind(this, element), 1000);
+                this._deferredValueUpdateElements.add(element);
+              } else {
+                // Each time the preference is changed, restart the delay.
+                element._deferredValueUpdateTask.disarm();
+              }
+              element._deferredValueUpdateTask.arm();
+            }
+          }
+        ]]>
+        </body>
+      </method>
+
+      <property name="contentHeight">
+        <getter>
+          var targetHeight = parseInt(window.getComputedStyle(this._content).height);
+          targetHeight += parseInt(window.getComputedStyle(this._content).marginTop);
+          targetHeight += parseInt(window.getComputedStyle(this._content).marginBottom);
+          return targetHeight;
+        </getter>
+      </property>
+      <field name="_content">
+        document.getAnonymousElementByAttribute(this, "class", "content-box");
+      </field>
+    </implementation>
+    <handlers>
+      <handler event="command">
+        // This "command" event handler tracks changes made to preferences by
+        // the user in this window.
+        if (event.sourceEvent)
+          event = event.sourceEvent;
+        this.userChangedValue(event.target);
+      </handler>
+      <handler event="select">
+        // This "select" event handler tracks changes made to colorpicker
+        // preferences by the user in this window.
+        if (event.target.localName == "colorpicker")
+          this.userChangedValue(event.target);
+      </handler>
+      <handler event="change">
+        // This "change" event handler tracks changes made to preferences by
+        // the user in this window.
+        this.userChangedValue(event.target);
+      </handler>
+      <handler event="input">
+        // This "input" event handler tracks changes made to preferences by
+        // the user in this window.
+        this.userChangedValue(event.target);
+      </handler>
+      <handler event="paneload">
+      <![CDATA[
+        // Initialize all values from preferences.
+        var elements = this.preferenceElements;
+        for (var i = 0; i < elements.length; ++i) {
+          try {
+            var preference = this.preferenceForElement(elements[i]);
+            preference.setElementValue(elements[i]);
+          } catch (e) {
+            dump("*** No preference found for " + elements[i].getAttribute("preference") + "\n");
+          }
+        }
+      ]]>
+      </handler>
+    </handlers>
+  </binding>
+
+  <binding id="panebutton" role="xul:listitem"
+           extends="chrome://global/content/bindings/radio.xml#radio">
+    <resources>
+      <stylesheet src="chrome://global/skin/preferences.css"/>
+    </resources>
+    <content>
+      <xul:image class="paneButtonIcon" xbl:inherits="src"/>
+      <xul:label class="paneButtonLabel" xbl:inherits="value=label"/>
+    </content>
+  </binding>
+
+</bindings>
+
+# -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+# 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/.
+
+#
+# This is PrefWindow 6. The Code Could Well Be Ready, Are You?
+#
+#    Historical References:
+#    PrefWindow V   (February 1, 2003)
+#    PrefWindow IV  (April 24, 2000)
+#    PrefWindow III (January 6, 2000)
+#    PrefWindow II  (???)
+#    PrefWindow I   (June 4, 1999)
+#
diff --git a/toolkit/themes/linux/global/preferences.css b/toolkit/themes/linux/global/preferences.css
new file mode 100644
--- /dev/null
+++ b/toolkit/themes/linux/global/preferences.css
@@ -0,0 +1,62 @@
+/* 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/. */
+
+/* ===== preferences.css =====================================================
+  == Styles used by the XUL prefwindow element.
+  ======================================================================= */
+
+@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");
+
+/* ::::: dialog ::::: */
+
+prefwindow {
+  padding: 0px;
+}
+
+prefpane {
+  padding: 8px;
+}
+
+prefwindow[type="child"] {
+  padding: 8px;
+}
+
+prefwindow[type="child"] > prefpane {
+  padding: 0px;
+}
+
+.prefWindow-dlgbuttons {
+  padding-bottom: 8px;
+  padding-inline-start: 8px;
+  padding-inline-end: 8px;
+}
+
+prefwindow[type="child"] .prefWindow-dlgbuttons {
+  padding: 0px;
+}
+
+radio[pane] {
+  -moz-appearance: none;
+  min-width: 4.5em;
+  margin: 0;
+  padding: 3px;
+  color: -moz-FieldText;
+}
+
+.paneSelector {
+  -moz-appearance: listbox;
+  margin: 8px 8px 0 8px;
+  padding: 0;
+}
+
+.paneButtonIcon {
+  width: 32px;
+  height: 32px;
+}
+
+radio[pane][selected="true"] {
+  background-color: Highlight;
+  color: HighlightText;
+}
+
diff --git a/toolkit/themes/osx/global/preferences.css b/toolkit/themes/osx/global/preferences.css
new file mode 100644
--- /dev/null
+++ b/toolkit/themes/osx/global/preferences.css
@@ -0,0 +1,59 @@
+/* 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/. */
+
+@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");
+
+prefwindow {
+  padding: 0;
+  font: -moz-dialog !important;
+}
+
+prefpane {
+  padding: 12px 12px 0 12px;
+}
+
+prefwindow[type="child"] > prefpane {
+  padding: 0;
+}
+
+.prefWindow-dlgbuttons {
+  margin: 0 12px 12px;
+  padding-top: 0 !important;
+}
+
+.paneSelector {
+  font: message-box;
+  padding: 1px 4px;
+  -moz-appearance: toolbar;
+  margin: 0;
+}
+
+radio[pane] {
+  border: solid transparent;
+  border-width: 0 2px;
+  padding: 5px 4px 3px;
+  margin: 0;
+  -moz-appearance: none;
+  text-shadow: rgba(255, 255, 255, 0.4) 0 1px;
+}
+
+radio[pane]:active:hover {
+  text-shadow: none;
+}
+
+radio[pane]:active:hover > .paneButtonIcon {
+  filter: brightness(0.55);
+}
+
+radio[pane][selected="true"] {
+  -moz-border-image: url("chrome://global/skin/icons/panebutton-active.png") 0 2 fill repeat stretch;
+}
+
+radio[pane][selected="true"]:-moz-window-inactive {
+  -moz-border-image: url("chrome://global/skin/icons/panebutton-inactive.png") 0 2 fill repeat stretch;
+}
+
+.paneButtonLabel {
+  margin: 0 !important;
+}
diff --git a/toolkit/themes/windows/global/preferences.css b/toolkit/themes/windows/global/preferences.css
new file mode 100644
--- /dev/null
+++ b/toolkit/themes/windows/global/preferences.css
@@ -0,0 +1,76 @@
+/* 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/. */
+
+/* ===== preferences.css =====================================================
+  == Styles used by the XUL prefwindow element.
+  ======================================================================= */
+
+@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");
+
+/* ::::: dialog ::::: */
+
+prefwindow {
+  padding: 0px;
+}
+
+prefpane {
+  padding-top: 8px;
+  padding-bottom: 10px;
+  padding-inline-start: 8px;
+  padding-inline-end: 10px;
+}
+
+prefwindow[type="child"] {
+  padding-top: 8px;
+  padding-bottom: 10px;
+  padding-inline-start: 8px;
+  padding-inline-end: 10px;
+}
+
+prefwindow[type="child"] > prefpane {
+  padding: 0px;
+}
+
+.prefWindow-dlgbuttons {
+  padding-bottom: 10px;
+  padding-inline-start: 8px;
+  padding-inline-end: 10px;
+}
+
+prefwindow[type="child"] .prefWindow-dlgbuttons {
+  padding: 0px;
+}
+
+radio[pane] {
+  -moz-appearance: none;
+  margin: 0px 1px 0px 1px;
+  padding: 1px 3px 1px 3px;
+  min-width: 4.5em;
+}
+
+.paneSelector {
+  border-bottom: 2px groove ThreeDFace;
+  margin: 0px;
+  padding-inline-start: 10px;
+  background-color: -moz-Field;
+  color: -moz-FieldText;
+}
+
+.paneButtonIcon {
+  width: 32px;
+  height: 32px;
+}
+
+radio[pane]:hover {
+  background-color: #E0E8F6;
+  color: black;
+  -moz-appearance: none;
+}
+
+radio[pane][selected="true"] {
+  background-color: #C1D2EE;
+  color: black; 
+  -moz-appearance: none;
+}
+
diff --git a/toolkit/xre/nsXREDirProvider.cpp b/toolkit/xre/nsXREDirProvider.cpp
--- a/toolkit/xre/nsXREDirProvider.cpp
+++ b/toolkit/xre/nsXREDirProvider.cpp
@@ -931,16 +931,34 @@ nsXREDirProvider::GetFilesInternal(const
                         directories);
     }
 
     rv = NS_NewArrayEnumerator(aResult, directories);
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = NS_SUCCESS_AGGREGATE_RESULT;
   }
+  else if (!strcmp(aProperty, NS_EXT_PREFS_DEFAULTS_DIR_LIST)) {
+    nsCOMArray<nsIFile> directories;
+
+    LoadDirsIntoArray(AddonManagerStartup::GetSingleton().ExtensionPaths(),
+                      kAppendPrefDir, directories);
+
+    if (mProfileDir) {
+      nsCOMPtr<nsIFile> overrideFile;
+      mProfileDir->Clone(getter_AddRefs(overrideFile));
+      overrideFile->AppendNative(NS_LITERAL_CSTRING(PREF_OVERRIDE_DIRNAME));
+
+      bool exists;
+      if (NS_SUCCEEDED(overrideFile->Exists(&exists)) && exists)
+        directories.AppendObject(overrideFile);
+    }
+
+    rv = NS_NewArrayEnumerator(aResult, directories);
+  }
   else
     rv = NS_ERROR_FAILURE;
 
   return rv;
 }
 
 NS_IMETHODIMP
 nsXREDirProvider::GetDirectory(nsIFile* *aResult)
@@ -1011,16 +1029,18 @@ nsXREDirProvider::DoStartup()
     nsCOMPtr<nsIObserver> em = do_GetService("@mozilla.org/addons/integration;1");
     if (em) {
       em->Observe(nullptr, "addons-startup", nullptr);
     } else {
       NS_WARNING("Failed to create Addons Manager.");
     }
 
     obsSvc->NotifyObservers(nullptr, "profile-after-change", kStartup);
+    obsSvc->NotifyObservers(nullptr, "load-extension-defaults", nullptr);
+
 
     // Any component that has registered for the profile-after-change category
     // should also be created at this time.
     (void)NS_CreateServicesFromCategory("profile-after-change", nullptr,
                                         "profile-after-change");
 
     if (gSafeMode && safeModeNecessary) {
       static const char16_t kCrashed[] = {'c','r','a','s','h','e','d','\0'};
diff --git a/xpcom/io/nsAppDirectoryServiceDefs.h b/xpcom/io/nsAppDirectoryServiceDefs.h
--- a/xpcom/io/nsAppDirectoryServiceDefs.h
+++ b/xpcom/io/nsAppDirectoryServiceDefs.h
@@ -53,16 +53,17 @@
 // other users of the profile. Without this prefix, the consumer
 // has exclusive access to this location.
 
 #define NS_SHARED                               "SHARED"
 
 #define NS_APP_PREFS_50_DIR                     "PrefD"         // Directory which contains user prefs
 #define NS_APP_PREFS_50_FILE                    "PrefF"
 #define NS_APP_PREFS_DEFAULTS_DIR_LIST          "PrefDL"
+#define NS_EXT_PREFS_DEFAULTS_DIR_LIST          "ExtPrefDL"
 #define NS_APP_PREFS_OVERRIDE_DIR               "PrefDOverride" // Directory for per-profile defaults
 
 #define NS_APP_USER_PROFILE_50_DIR              "ProfD"
 #define NS_APP_USER_PROFILE_LOCAL_50_DIR        "ProfLD"
 
 #define NS_APP_USER_CHROME_DIR                  "UChrm"
 #define NS_APP_USER_SEARCH_DIR                  "UsrSrchPlugns"
 
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1517467085 -3600
#      Thu Feb 01 07:38:05 2018 +0100
# Node ID 6c832c6b97b914181c39fb9f1d823eb37f878d9e
# Parent  efe09e7cec7fefd4c200b40a2bcfc4d8f555009c
Put back nsIURI.path

diff --git a/caps/NullPrincipalURI.cpp b/caps/NullPrincipalURI.cpp
--- a/caps/NullPrincipalURI.cpp
+++ b/caps/NullPrincipalURI.cpp
@@ -148,22 +148,34 @@ NullPrincipalURI::SetPassword(const nsAC
 NS_IMETHODIMP
 NullPrincipalURI::GetPathQueryRef(nsACString& _path)
 {
   _path = mPath;
   return NS_OK;
 }
 
 NS_IMETHODIMP
+NullPrincipalURI::GetPath(nsACString& _path)
+{
+  return GetPathQueryRef(_path);
+}
+
+NS_IMETHODIMP
 NullPrincipalURI::SetPathQueryRef(const nsACString& aPath)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
+NullPrincipalURI::SetPath(const nsACString& aPath)
+{
+  return SetPathQueryRef(aPath);
+}
+
+NS_IMETHODIMP
 NullPrincipalURI::GetFilePath(nsACString& aFilePath)
 {
   aFilePath.Truncate();
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 NullPrincipalURI::SetFilePath(const nsACString& aFilePath)
diff --git a/image/decoders/icon/nsIconURI.cpp b/image/decoders/icon/nsIconURI.cpp
--- a/image/decoders/icon/nsIconURI.cpp
+++ b/image/decoders/icon/nsIconURI.cpp
@@ -416,22 +416,34 @@ nsMozIconURI::SetPort(int32_t aPort)
 NS_IMETHODIMP
 nsMozIconURI::GetPathQueryRef(nsACString& aPath)
 {
   aPath.Truncate();
   return NS_OK;
 }
 
 NS_IMETHODIMP
+nsMozIconURI::GetPath(nsACString& aPath)
+{
+  return GetPathQueryRef(aPath);
+}
+
+NS_IMETHODIMP
 nsMozIconURI::SetPathQueryRef(const nsACString& aPath)
 {
   return NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
+nsMozIconURI::SetPath(const nsACString& aPath)
+{
+  return SetPathQueryRef(aPath);
+}
+
+NS_IMETHODIMP
 nsMozIconURI::GetFilePath(nsACString& aFilePath)
 {
   aFilePath.Truncate();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsMozIconURI::SetFilePath(const nsACString& aFilePath)
diff --git a/modules/libjar/nsJARURI.cpp b/modules/libjar/nsJARURI.cpp
--- a/modules/libjar/nsJARURI.cpp
+++ b/modules/libjar/nsJARURI.cpp
@@ -507,22 +507,34 @@ NS_IMETHODIMP
 nsJARURI::GetPathQueryRef(nsACString &aPath)
 {
     nsAutoCString entrySpec;
     mJAREntry->GetSpec(entrySpec);
     return FormatSpec(entrySpec, aPath, false);
 }
 
 NS_IMETHODIMP
+nsJARURI::GetPath(nsACString &aPath)
+{
+    return GetPathQueryRef(aPath);
+}
+
+NS_IMETHODIMP
 nsJARURI::SetPathQueryRef(const nsACString &aPath)
 {
     return NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
+nsJARURI::SetPath(const nsACString &aPath)
+{
+    return SetPathQueryRef(aPath);
+}
+
+NS_IMETHODIMP
 nsJARURI::GetAsciiSpec(nsACString &aSpec)
 {
     // XXX Shouldn't this like... make sure it returns ASCII or something?
     return GetSpec(aSpec);
 }
 
 NS_IMETHODIMP
 nsJARURI::GetAsciiHostPort(nsACString &aHostPort)
diff --git a/netwerk/base/nsIURI.idl b/netwerk/base/nsIURI.idl
--- a/netwerk/base/nsIURI.idl
+++ b/netwerk/base/nsIURI.idl
@@ -183,16 +183,17 @@ interface nsIURI : nsISupports
      * empty, depending on the protocol).
      *
      * Some characters may be escaped.
      *
      * This attribute contains query and ref parts for historical reasons.
      * Use the 'filePath' attribute if you do not want those parts included.
      */
     attribute AUTF8String pathQueryRef;
+    attribute AUTF8String path;
 
 
     /************************************************************************
      * An URI supports the following methods:
      */
 
     /**
      * URI equivalence test (not a strict string comparison).
diff --git a/netwerk/base/nsSimpleURI.cpp b/netwerk/base/nsSimpleURI.cpp
--- a/netwerk/base/nsSimpleURI.cpp
+++ b/netwerk/base/nsSimpleURI.cpp
@@ -447,22 +447,35 @@ nsSimpleURI::GetPathQueryRef(nsACString 
     if (mIsRefValid) {
         result += NS_LITERAL_CSTRING("#") + mRef;
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
+nsSimpleURI::GetPath(nsACString &result)
+{
+    return GetPathQueryRef(result);
+}
+
+NS_IMETHODIMP
 nsSimpleURI::SetPathQueryRef(const nsACString &aPath)
 {
     NS_ENSURE_STATE(mMutable);
 
     return SetPathQueryRefEscaped(aPath, true);
 }
+
+NS_IMETHODIMP
+nsSimpleURI::SetPath(const nsACString &aPath)
+{
+    return SetPathQueryRef(aPath);
+}
+
 nsresult
 nsSimpleURI::SetPathQueryRefEscaped(const nsACString &aPath, bool aNeedsEscape)
 {
     nsresult rv;
     nsAutoCString path;
     if (aNeedsEscape) {
         rv = NS_EscapeURL(aPath, esc_OnlyNonASCII, path, fallible);
         if (NS_FAILED(rv)) {
diff --git a/netwerk/base/nsStandardURL.cpp b/netwerk/base/nsStandardURL.cpp
--- a/netwerk/base/nsStandardURL.cpp
+++ b/netwerk/base/nsStandardURL.cpp
@@ -1474,16 +1474,22 @@ nsStandardURL::GetPort(int32_t *result)
 // result may contain unescaped UTF-8 characters
 NS_IMETHODIMP
 nsStandardURL::GetPathQueryRef(nsACString &result)
 {
     result = Path();
     return NS_OK;
 }
 
+NS_IMETHODIMP
+nsStandardURL::GetPath(nsACString &result)
+{
+    return GetPathQueryRef(result);
+}
+
 // result is ASCII
 NS_IMETHODIMP
 nsStandardURL::GetAsciiSpec(nsACString &result)
 {
     if (mSpecEncoding == eEncoding_Unknown) {
         if (IsASCII(mSpec))
             mSpecEncoding = eEncoding_ASCII;
         else
@@ -2225,16 +2231,22 @@ nsStandardURL::SetPathQueryRef(const nsA
         mBasename.mLen = -1;
         mExtension.mLen = -1;
         mQuery.mLen = -1;
         mRef.mLen = -1;
     }
     return NS_OK;
 }
 
+NS_IMETHODIMP
+nsStandardURL::SetPath(const nsACString &input)
+{
+    return SetPathQueryRef(input);
+}
+
 // When updating this also update SubstitutingURL::Mutator
 NS_IMPL_ISUPPORTS(nsStandardURL::Mutator,
                   nsIURISetters,
                   nsIURIMutator,
                   nsIStandardURLMutator,
                   nsIURLMutator,
                   nsIFileURLMutator)
 
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1517467105 -3600
#      Thu Feb 01 07:38:25 2018 +0100
# Node ID 2137bf585302b79c81a05bc155e5dbbf38b2171c
# Parent  6c832c6b97b914181c39fb9f1d823eb37f878d9e
Put back nsIProgrammingLanguage

diff --git a/xpcom/base/moz.build b/xpcom/base/moz.build
--- a/xpcom/base/moz.build
+++ b/xpcom/base/moz.build
@@ -15,16 +15,17 @@ XPIDL_SOURCES += [
     'nsIGZFileWriter.idl',
     'nsIInterfaceRequestor.idl',
     'nsILoadURIDelegate.idl',
     'nsIMemory.idl',
     'nsIMemoryInfoDumper.idl',
     'nsIMemoryReporter.idl',
     'nsIMessageLoop.idl',
     'nsIMutable.idl',
+    'nsIProgrammingLanguage.idl',
     'nsISecurityConsoleMessage.idl',
     'nsISupports.idl',
     'nsIUUIDGenerator.idl',
     'nsIVersionComparator.idl',
     'nsIWeakReference.idl',
     'nsrootidl.idl',
 ]
 
diff --git a/xpcom/base/nsIProgrammingLanguage.idl b/xpcom/base/nsIProgrammingLanguage.idl
new file mode 100644
--- /dev/null
+++ b/xpcom/base/nsIProgrammingLanguage.idl
@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+/**
+ * Legacy constants for specifying programming languages.
+ *
+ * JAVASCRIPT is needed to avoid breaking addons that use it in nsIClassInfo
+ * to define fields that are no longer needed.
+ *
+ * UNKNOWN and JAVASCRIPT are also used in implementations of
+ * nsIStackFrame::language.
+ */
+
+[scriptable, uuid(02ad9f22-3c98-46f3-be4e-2f5c9299e29a)]
+interface nsIProgrammingLanguage : nsISupports
+{
+    const uint32_t UNKNOWN     = 0;
+    // 1 is unused.
+    const uint32_t JAVASCRIPT  = 2;
+};
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1517467168 -3600
#      Thu Feb 01 07:39:28 2018 +0100
# Node ID 5893a1699bfbf011645ba69d5717881f16b3f330
# Parent  2137bf585302b79c81a05bc155e5dbbf38b2171c
Who needs security theater?

diff --git a/browser/app/profile/firefox.js b/browser/app/profile/firefox.js
--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -79,17 +79,17 @@ pref("extensions.webextensions.default-c
 #ifdef XP_WIN
 pref("extensions.webextensions.remote", true);
 #endif
 
 // Extensions that should not be flagged as legacy in about:addons
 pref("extensions.legacy.exceptions", "{972ce4c6-7e08-4474-a285-3208198ce6fd},testpilot@cliqz.com,@testpilot-containers,jid1-NeEaf3sAHdKHPA@jetpack,@activity-streams,pulse@mozilla.com,@testpilot-addon,@min-vid,tabcentertest1@mozilla.com,snoozetabs@mozilla.com,speaktome@mozilla.com,hoverpad@mozilla.com");
 
 // Require signed add-ons by default
-pref("xpinstall.signatures.required", true);
+pref("xpinstall.signatures.required", false);
 pref("xpinstall.signatures.devInfoURL", "https://wiki.mozilla.org/Addons/Extension_Signing");
 
 // Dictionary download preference
 pref("browser.dictionaries.download.url", "https://addons.mozilla.org/%LOCALE%/firefox/dictionaries/");
 
 // At startup, should we check to see if the installation
 // date is older than some threshold
 pref("app.update.checkInstallTime", true);
@@ -1578,17 +1578,17 @@ pref("browser.tabs.crashReporting.email"
 pref("extensions.interposition.enabled", true);
 pref("extensions.interposition.prefetching", true);
 
 // But don't allow non-MPC extensions by default on Nightly
 #if defined(NIGHTLY_BUILD)
 pref("extensions.allow-non-mpc-extensions", false);
 #endif
 
-pref("extensions.legacy.enabled", false);
+pref("extensions.legacy.enabled", true);
 
 // How often to check for CPOW timeouts. CPOWs are only timed out by
 // the hang monitor.
 pref("dom.ipc.cpow.timeout", 500);
 
 // Causes access on unsafe CPOWs from browser code to throw by default.
 pref("dom.ipc.cpows.forbid-unsafe-from-browser", true);
 
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1518541852 -3600
#      Tue Feb 13 18:10:52 2018 +0100
# Node ID a6997db989a50a4dcc8a918d5907ee398149fc5f
# Parent  5893a1699bfbf011645ba69d5717881f16b3f330
Put back nsILocalFile

diff --git a/xpcom/io/moz.build b/xpcom/io/moz.build
--- a/xpcom/io/moz.build
+++ b/xpcom/io/moz.build
@@ -14,16 +14,17 @@ XPIDL_SOURCES += [
     'nsIConverterOutputStream.idl',
     'nsIDirectoryEnumerator.idl',
     'nsIDirectoryService.idl',
     'nsIFile.idl',
     'nsIInputStream.idl',
     'nsIInputStreamTee.idl',
     'nsIIOUtil.idl',
     'nsILineInputStream.idl',
+    'nsILocalFile.idl',
     'nsILocalFileWin.idl',
     'nsIMultiplexInputStream.idl',
     'nsIObjectInputStream.idl',
     'nsIObjectOutputStream.idl',
     'nsIOutputStream.idl',
     'nsIPipe.idl',
     'nsISafeOutputStream.idl',
     'nsIScriptableBase64Encoder.idl',
diff --git a/xpcom/io/nsILocalFile.idl b/xpcom/io/nsILocalFile.idl
new file mode 100644
--- /dev/null
+++ b/xpcom/io/nsILocalFile.idl
@@ -0,0 +1,16 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIFile.idl"
+
+/**
+ * An empty interface to provide backwards compatibility for existing code.
+ *
+ * @see nsIFile
+ */
+[scriptable, builtinclass, uuid(7ba8c6ba-2ce2-48b1-bd60-4c32aac35f9c)]
+interface nsILocalFile : nsIFile
+{
+};
diff --git a/xpcom/io/nsILocalFileMac.idl b/xpcom/io/nsILocalFileMac.idl
--- a/xpcom/io/nsILocalFileMac.idl
+++ b/xpcom/io/nsILocalFileMac.idl
@@ -1,28 +1,28 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "nsIFile.idl"
+#include "nsILocalFile.idl"
 
 %{C++
 #include <Carbon/Carbon.h>
 #include <CoreFoundation/CoreFoundation.h>
 %}
 
       native OSType(OSType);
       native FSSpec(FSSpec);
       native FSRef(FSRef);
 [ptr] native FSRefPtr(FSRef);
       native CFURLRef(CFURLRef);
 
 [scriptable, builtinclass, uuid(623eca5b-c25d-4e27-be5a-789a66c4b2f7)]
-interface nsILocalFileMac : nsIFile
+interface nsILocalFileMac : nsILocalFile
 {
    /**
     * initWithCFURL
     *
     * Init this object with a CFURLRef
     *
     * NOTE: Supported only for XP_MACOSX
     * NOTE: If the path of the CFURL is /a/b/c, at least a/b must exist beforehand.
diff --git a/xpcom/io/nsILocalFileWin.idl b/xpcom/io/nsILocalFileWin.idl
--- a/xpcom/io/nsILocalFileWin.idl
+++ b/xpcom/io/nsILocalFileWin.idl
@@ -1,24 +1,24 @@
 /* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-#include "nsIFile.idl"
+#include "nsILocalFile.idl"
 
 %{C++
 struct PRFileDesc;
 %}
 
 [ptr] native PRFileDescStar(PRFileDesc);
 
 [scriptable, builtinclass, uuid(e7a3a954-384b-4aeb-a5f7-55626b0de9be)]
-interface nsILocalFileWin : nsIFile
+interface nsILocalFileWin : nsILocalFile
 {
     /**
      *  initWithCommandLine
      *
      *  Initialize this object based on the main app path of a commandline
      *  handler.
      *
      *   @param aCommandLine
diff --git a/xpcom/io/nsLocalFileUnix.cpp b/xpcom/io/nsLocalFileUnix.cpp
--- a/xpcom/io/nsLocalFileUnix.cpp
+++ b/xpcom/io/nsLocalFileUnix.cpp
@@ -235,20 +235,22 @@ nsLocalFile::nsLocalFile(const nsACStrin
 nsLocalFile::nsLocalFile(const nsLocalFile& aOther)
   : mPath(aOther.mPath)
 {
 }
 
 #ifdef MOZ_WIDGET_COCOA
 NS_IMPL_ISUPPORTS(nsLocalFile,
                   nsILocalFileMac,
+                  nsILocalFile,
                   nsIFile,
                   nsIHashable)
 #else
 NS_IMPL_ISUPPORTS(nsLocalFile,
+                  nsILocalFile,
                   nsIFile,
                   nsIHashable)
 #endif
 
 nsresult
 nsLocalFile::nsLocalFileConstructor(nsISupports* aOuter,
                                     const nsIID& aIID,
                                     void** aInstancePtr)
diff --git a/xpcom/io/nsLocalFileUnix.h b/xpcom/io/nsLocalFileUnix.h
--- a/xpcom/io/nsLocalFileUnix.h
+++ b/xpcom/io/nsLocalFileUnix.h
@@ -18,16 +18,18 @@
 #include "nscore.h"
 #include "nsString.h"
 #include "nsReadableUtils.h"
 #include "nsIHashable.h"
 #include "nsIClassInfoImpl.h"
 #include "mozilla/Attributes.h"
 #ifdef MOZ_WIDGET_COCOA
 #include "nsILocalFileMac.h"
+#else
+#include "nsILocalFile.h"
 #endif
 
 /**
  *  we need these for statfs()
  */
 #ifdef HAVE_SYS_STATVFS_H
   #if defined(__osf__) && defined(__DECCXX)
     extern "C" int statvfs(const char *, struct statvfs *);
@@ -78,32 +80,33 @@
   #define LSTAT lstat
 #endif
 
 
 class nsLocalFile final
 #ifdef MOZ_WIDGET_COCOA
   : public nsILocalFileMac
 #else
-  : public nsIFile
+  : public nsILocalFile
 #endif
   , public nsIHashable
 {
 public:
   NS_DEFINE_STATIC_CID_ACCESSOR(NS_LOCAL_FILE_CID)
 
   nsLocalFile();
   explicit nsLocalFile(const nsACString& aFilePath);
 
   static nsresult nsLocalFileConstructor(nsISupports* aOuter,
                                          const nsIID& aIID,
                                          void** aInstancePtr);
 
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIFILE
+  NS_DECL_NSILOCALFILE
 #ifdef MOZ_WIDGET_COCOA
   NS_DECL_NSILOCALFILEMAC
 #endif
   NS_DECL_NSIHASHABLE
 
 private:
   nsLocalFile(const nsLocalFile& aOther);
   ~nsLocalFile()
diff --git a/xpcom/io/nsLocalFileWin.cpp b/xpcom/io/nsLocalFileWin.cpp
--- a/xpcom/io/nsLocalFileWin.cpp
+++ b/xpcom/io/nsLocalFileWin.cpp
@@ -826,16 +826,17 @@ nsLocalFile::nsLocalFileConstructor(nsIS
 }
 
 
 //-----------------------------------------------------------------------------
 // nsLocalFile::nsISupports
 //-----------------------------------------------------------------------------
 
 NS_IMPL_ISUPPORTS(nsLocalFile,
+                  nsILocalFile,
                   nsIFile,
                   nsILocalFileWin,
                   nsIHashable)
 
 
 //-----------------------------------------------------------------------------
 // nsLocalFile <private>
 //-----------------------------------------------------------------------------
diff --git a/xpcom/io/nsLocalFileWin.h b/xpcom/io/nsLocalFileWin.h
--- a/xpcom/io/nsLocalFileWin.h
+++ b/xpcom/io/nsLocalFileWin.h
@@ -39,16 +39,17 @@ public:
                                          const nsIID& aIID,
                                          void** aInstancePtr);
 
   // nsISupports interface
   NS_DECL_THREADSAFE_ISUPPORTS
 
   // nsIFile interface
   NS_DECL_NSIFILE
+  NS_DECL_NSILOCALFILE
 
   // nsILocalFileWin interface
   NS_DECL_NSILOCALFILEWIN
 
   // nsIHashable interface
   NS_DECL_NSIHASHABLE
 
 public:
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1517496982 -3600
#      Thu Feb 01 15:56:22 2018 +0100
# Node ID 85a5dc7746fb4b336936b89def40c560c530769e
# Parent  a6997db989a50a4dcc8a918d5907ee398149fc5f
Allow more "old" add-ons

diff --git a/browser/app/profile/firefox.js b/browser/app/profile/firefox.js
--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -1575,17 +1575,17 @@ pref("browser.tabs.crashReporting.emailM
 pref("browser.tabs.crashReporting.email", "");
 
 // Enable e10s add-on interposition by default.
 pref("extensions.interposition.enabled", true);
 pref("extensions.interposition.prefetching", true);
 
 // But don't allow non-MPC extensions by default on Nightly
 #if defined(NIGHTLY_BUILD)
-pref("extensions.allow-non-mpc-extensions", false);
+pref("extensions.allow-non-mpc-extensions", true);
 #endif
 
 pref("extensions.legacy.enabled", true);
 
 // How often to check for CPOW timeouts. CPOWs are only timed out by
 // the hang monitor.
 pref("dom.ipc.cpow.timeout", 500);
 
diff --git a/toolkit/mozapps/extensions/internal/XPIInstall.jsm b/toolkit/mozapps/extensions/internal/XPIInstall.jsm
--- a/toolkit/mozapps/extensions/internal/XPIInstall.jsm
+++ b/toolkit/mozapps/extensions/internal/XPIInstall.jsm
@@ -578,17 +578,17 @@ async function loadManifestFromRDF(aUri,
     addon.multiprocessCompatible = mpcValue == "true";
     addon.mpcOptedOut = mpcValue == "false";
 
     addon.hasEmbeddedWebExtension = getRDFProperty(ds, root, "hasEmbeddedWebExtension") == "true";
 
     if (addon.optionsType &&
         addon.optionsType != AddonManager.OPTIONS_INLINE_BROWSER &&
         addon.optionsType != AddonManager.OPTIONS_TYPE_TAB) {
-      throw new Error("Install manifest specifies unknown optionsType: " + addon.optionsType);
+      //throw new Error("Install manifest specifies unknown optionsType: " + addon.optionsType);
     }
 
     if (addon.hasEmbeddedWebExtension) {
       let uri = Services.io.newURI("webextension/manifest.json", null, aUri);
       let embeddedAddon = await loadManifestFromWebManifest(uri);
       if (embeddedAddon.optionsURL) {
         if (addon.optionsType || addon.optionsURL)
           logger.warn(`Addon ${addon.id} specifies optionsType or optionsURL ` +
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1517563916 -3600
#      Fri Feb 02 10:31:56 2018 +0100
# Node ID 8f341ec9a6914fa260fe097f36fdbe5f779b552b
# Parent  85a5dc7746fb4b336936b89def40c560c530769e
Remove "feature" bloat such as pocket

diff --git a/browser/extensions/moz.build b/browser/extensions/moz.build
--- a/browser/extensions/moz.build
+++ b/browser/extensions/moz.build
@@ -6,34 +6,26 @@
 
 DIRS += [
     'activity-stream',
     'aushelper',
     'followonsearch',
     'formautofill',
     'onboarding',
     'pdfjs',
-    'pocket',
     'screenshots',
-    'shield-recipe-client',
     'webcompat',
 ]
 
 # Only include the following system add-ons if building Aurora or Nightly
 if not CONFIG['RELEASE_OR_BETA']:
     DIRS += [
         'presentation',
     ]
 
-# Only include the following system add-ons if building DevEdition or Nightly
-if CONFIG['MOZ_DEV_EDITION'] or CONFIG['NIGHTLY_BUILD']:
-    DIRS += [
-        'webcompat-reporter',
-    ]
-
 # Only include mortar system add-ons if we locally enable it
 if CONFIG['MOZ_MORTAR']:
     DIRS += [
         'mortar',
     ]
 
 # Add ASan reporter system add-on if requested
 if CONFIG['MOZ_ASAN_REPORTER']:
diff --git a/browser/locales/Makefile.in b/browser/locales/Makefile.in
--- a/browser/locales/Makefile.in
+++ b/browser/locales/Makefile.in
@@ -70,23 +70,19 @@ libs-%:
 	$(NSINSTALL) -D $(DIST)/install
 	@$(MAKE) -C ../../toolkit/locales libs-$* XPI_ROOT_APPID='$(XPI_ROOT_APPID)'
 	@$(MAKE) -C ../../services/sync/locales AB_CD=$* XPI_NAME=locale-$*
 	@$(MAKE) -C ../../extensions/spellcheck/locales AB_CD=$* XPI_NAME=locale-$*
 ifneq (,$(wildcard ../extensions/formautofill/locales))
 	@$(MAKE) -C ../extensions/formautofill/locales AB_CD=$* XPI_NAME=locale-$*
 endif
 	@$(MAKE) -C ../extensions/onboarding/locales AB_CD=$* XPI_NAME=locale-$*
-	@$(MAKE) -C ../extensions/pocket/locale AB_CD=$* XPI_NAME=locale-$*
 ifndef RELEASE_OR_BETA
 	@$(MAKE) -C ../extensions/presentation/locale AB_CD=$* XPI_NAME=locale-$*
 endif
-ifneq '$(or $(MOZ_DEV_EDITION),$(NIGHTLY_BUILD))' ''
-	@$(MAKE) -C ../extensions/webcompat-reporter/locales AB_CD=$* XPI_NAME=locale-$*
-endif
 	@$(MAKE) -C ../../devtools/client/locales AB_CD=$* XPI_NAME=locale-$* XPI_ROOT_APPID='$(XPI_ROOT_APPID)'
 	@$(MAKE) -C ../../devtools/shim/locales AB_CD=$* XPI_NAME=locale-$* XPI_ROOT_APPID='$(XPI_ROOT_APPID)'
 	@$(MAKE) -B searchplugins AB_CD=$* XPI_NAME=locale-$*
 	@$(MAKE) libs AB_CD=$* XPI_NAME=locale-$* PREF_DIR=$(PREF_DIR)
 	@$(MAKE) multilocale.txt-$* AB_CD=$* XPI_NAME=locale-$*
 	@$(MAKE) -C $(DEPTH)/$(MOZ_BRANDING_DIRECTORY)/locales AB_CD=$* XPI_NAME=locale-$*
 
 chrome-%: AB_CD=$*
@@ -94,27 +90,23 @@ chrome-%: IS_LANGUAGE_REPACK=1
 chrome-%:
 	$(if $(filter en-US,$(AB_CD)),, @$(MAKE) merge-$*)
 	@$(MAKE) -C ../../toolkit/locales chrome-$*
 	@$(MAKE) -C ../../services/sync/locales chrome AB_CD=$*
 	@$(MAKE) -C ../../extensions/spellcheck/locales chrome AB_CD=$*
 ifneq (,$(wildcard ../extensions/formautofill/locales))
 	@$(MAKE) -C ../extensions/formautofill/locales chrome AB_CD=$*
 endif
-	@$(MAKE) -C ../extensions/pocket/locale chrome AB_CD=$*
 ifndef RELEASE_OR_BETA
 	@$(MAKE) -C ../extensions/presentation/locale chrome AB_CD=$*
 endif
 	@$(MAKE) -C ../../devtools/client/locales chrome AB_CD=$*
 	@$(MAKE) -C ../../devtools/shim/locales chrome AB_CD=$*
 	@$(MAKE) chrome AB_CD=$*
 	@$(MAKE) -C $(DEPTH)/$(MOZ_BRANDING_DIRECTORY)/locales chrome AB_CD=$*
-ifdef NIGHTLY_BUILD
-	@$(MAKE) -C ../extensions/webcompat-reporter/locales chrome AB_CD=$*
-endif
 
 package-win32-installer: WIN32_INSTALLER_OUT=$(ABS_DIST)/$(PKG_INST_PATH)$(PKG_INST_BASENAME).exe
 package-win32-installer: $(SUBMAKEFILES)
 	@echo 'Packaging $(WIN32_INSTALLER_OUT).'
 	$(MAKE) -C ../installer/windows CONFIG_DIR=l10ngen l10ngen/setup.exe l10ngen/7zSD.sfx
 	$(RM) -r $(STAGEDIST)/uninstall
 	$(NSINSTALL) -D $(STAGEDIST)/uninstall
 	cp ../installer/windows/l10ngen/helper.exe $(STAGEDIST)/uninstall
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1518019820 -3600
#      Wed Feb 07 17:10:20 2018 +0100
# Node ID 7c2dbcd10da5c1148438887697fa593d1d954132
# Parent  8f341ec9a6914fa260fe097f36fdbe5f779b552b
Fix menu toolbar button styles

diff --git a/browser/themes/shared/toolbarbuttons.inc.css b/browser/themes/shared/toolbarbuttons.inc.css
--- a/browser/themes/shared/toolbarbuttons.inc.css
+++ b/browser/themes/shared/toolbarbuttons.inc.css
@@ -110,23 +110,27 @@ toolbar .toolbarbutton-1 {
 
 toolbar .toolbarbutton-1 > menupopup {
   margin-top: -3px;
 }
 
 .findbar-button > .toolbarbutton-text,
 toolbarbutton.bookmark-item:not(.subviewbutton),
 toolbar .toolbarbutton-1 > .toolbarbutton-icon,
+toolbar .toolbarbutton-1[type="menu"] > toolbarbutton > .toolbarbutton-icon,
+toolbar .toolbarbutton-1[type="menu-button"] > toolbarbutton > .toolbarbutton-icon,
 toolbar .toolbarbutton-1 > .toolbarbutton-text,
 toolbar .toolbarbutton-1 > .toolbarbutton-badge-stack {
   padding: var(--toolbarbutton-inner-padding);
   border-radius: var(--toolbarbutton-border-radius);
 }
 
-toolbar .toolbarbutton-1 > .toolbarbutton-icon {
+toolbar .toolbarbutton-1 .toolbarbutton-icon,
+toolbar .toolbarbutton-1[type="menu"] > toolbarbutton > .toolbarbutton-icon,
+toolbar .toolbarbutton-1[type="menu-button"] > toolbarbutton > .toolbarbutton-icon {
   /* horizontal padding + actual icon width */
   width: calc(2 * var(--toolbarbutton-inner-padding) + 16px);
   height: calc(2 * var(--toolbarbutton-inner-padding) + 16px);
 }
 
 .bookmark-item > .toolbarbutton-menu-dropmarker,
 toolbar .toolbarbutton-1 > .toolbarbutton-menu-dropmarker {
   display: none;
@@ -170,27 +174,44 @@ toolbar[brighttext] .toolbaritem-combine
 }
 
 #PersonalToolbar .toolbarbutton-1:not([disabled=true]):not([checked]):not([open]):not(:active):hover,
 .tabbrowser-arrowscrollbox > .scrollbutton-up:not([disabled=true]):hover,
 .tabbrowser-arrowscrollbox > .scrollbutton-down:not([disabled=true]):hover,
 .findbar-button:not(:-moz-any([checked="true"],[disabled="true"])):hover > .toolbarbutton-text,
 toolbarbutton.bookmark-item:not(.subviewbutton):hover:not([disabled="true"]):not([open]),
 toolbar .toolbarbutton-1:not([disabled=true]):not([checked]):not([open]):not(:active):hover > .toolbarbutton-icon,
+toolbar .toolbarbutton-1:-moz-any([type="menu"],[type="menu-button"]):not([disabled=true]):not([checked]):not([open]):not(:active):hover .toolbarbutton-icon,
 toolbar .toolbarbutton-1:not([disabled=true]):not([checked]):not([open]):not(:active):hover > .toolbarbutton-text,
 toolbar .toolbarbutton-1:not([disabled=true]):not([checked]):not([open]):not(:active):hover > .toolbarbutton-badge-stack {
   background-color: var(--toolbarbutton-hover-background);
   color: inherit;
 }
 
+toolbar .toolbarbutton-1:-moz-any([type="menu"],[type="menu-button"]) toolbarbutton {
+  -moz-appearance: none !important;
+  margin: 0px;
+  padding-right: 0;
+}
+toolbar .toolbarbutton-1:-moz-any([type="menu"],[type="menu-button"]) .toolbarbutton-icon {
+  margin-right: 2px;
+}
+
+toolbar .toolbarbutton-1:-moz-any([type="menu"],[type="menu-button"]) .toolbarbutton-menubutton-dropmarker {
+  margin-left: 0;
+  padding-left: 0;
+}
+
 #PersonalToolbar .toolbarbutton-1:not([disabled=true]):-moz-any([open],[checked],:hover:active),
 .findbar-button:not([disabled=true]):-moz-any([checked="true"],:hover:active) > .toolbarbutton-text,
 toolbarbutton.bookmark-item:not(.subviewbutton):hover:active:not([disabled="true"]),
 toolbarbutton.bookmark-item[open="true"],
 toolbar .toolbarbutton-1:not([disabled=true]):-moz-any([open],[checked],:hover:active) > .toolbarbutton-icon,
+toolbar .toolbarbutton-1[type="menu"]:not([disabled=true]):-moz-any([open],[checked],:hover:active) .toolbarbutton-icon,
+toolbar .toolbarbutton-1[type="menu-button"]:not([disabled=true]):-moz-any([open],[checked],:hover:active) .toolbarbutton-icon,
 toolbar .toolbarbutton-1:not([disabled=true]):-moz-any([open],[checked],:hover:active) > .toolbarbutton-text,
 toolbar .toolbarbutton-1:not([disabled=true]):-moz-any([open],[checked],:hover:active) > .toolbarbutton-badge-stack {
   background-color: var(--toolbarbutton-active-background);
   color: inherit;
 }
 
 toolbar .toolbarbutton-1[checked]:not(:active):hover > .toolbarbutton-icon {
   background-color: var(--toolbarbutton-hover-background);
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1518541936 -3600
#      Tue Feb 13 18:12:16 2018 +0100
# Node ID f73909dd4db994f0fb56100ea828b926014d257f
# Parent  7c2dbcd10da5c1148438887697fa593d1d954132
Be less anal about unsigned stuff

diff --git a/toolkit/mozapps/extensions/internal/XPIProvider.jsm b/toolkit/mozapps/extensions/internal/XPIProvider.jsm
--- a/toolkit/mozapps/extensions/internal/XPIProvider.jsm
+++ b/toolkit/mozapps/extensions/internal/XPIProvider.jsm
@@ -4913,17 +4913,17 @@ AddonInternal.prototype = {
         // installed there do not require signing.
         if (Services.appinfo.OS != "Darwin")
           return true;
         break;
     }
 
     if (this.signedState === AddonManager.SIGNEDSTATE_NOT_REQUIRED)
       return true;
-    return this.signedState > AddonManager.SIGNEDSTATE_MISSING;
+    return this.signedState >= AddonManager.SIGNEDSTATE_MISSING;
   },
 
   get isCompatible() {
     return this.isCompatibleWith();
   },
 
   get disabled() {
     return (this.userDisabled || this.appDisabled || this.softDisabled);
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1518696473 -3600
#      Thu Feb 15 13:07:53 2018 +0100
# Node ID 37a5c1bbe4f0895ea68a917e427dd2bca3604943
# Parent  f73909dd4db994f0fb56100ea828b926014d257f
Setup icon

diff --git a/other-licenses/7zstub/firefox/7zSD.sfx b/other-licenses/7zstub/firefox/7zSD.sfx
index e5b07e59ff488491a75f664676153f776bfad5c8..a73a34f19f18dd1c9b7ecfda4697fa5e7cde8e57
GIT binary patch
literal 529920
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
B70Cbq

diff --git a/other-licenses/7zstub/firefox/setup.ico b/other-licenses/7zstub/firefox/setup.ico
index 794f23d5c06c37d64ac0d2f8909a7b17adcb8289..87d57a395863ec689bbb560487719a8813b5deb1
GIT binary patch
literal 408142
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

# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1519565168 -3600
#      Sun Feb 25 14:26:08 2018 +0100
# Node ID 2f435ce419c868d69b1b1a011e030c72f1bc2981
# Parent  37a5c1bbe4f0895ea68a917e427dd2bca3604943
Readd nsIXMLHttpRequest (partial)

diff --git a/browser/installer/package-manifest.in b/browser/installer/package-manifest.in
--- a/browser/installer/package-manifest.in
+++ b/browser/installer/package-manifest.in
@@ -216,16 +216,17 @@
 @RESPATH@/components/dom_range.xpt
 @RESPATH@/components/dom_security.xpt
 @RESPATH@/components/dom_sidebar.xpt
 @RESPATH@/components/dom_storage.xpt
 #ifdef MOZ_WEBSPEECH
 @RESPATH@/components/dom_webspeechrecognition.xpt
 #endif
 @RESPATH@/components/dom_workers.xpt
+@RESPATH@/components/dom_xhr.xpt
 @RESPATH@/components/dom_xul.xpt
 @RESPATH@/components/dom_presentation.xpt
 @RESPATH@/components/downloads.xpt
 @RESPATH@/components/editor.xpt
 @RESPATH@/components/enterprisepolicies.xpt
 @RESPATH@/components/extensions.xpt
 @RESPATH@/components/exthandler.xpt
 @RESPATH@/components/fastfind.xpt
diff --git a/dom/base/FormData.h b/dom/base/FormData.h
--- a/dom/base/FormData.h
+++ b/dom/base/FormData.h
@@ -8,16 +8,17 @@
 #define mozilla_dom_FormData_h
 
 #include "mozilla/Attributes.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/dom/BindingDeclarations.h"
 #include "mozilla/dom/HTMLFormSubmission.h"
 #include "mozilla/dom/File.h"
 #include "mozilla/dom/FormDataBinding.h"
+#include "nsIXMLHttpRequest.h"
 #include "nsTArray.h"
 #include "nsWrapperCache.h"
 
 namespace mozilla {
 namespace dom {
 
 class HTMLFormElement;
 class GlobalObject;
diff --git a/dom/fetch/BodyExtractor.cpp b/dom/fetch/BodyExtractor.cpp
--- a/dom/fetch/BodyExtractor.cpp
+++ b/dom/fetch/BodyExtractor.cpp
@@ -163,16 +163,26 @@ BodyExtractor<nsIInputStream>::GetAsStre
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIInputStream> stream(mBody);
   stream.forget(aResult);
   return NS_OK;
 }
 
 template<> nsresult
+BodyExtractor<nsIXHRSendable>::GetAsStream(nsIInputStream** aResult,
+                                           uint64_t* aContentLength,
+                                           nsACString& aContentTypeWithCharset,
+                                           nsACString& aCharset) const
+{
+  return mBody->GetSendInfo(aResult, aContentLength, aContentTypeWithCharset,
+                            aCharset);
+}
+
+template<> nsresult
 BodyExtractor<const Blob>::GetAsStream(nsIInputStream** aResult,
                                        uint64_t* aContentLength,
                                        nsACString& aContentTypeWithCharset,
                                        nsACString& aCharset) const
 {
   return mBody->GetSendInfo(aResult, aContentLength, aContentTypeWithCharset,
                             aCharset);
 }
diff --git a/dom/file/Blob.h b/dom/file/Blob.h
--- a/dom/file/Blob.h
+++ b/dom/file/Blob.h
@@ -10,16 +10,17 @@
 #include "mozilla/Attributes.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/dom/BindingDeclarations.h"
 #include "mozilla/dom/BlobImpl.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsCOMPtr.h"
 #include "nsIDOMBlob.h"
 #include "nsIMutable.h"
+#include "nsIXMLHttpRequest.h"
 #include "nsWrapperCache.h"
 #include "nsWeakReference.h"
 
 class nsIInputStream;
 
 namespace mozilla {
 namespace dom {
 
diff --git a/dom/xhr/XMLHttpRequest.h b/dom/xhr/XMLHttpRequest.h
--- a/dom/xhr/XMLHttpRequest.h
+++ b/dom/xhr/XMLHttpRequest.h
@@ -5,16 +5,17 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_XMLHttpRequest_h
 #define mozilla_dom_XMLHttpRequest_h
 
 #include "mozilla/Attributes.h"
 #include "mozilla/dom/XMLHttpRequestEventTarget.h"
 #include "mozilla/dom/XMLHttpRequestBinding.h"
+#include "nsIXMLHttpRequest.h"
 
 class nsIJSID;
 
 namespace mozilla {
 namespace dom {
 
 class Blob;
 class DOMString;
diff --git a/dom/xhr/XMLHttpRequestMainThread.cpp b/dom/xhr/XMLHttpRequestMainThread.cpp
--- a/dom/xhr/XMLHttpRequestMainThread.cpp
+++ b/dom/xhr/XMLHttpRequestMainThread.cpp
@@ -244,16 +244,36 @@ XMLHttpRequestMainThread::~XMLHttpReques
   mFlagSyncLooping = false;
 
   mResultJSON.setUndefined();
   mResultArrayBuffer = nullptr;
   mozilla::DropJSObjects(this);
 }
 
 /**
+ * This Init method is called from the factory constructor.
+ */
+nsresult
+XMLHttpRequestMainThread::Init()
+{
+  nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
+  nsCOMPtr<nsIPrincipal> subjectPrincipal;
+  if (secMan) {
+    secMan->GetSystemPrincipal(getter_AddRefs(subjectPrincipal));
+  }
+  NS_ENSURE_STATE(subjectPrincipal);
+
+  // Instead of grabbing some random global from the context stack,
+  // let's use the default one (junk scope) for now.
+  // We should move away from this Init...
+  Construct(subjectPrincipal, xpc::NativeGlobal(xpc::PrivilegedJunkScope()));
+  return NS_OK;
+}
+
+/**
  * This Init method should only be called by C++ consumers.
  */
 nsresult
 XMLHttpRequestMainThread::Init(nsIPrincipal* aPrincipal,
                                nsIGlobalObject* aGlobalObject,
                                nsIURI* aBaseURI,
                                nsILoadGroup* aLoadGroup)
 {
@@ -381,16 +401,17 @@ NS_IMPL_CYCLE_COLLECTION_TRACE_END
 bool
 XMLHttpRequestMainThread::IsCertainlyAliveForCC() const
 {
   return mWaitingForOnStopRequest;
 }
 
 // QueryInterface implementation for XMLHttpRequestMainThread
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XMLHttpRequestMainThread)
+  NS_INTERFACE_MAP_ENTRY(nsIXMLHttpRequest)
   NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
   NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
   NS_INTERFACE_MAP_ENTRY(nsIChannelEventSink)
   NS_INTERFACE_MAP_ENTRY(nsIProgressEventSink)
   NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
   NS_INTERFACE_MAP_ENTRY(nsITimerCallback)
   NS_INTERFACE_MAP_ENTRY(nsINamed)
   NS_INTERFACE_MAP_ENTRY(nsISizeOfEventTarget)
@@ -428,29 +449,55 @@ XMLHttpRequestMainThread::SizeOfEventTar
 
   return n;
 
   // Measurement of the following members may be added later if DMD finds it is
   // worthwhile:
   // - lots
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetChannel(nsIChannel **aChannel)
+{
+  NS_ENSURE_ARG_POINTER(aChannel);
+  NS_IF_ADDREF(*aChannel = mChannel);
+
+  return NS_OK;
+}
+
 static void LogMessage(const char* aWarning, nsPIDOMWindowInner* aWindow,
                        const char16_t** aParams=nullptr, uint32_t aParamCount=0)
 {
   nsCOMPtr<nsIDocument> doc;
   if (aWindow) {
     doc = aWindow->GetExtantDoc();
   }
   nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
                                   NS_LITERAL_CSTRING("DOM"), doc,
                                   nsContentUtils::eDOM_PROPERTIES,
                                   aWarning, aParams, aParamCount);
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetResponseXML(nsIDOMDocument **aResponseXML)
+{
+  ErrorResult rv;
+  nsIDocument* responseXML = GetResponseXML(rv);
+  if (rv.Failed()) {
+    return rv.StealNSResult();
+  }
+
+  if (!responseXML) {
+    *aResponseXML = nullptr;
+    return NS_OK;
+  }
+
+  return CallQueryInterface(responseXML, aResponseXML);
+}
+
 nsIDocument*
 XMLHttpRequestMainThread::GetResponseXML(ErrorResult& aRv)
 {
   if (mResponseType != XMLHttpRequestResponseType::_empty &&
       mResponseType != XMLHttpRequestResponseType::Document) {
     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSEXML);
     return nullptr;
   }
@@ -539,16 +586,30 @@ XMLHttpRequestMainThread::AppendToRespon
   MOZ_ASSERT(result == kInputEmpty);
   MOZ_ASSERT(read == aSrcBufferLen);
   MOZ_ASSERT(written <= destBufferLen.value());
   Unused << hadErrors;
   helper.AddLength(written);
   return NS_OK;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetResponseText(nsAString& aResponseText)
+{
+  ErrorResult rv;
+  DOMString str;
+  GetResponseText(str, rv);
+  if (NS_WARN_IF(rv.Failed())) {
+    return rv.StealNSResult();
+  }
+
+  str.ToString(aResponseText);
+  return NS_OK;
+}
+
 void
 XMLHttpRequestMainThread::GetResponseText(DOMString& aResponseText,
                                           ErrorResult& aRv)
 {
   XMLHttpRequestStringSnapshot snapshot;
   GetResponseText(snapshot, aRv);
   if (aRv.Failed()) {
     return;
@@ -630,16 +691,40 @@ XMLHttpRequestMainThread::CreateResponse
   if (!JS_ParseJSON(aCx, string.BeginReading(), string.Length(), &value)) {
     return NS_ERROR_FAILURE;
   }
 
   mResultJSON = value;
   return NS_OK;
 }
 
+NS_IMETHODIMP XMLHttpRequestMainThread::GetResponseType(nsAString& aResponseType)
+{
+  MOZ_ASSERT(mResponseType < XMLHttpRequestResponseType::EndGuard_);
+  const EnumEntry& entry =
+    XMLHttpRequestResponseTypeValues::strings[static_cast<uint32_t>(mResponseType)];
+  aResponseType.AssignASCII(entry.value, entry.length);
+  return NS_OK;
+}
+
+NS_IMETHODIMP XMLHttpRequestMainThread::SetResponseType(const nsAString& aResponseType)
+{
+  uint32_t i = 0;
+  for (const EnumEntry* entry = XMLHttpRequestResponseTypeValues::strings;
+       entry->value; ++entry, ++i) {
+    if (aResponseType.EqualsASCII(entry->value, entry->length)) {
+      ErrorResult rv;
+      SetResponseType(static_cast<XMLHttpRequestResponseType>(i), rv);
+      return rv.StealNSResult();
+    }
+  }
+
+  return NS_OK;
+}
+
 void
 XMLHttpRequestMainThread::SetResponseType(XMLHttpRequestResponseType aResponseType,
                                           ErrorResult& aRv)
 {
   NOT_CALLABLE_IN_SYNC_SEND_RV
 
   if (mState == XMLHttpRequestBinding::LOADING ||
       mState == XMLHttpRequestBinding::DONE) {
@@ -665,16 +750,24 @@ XMLHttpRequestMainThread::SetResponseTyp
   if (aResponseType == XMLHttpRequestResponseType::Moz_chunked_arraybuffer) {
     Telemetry::Accumulate(Telemetry::MOZ_CHUNKED_ARRAYBUFFER_IN_XHR, 1);
   }
 
   // Set the responseType attribute's value to the given value.
   mResponseType = aResponseType;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetResponse(JSContext *aCx, JS::MutableHandle<JS::Value> aResult)
+{
+  ErrorResult rv;
+  GetResponse(aCx, aResult, rv);
+  return rv.StealNSResult();
+}
+
 void
 XMLHttpRequestMainThread::GetResponse(JSContext* aCx,
                                       JS::MutableHandle<JS::Value> aResponse,
                                       ErrorResult& aRv)
 {
   switch (mResponseType) {
   case XMLHttpRequestResponseType::_empty:
   case XMLHttpRequestResponseType::Text:
@@ -818,16 +911,24 @@ XMLHttpRequestMainThread::GetResponseURL
     return;
   }
 
   nsAutoCString temp;
   responseUrl->GetSpecIgnoringRef(temp);
   CopyUTF8toUTF16(temp, aUrl);
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetStatus(uint32_t *aStatus)
+{
+  ErrorResult rv;
+  *aStatus = GetStatus(rv);
+  return rv.StealNSResult();
+}
+
 uint32_t
 XMLHttpRequestMainThread::GetStatus(ErrorResult& aRv)
 {
   // Make sure we don't leak status information from denied cross-site
   // requests.
   if (IsDeniedCrossSiteCORSRequest()) {
     return 0;
   }
@@ -864,16 +965,24 @@ XMLHttpRequestMainThread::GetStatus(Erro
   nsresult rv = httpChannel->GetResponseStatus(&status);
   if (NS_FAILED(rv)) {
     status = 0;
   }
 
   return status;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetStatusText(nsACString& aOut)
+{
+  ErrorResult rv;
+  GetStatusText(aOut, rv);
+  return rv.StealNSResult();
+}
+
 void
 XMLHttpRequestMainThread::GetStatusText(nsACString& aStatusText,
                                         ErrorResult& aRv)
 {
   // Return an empty status text on all error loads.
   aStatusText.Truncate();
 
   // Make sure we don't leak status information from denied cross-site
@@ -1036,16 +1145,23 @@ XMLHttpRequestMainThread::AbortInternal(
   // Step 3
   if (mState == XMLHttpRequestBinding::DONE) {
     ChangeState(XMLHttpRequestBinding::UNSENT, false); // no ReadystateChange event
   }
 
   mFlagSyncLooping = false;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::SlowAbort()
+{
+  Abort();
+  return NS_OK;
+}
+
 /*Method that checks if it is safe to expose a header value to the client.
 It is used to check what headers are exposed for CORS requests.*/
 bool
 XMLHttpRequestMainThread::IsSafeHeader(const nsACString& aHeader,
                                        NotNull<nsIHttpChannel*> aHttpChannel) const
 {
   // See bug #380418. Hide "Set-Cookie" headers from non-chrome scripts.
   if (!IsSystemXHR() && nsContentUtils::IsForbiddenResponseHeader(aHeader)) {
@@ -1093,16 +1209,24 @@ XMLHttpRequestMainThread::IsSafeHeader(c
     }
     if (aHeader.Equals(token, nsCaseInsensitiveCStringComparator())) {
       isSafe = true;
     }
   }
   return isSafe;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetAllResponseHeaders(nsACString& aOut)
+{
+  ErrorResult rv;
+  GetAllResponseHeaders(aOut, rv);
+  return rv.StealNSResult();
+}
+
 void
 XMLHttpRequestMainThread::GetAllResponseHeaders(nsACString& aResponseHeaders,
                                                 ErrorResult& aRv)
 {
   NOT_CALLABLE_IN_SYNC_SEND_RV
 
   aResponseHeaders.Truncate();
 
@@ -1152,16 +1276,25 @@ XMLHttpRequestMainThread::GetAllResponse
     if (NS_SUCCEEDED(mChannel->GetContentLength(&length))) {
       aResponseHeaders.AppendLiteral("Content-Length: ");
       aResponseHeaders.AppendInt(length);
       aResponseHeaders.AppendLiteral("\r\n");
     }
   }
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetResponseHeader(const nsACString& aHeader,
+                                            nsACString& aResult)
+{
+  ErrorResult rv;
+  GetResponseHeader(aHeader, aResult, rv);
+  return rv.StealNSResult();
+}
+
 void
 XMLHttpRequestMainThread::GetResponseHeader(const nsACString& header,
                                             nsACString& _retval, ErrorResult& aRv)
 {
   NOT_CALLABLE_IN_SYNC_SEND_RV
 
   _retval.SetIsVoid(true);
 
@@ -1380,16 +1513,25 @@ XMLHttpRequestMainThread::IsSystemXHR() 
 
 bool
 XMLHttpRequestMainThread::InUploadPhase() const
 {
   // We're in the upload phase while our state is OPENED.
   return mState == XMLHttpRequestBinding::OPENED;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::Open(const nsACString& aMethod, const nsACString& aUrl,
+                               bool aAsync, const nsAString& aUsername,
+                               const nsAString& aPassword, uint8_t optional_argc)
+{
+  return Open(aMethod, aUrl, optional_argc > 0 ? aAsync : true,
+              aUsername, aPassword);
+}
+
 // This case is hit when the async parameter is outright omitted, which
 // should set it to true (and the username and password to null).
 void
 XMLHttpRequestMainThread::Open(const nsACString& aMethod, const nsAString& aUrl,
                                ErrorResult& aRv)
 {
   Open(aMethod, aUrl, true, VoidString(), VoidString(), aRv);
 }
@@ -2672,16 +2814,96 @@ XMLHttpRequestMainThread::InitiateFetch(
       mState = XMLHttpRequestBinding::DONE;
       return NS_ERROR_DOM_NETWORK_ERR;
     }
   }
 
   return NS_OK;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::Send(nsIVariant* aVariant)
+{
+  if (!aVariant) {
+    return SendInternal(nullptr);
+  }
+
+  uint16_t dataType;
+  nsresult rv = aVariant->GetDataType(&dataType);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (dataType == nsIDataType::VTYPE_INTERFACE ||
+      dataType == nsIDataType::VTYPE_INTERFACE_IS) {
+    nsCOMPtr<nsISupports> supports;
+    nsID *iid;
+    rv = aVariant->GetAsInterface(&iid, getter_AddRefs(supports));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    free(iid);
+
+    // document?
+    nsCOMPtr<nsIDocument> doc = do_QueryInterface(supports);
+    if (doc) {
+      BodyExtractor<nsIDocument> body(doc);
+      return SendInternal(&body);
+    }
+
+    // nsISupportsString?
+    nsCOMPtr<nsISupportsString> wstr = do_QueryInterface(supports);
+    if (wstr) {
+      nsAutoString string;
+      wstr->GetData(string);
+      BodyExtractor<const nsAString> body(&string);
+      return SendInternal(&body);
+    }
+
+    // nsIInputStream?
+    nsCOMPtr<nsIInputStream> stream = do_QueryInterface(supports);
+    if (stream) {
+      BodyExtractor<nsIInputStream> body(stream);
+      return SendInternal(&body);
+    }
+
+    // nsIXHRSendable?
+    nsCOMPtr<nsIXHRSendable> sendable = do_QueryInterface(supports);
+    if (sendable) {
+      BodyExtractor<nsIXHRSendable> body(sendable);
+      return SendInternal(&body);
+    }
+
+    // ArrayBuffer?
+    JS::RootingContext* rootingCx = RootingCx();
+    JS::Rooted<JS::Value> realVal(rootingCx);
+
+    nsresult rv = aVariant->GetAsJSVal(&realVal);
+    if (NS_SUCCEEDED(rv) && !realVal.isPrimitive()) {
+      JS::Rooted<JSObject*> obj(rootingCx, realVal.toObjectOrNull());
+      RootedSpiderMonkeyInterface<ArrayBuffer> buf(rootingCx);
+      if (buf.Init(obj)) {
+        BodyExtractor<const ArrayBuffer> body(&buf);
+        return SendInternal(&body);
+      }
+    }
+  } else if (dataType == nsIDataType::VTYPE_VOID ||
+           dataType == nsIDataType::VTYPE_EMPTY) {
+    return SendInternal(nullptr);
+  }
+
+  char16_t* data = nullptr;
+  uint32_t len = 0;
+  rv = aVariant->GetAsWStringWithSize(&len, &data);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsString string;
+  string.Adopt(data, len);
+
+  BodyExtractor<const nsAString> body(&string);
+  return SendInternal(&body);
+}
+
 void
 XMLHttpRequestMainThread::UnsuppressEventHandlingAndResume()
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(mFlagSynchronous);
 
   if (mSuspendedDoc) {
     mSuspendedDoc->UnsuppressEventHandlingAndFireEvents(true);
@@ -2986,16 +3208,25 @@ XMLHttpRequestMainThread::IsLowercaseRes
                                  "dom.xhr.lowercase_header.enabled",
                                  false);
     sLowercaseResponseHeaderAdded = true;
   }
 
   return sIsLowercaseResponseHeaderEnabled;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::SetRequestHeader(const nsACString& aName,
+                                           const nsACString& aValue)
+{
+  ErrorResult aRv;
+  SetRequestHeader(aName, aValue, aRv);
+  return aRv.StealNSResult();
+}
+  
 // http://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html#dom-xmlhttprequest-setrequestheader
 void
 XMLHttpRequestMainThread::SetRequestHeader(const nsACString& aName,
                                            const nsACString& aValue,
                                            ErrorResult& aRv)
 {
   NOT_CALLABLE_IN_SYNC_SEND_RV
 
@@ -3040,16 +3271,31 @@ XMLHttpRequestMainThread::SetRequestHead
   //                 callers, but will not merge.
   if (isPrivilegedCaller && isForbiddenHeader) {
     mAuthorRequestHeaders.Set(aName, value);
   } else {
     mAuthorRequestHeaders.MergeOrSet(aName, value);
   }
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetTimeout(uint32_t *aTimeout)
+{
+  *aTimeout = Timeout();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+XMLHttpRequestMainThread::SetTimeout(uint32_t aTimeout)
+{
+  ErrorResult rv;
+  SetTimeout(aTimeout, rv);
+  return rv.StealNSResult();
+}
+
 void
 XMLHttpRequestMainThread::SetTimeout(uint32_t aTimeout, ErrorResult& aRv)
 {
   NOT_CALLABLE_IN_SYNC_SEND_RV
 
   if (mFlagSynchronous &&
       mState != XMLHttpRequestBinding::UNSENT && HasOrHasHadOwner()) {
     /* Timeout is not supported for synchronous requests with an owning window,
@@ -3113,16 +3359,23 @@ XMLHttpRequestMainThread::StartTimeoutTi
     (uint32_t)((PR_Now() - mRequestSentTime) / PR_USEC_PER_MSEC);
   mTimeoutTimer->InitWithCallback(
     this,
     mTimeoutMilliseconds > elapsed ? mTimeoutMilliseconds - elapsed : 0,
     nsITimer::TYPE_ONE_SHOT
   );
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetReadyState(uint16_t *aState)
+{
+  *aState = ReadyState();
+  return NS_OK;
+}
+
 uint16_t
 XMLHttpRequestMainThread::ReadyState() const
 {
   return mState;
 }
 
 void
 XMLHttpRequestMainThread::OverrideMimeType(const nsAString& aMimeType,
@@ -3135,16 +3388,31 @@ XMLHttpRequestMainThread::OverrideMimeTy
     ResetResponse();
     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_LOADING_OR_DONE);
     return;
   }
 
   mOverrideMimeType = aMimeType;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::SlowOverrideMimeType(const nsAString& aMimeType)
+{
+  ErrorResult aRv;
+  OverrideMimeType(aMimeType, aRv);
+  return aRv.StealNSResult();
+}
+
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetMozBackgroundRequest(bool *_retval)
+{
+  *_retval = MozBackgroundRequest();
+  return NS_OK;
+}
+
 bool
 XMLHttpRequestMainThread::MozBackgroundRequest() const
 {
   return mFlagBackgroundRequest;
 }
 
 nsresult
 XMLHttpRequestMainThread::SetMozBackgroundRequest(bool aMozBackgroundRequest)
@@ -3166,22 +3434,37 @@ XMLHttpRequestMainThread::SetMozBackgrou
 void
 XMLHttpRequestMainThread::SetMozBackgroundRequest(bool aMozBackgroundRequest,
                                                   ErrorResult& aRv)
 {
   // No errors for this webIDL method on main-thread.
   SetMozBackgroundRequest(aMozBackgroundRequest);
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetWithCredentials(bool *_retval)
+{
+  *_retval = WithCredentials();
+  return NS_OK;
+}
+
 bool
 XMLHttpRequestMainThread::WithCredentials() const
 {
   return mFlagACwithCredentials;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::SetWithCredentials(bool aWithCredentials)
+{
+  ErrorResult rv;
+  SetWithCredentials(aWithCredentials, rv);
+  return rv.StealNSResult();
+}
+
 void
 XMLHttpRequestMainThread::SetWithCredentials(bool aWithCredentials, ErrorResult& aRv)
 {
   NOT_CALLABLE_IN_SYNC_SEND_RV
 
   // Return error if we're already processing a request.  Note that we can't use
   // ReadyState() here, because it can't differentiate between "opened" and
   // "sent", so we use mState directly.
@@ -3423,28 +3706,51 @@ XMLHttpRequestUpload*
 XMLHttpRequestMainThread::GetUpload(ErrorResult& aRv)
 {
   if (!mUpload) {
     mUpload = new XMLHttpRequestUpload(this);
   }
   return mUpload;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetUpload(nsIXMLHttpRequestUpload** aUpload)
+{
+  ErrorResult rv;
+  RefPtr<XMLHttpRequestUpload> upload = GetUpload(rv);
+  upload.forget(aUpload);
+  return rv.StealNSResult();
+}
+
 bool
 XMLHttpRequestMainThread::MozAnon() const
 {
   return mIsAnon;
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetMozAnon(bool* aAnon)
+{
+  *aAnon = MozAnon();
+  return NS_OK;
+}
+
 bool
 XMLHttpRequestMainThread::MozSystem() const
 {
   return IsSystemXHR();
 }
 
+NS_IMETHODIMP
+XMLHttpRequestMainThread::GetMozSystem(bool* aSystem)
+{
+  *aSystem = MozSystem();
+  return NS_OK;
+}
+
 void
 XMLHttpRequestMainThread::HandleTimeoutCallback()
 {
   if (mState == XMLHttpRequestBinding::DONE) {
     NS_NOTREACHED("XMLHttpRequestMainThread::HandleTimeoutCallback with completed request");
     // do nothing!
     return;
   }
diff --git a/dom/xhr/XMLHttpRequestMainThread.h b/dom/xhr/XMLHttpRequestMainThread.h
--- a/dom/xhr/XMLHttpRequestMainThread.h
+++ b/dom/xhr/XMLHttpRequestMainThread.h
@@ -4,16 +4,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_XMLHttpRequestMainThread_h
 #define mozilla_dom_XMLHttpRequestMainThread_h
 
 #include <bitset>
 #include "nsAutoPtr.h"
+#include "nsIXMLHttpRequest.h"
 #include "nsISupportsUtils.h"
 #include "nsIURI.h"
 #include "nsIHttpChannel.h"
 #include "nsIDocument.h"
 #include "nsIStreamListener.h"
 #include "nsIChannelEventSink.h"
 #include "nsIAsyncVerifyRedirectCallback.h"
 #include "nsIInterfaceRequestor.h"
@@ -156,16 +157,17 @@ public:
   void GetCORSUnsafeHeaders(nsTArray<nsCString>& aArray) const;
 };
 
 class nsXHRParseEndListener;
 
 // Make sure that any non-DOM interfaces added here are also added to
 // nsXMLHttpRequestXPCOMifier.
 class XMLHttpRequestMainThread final : public XMLHttpRequest,
+                                       public nsIXMLHttpRequest,
                                        public nsIStreamListener,
                                        public nsIChannelEventSink,
                                        public nsIProgressEventSink,
                                        public nsIInterfaceRequestor,
                                        public nsITimerCallback,
                                        public nsISizeOfEventTarget,
                                        public nsINamed,
                                        public MutableBlobStorageCallback
@@ -219,16 +221,19 @@ public:
     mIsSystem = aSystem;
   }
 
   void SetClientInfoAndController(const ClientInfo& aClientInfo,
                                   const Maybe<ServiceWorkerDescriptor>& aController);
 
   NS_DECL_ISUPPORTS_INHERITED
 
+  // nsIXMLHttpRequest
+  NS_DECL_NSIXMLHTTPREQUEST
+
   // nsIStreamListener
   NS_DECL_NSISTREAMLISTENER
 
   // nsIRequestObserver
   NS_DECL_NSIREQUESTOBSERVER
 
   // nsIChannelEventSink
   NS_DECL_NSICHANNELEVENTSINK
@@ -271,18 +276,19 @@ public:
 
   nsresult
   Open(const nsACString& aMethod,
        const nsACString& aUrl,
        bool aAsync,
        const nsAString& aUsername,
        const nsAString& aPassword);
 
-  virtual void
-  SetRequestHeader(const nsACString& aName, const nsACString& aValue,
+  void
+  SetRequestHeader(const nsACString& aName,
+                   const nsACString& aValue,
                    ErrorResult& aRv) override;
 
   virtual uint32_t
   Timeout() const override
   {
     return mTimeoutMilliseconds;
   }
 
@@ -413,19 +419,16 @@ public:
                   ErrorResult& aRv);
 
   virtual nsIDocument*
   GetResponseXML(ErrorResult& aRv) override;
 
   virtual bool
   MozBackgroundRequest() const override;
 
-  nsresult
-  SetMozBackgroundRequest(bool aMozBackgroundRequest);
-
   virtual void
   SetMozBackgroundRequest(bool aMozBackgroundRequest, ErrorResult& aRv) override;
 
   virtual uint16_t
   ErrorCode() const override
   {
     return static_cast<uint16_t>(mErrorLoad);
   }
@@ -462,21 +465,22 @@ public:
 
   // This fires a trusted readystatechange event, which is not cancelable and
   // doesn't bubble.
   nsresult FireReadystatechangeEvent();
   void DispatchProgressEvent(DOMEventTargetHelper* aTarget,
                              const ProgressEventType aType,
                              int64_t aLoaded, int64_t aTotal);
 
-  // This is called by nsXULTemplateQueryProcessorXML.
-  nsresult Init(nsIPrincipal* aPrincipal,
-                nsIGlobalObject* aGlobalObject,
-                nsIURI* aBaseURI,
-                nsILoadGroup* aLoadGroup);
+  // This is called by the factory constructor.
+  nsresult Init();
+
+  nsresult init(nsIPrincipal* principal,
+                nsPIDOMWindowInner* globalObject,
+                nsIURI* baseURI);
 
   void SetRequestObserver(nsIRequestObserver* aObserver);
 
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(XMLHttpRequestMainThread,
                                                          XMLHttpRequest)
   virtual bool IsCertainlyAliveForCC() const override;
 
   bool AllowUploadProgress();
diff --git a/dom/xhr/XMLHttpRequestUpload.cpp b/dom/xhr/XMLHttpRequestUpload.cpp
--- a/dom/xhr/XMLHttpRequestUpload.cpp
+++ b/dom/xhr/XMLHttpRequestUpload.cpp
@@ -6,19 +6,21 @@
 
 #include "XMLHttpRequestUpload.h"
 #include "mozilla/dom/XMLHttpRequestUploadBinding.h"
 
 namespace mozilla {
 namespace dom {
 
 NS_INTERFACE_MAP_BEGIN(XMLHttpRequestUpload)
+  NS_INTERFACE_MAP_ENTRY(nsIXMLHttpRequestUpload)
 NS_INTERFACE_MAP_END_INHERITING(XMLHttpRequestEventTarget)
 
 NS_IMPL_ADDREF_INHERITED(XMLHttpRequestUpload, XMLHttpRequestEventTarget)
+
 NS_IMPL_RELEASE_INHERITED(XMLHttpRequestUpload, XMLHttpRequestEventTarget)
 
 /* virtual */ JSObject*
 XMLHttpRequestUpload::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
   return XMLHttpRequestUploadBinding::Wrap(aCx, this, aGivenProto);
 }
 
diff --git a/dom/xhr/XMLHttpRequestUpload.h b/dom/xhr/XMLHttpRequestUpload.h
--- a/dom/xhr/XMLHttpRequestUpload.h
+++ b/dom/xhr/XMLHttpRequestUpload.h
@@ -3,21 +3,23 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_XMLHttpRequestUpload_h
 #define mozilla_dom_XMLHttpRequestUpload_h
 
 #include "mozilla/dom/XMLHttpRequestEventTarget.h"
+#include "nsIXMLHttpRequest.h"
 
 namespace mozilla {
 namespace dom {
 
-class XMLHttpRequestUpload final : public XMLHttpRequestEventTarget
+class XMLHttpRequestUpload final : public XMLHttpRequestEventTarget,
+                                   public nsIXMLHttpRequestUpload
 {
 public:
   explicit XMLHttpRequestUpload(DOMEventTargetHelper* aOwner)
     : XMLHttpRequestEventTarget(aOwner)
   {}
 
   explicit XMLHttpRequestUpload()
   {}
diff --git a/dom/xhr/moz.build b/dom/xhr/moz.build
--- a/dom/xhr/moz.build
+++ b/dom/xhr/moz.build
@@ -2,16 +2,22 @@
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 with Files("**"):
     BUG_COMPONENT = ("Core", "DOM")
 
+XPIDL_SOURCES += [
+    'nsIXMLHttpRequest.idl',
+]
+
+XPIDL_MODULE = 'dom_xhr'
+
 EXPORTS.mozilla.dom += [
     'XMLHttpRequest.h',
     'XMLHttpRequestEventTarget.h',
     'XMLHttpRequestMainThread.h',
     'XMLHttpRequestString.h',
     'XMLHttpRequestUpload.h',
 ]
 
diff --git a/dom/xhr/nsIXMLHttpRequest.idl b/dom/xhr/nsIXMLHttpRequest.idl
new file mode 100644
--- /dev/null
+++ b/dom/xhr/nsIXMLHttpRequest.idl
@@ -0,0 +1,319 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIDOMEventTarget.idl"
+
+interface nsIChannel;
+interface nsIDOMDocument;
+interface nsIDOMEventListener;
+interface nsILoadGroup;
+interface nsIPrincipal;
+interface nsIScriptContext;
+interface nsIURI;
+interface nsIVariant;
+interface nsIGlobalObject;
+interface nsIInputStream;
+interface nsIDOMBlob;
+
+[builtinclass, uuid(d74c4dc4-bc8c-4f5d-b7f1-121a48750abe)]
+interface nsIXMLHttpRequestUpload : nsIDOMEventTarget {
+  // for future use
+};
+
+/**
+ * Mozilla's XMLHttpRequest is modelled after Microsoft's IXMLHttpRequest
+ * object. The goal has been to make Mozilla's version match Microsoft's
+ * version as closely as possible, but there are bound to be some differences.
+ *
+ * In general, Microsoft's documentation for IXMLHttpRequest can be used.
+ * Mozilla's interface definitions provide some additional documentation. The
+ * web page to look at is http://www.mozilla.org/xmlextras/
+ *
+ * Mozilla's XMLHttpRequest object can be created in JavaScript like this:
+ *   new XMLHttpRequest()
+ * compare to Internet Explorer:
+ *   new ActiveXObject("Msxml2.XMLHTTP")
+ *
+ * From native code, the way to set up onload and onerror handlers is a bit
+ * different. Here is a comment from Johnny Stenback <jst@netscape.com>:
+ *
+ *   The mozilla implementation of nsIXMLHttpRequest implements the interface
+ *   nsIDOMEventTarget and that's how you're supported to add event listeners.
+ *   Try something like this:
+ *
+ *   nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(myxmlhttpreq));
+ *
+ *   target->AddEventListener(NS_LITERAL_STRING("load"), mylistener,
+ *                            PR_FALSE)
+ *
+ *   where mylistener is your event listener object that implements the
+ *   interface nsIDOMEventListener.
+ *
+ * Conclusion: Do not use event listeners on XMLHttpRequest from C++, unless
+ * you're aware of all the security implications.  And then think twice about
+ * it.
+ */
+[scriptable, uuid(6f54214c-7175-498d-9d2d-0429e38c2869)]
+interface nsIXMLHttpRequest : nsISupports
+{
+  /**
+   * The request uses a channel in order to perform the
+   * request.  This attribute represents the channel used
+   * for the request.  NULL if the channel has not yet been
+   * created.
+   *
+   * Mozilla only. Requires elevated privileges to access.
+   */
+  readonly attribute nsIChannel channel;
+
+  /**
+   * The response to the request is parsed as if it were a
+   * text/xml stream. This attributes represents the response as
+   * a DOM Document object. NULL if the request is unsuccessful or
+   * has not yet been sent.
+   */
+  readonly attribute nsIDOMDocument responseXML;
+
+  /**
+   * The response to the request as text.
+   * NULL if the request is unsuccessful or
+   * has not yet been sent.
+   */
+  readonly attribute AString responseText;
+
+  /**
+   * Determine a response format which response attribute returns.
+   * empty string (initial value) or "text": as text.
+   * "arraybuffer": as a typed array ArrayBuffer.
+   * "blob": as a File API Blob.
+   * "document": as a DOM Document object.
+   */
+  attribute AString responseType;
+
+  /**
+   * The response to the request as a specified format by responseType.
+   * NULL if the request is unsuccessful or
+   * has not yet been sent.
+   */
+  [implicit_jscontext] readonly attribute jsval /* any */ response;
+
+  /**
+   * The status of the response to the request for HTTP requests.
+   */
+  // XXX spec says unsigned short
+  readonly attribute unsigned long status;
+
+  /**
+   * The string representing the status of the response for
+   * HTTP requests.
+   */
+  readonly attribute ACString statusText;
+
+  /**
+   * If the request has been sent already, this method will
+   * abort the request.
+   */
+  [binaryname(SlowAbort)] void abort();
+
+  /**
+   * Returns all of the response headers as a string for HTTP
+   * requests.
+   *
+   * @returns A string containing all of the response headers.
+   *          The empty string if the response has not yet been received.
+   */
+  ACString getAllResponseHeaders();
+
+  /**
+   * Returns the text of the header with the specified name for
+   * HTTP requests.
+   *
+   * @param header The name of the header to retrieve
+   * @returns A string containing the text of the header specified.
+   *          NULL if the response has not yet been received or the
+   *          header does not exist in the response.
+   */
+  ACString getResponseHeader(in ACString header);
+
+%{C++
+  // note this is NOT virtual so this won't muck with the vtable!
+  inline nsresult Open(const nsACString& method, const nsACString& url,
+                       bool async, const nsAString& user,
+                       const nsAString& password) {
+    return Open(method, url, async, user, password, 3);
+  }
+%}
+  /**
+   * Meant to be a script-only method for initializing a request.
+   *
+   * If there is an "active" request (that is, if open() has been called
+   * already), this is equivalent to calling abort() and then open().
+   *
+   * @param method The HTTP method - either "POST" or "GET". Ignored
+   *               if the URL is not a HTTP URL.
+   * @param url The URL to which to send the request.
+   * @param async (optional) Whether the request is synchronous or
+   *              asynchronous i.e. whether send returns only after
+   *              the response is received or if it returns immediately after
+   *              sending the request. In the latter case, notification
+   *              of completion is sent through the event listeners.
+   *              The default value is true.
+   * @param user (optional) A username for authentication if necessary.
+   *             The default value is the empty string
+   * @param password (optional) A password for authentication if necessary.
+   *                 The default value is the empty string
+   */
+  [optional_argc] void open(in ACString method, in AUTF8String url,
+                            [optional] in boolean async,
+                            [optional,Undefined(Empty)] in DOMString user,
+                            [optional,Undefined(Empty)] in DOMString password);
+
+  /**
+   * Sends the request. If the request is asynchronous, returns
+   * immediately after sending the request. If it is synchronous
+   * returns only after the response has been received.
+   *
+   * All event listeners must be set before calling send().
+   *
+   * After the initial response, all event listeners will be cleared.
+   * // XXXbz what does that mean, exactly?   
+   *
+   * @param body Either an instance of nsIDOMDocument, nsIInputStream
+   *             or a string (nsISupportsString in the native calling
+   *             case). This is used to populate the body of the
+   *             HTTP request if the HTTP request method is "POST".
+   *             If the parameter is a nsIDOMDocument, it is serialized.
+   *             If the parameter is a nsIInputStream, then it must be
+   *             compatible with nsIUploadChannel.setUploadStream, and a
+   *             Content-Length header will be added to the HTTP request
+   *             with a value given by nsIInputStream.available.  Any
+   *             headers included at the top of the stream will be
+   *             treated as part of the message body.  The MIME type of
+   *             the stream should be specified by setting the Content-
+   *             Type header via the setRequestHeader method before
+   *             calling send.
+   */
+  void   send([optional] in nsIVariant body);
+
+  /**
+   * Sets a HTTP request header for HTTP requests. You must call open
+   * before setting the request headers.
+   *
+   * @param header The name of the header to set in the request.
+   * @param value The body of the header.
+   */
+  void   setRequestHeader(in ACString header, in ACString value);
+
+  /**
+   * The amount of milliseconds a request can take before being terminated.
+   * Initially zero. Zero means there is no timeout.
+   */
+  attribute unsigned long timeout;
+
+  /**
+   * The state of the request.
+   *
+   * Possible values:
+   *   0 UNSENT   open() has not been called yet.
+   *   1 OPENED   send() has not been called yet.
+   *   2 HEADERS_RECEIVED
+   *              send() has been called, headers and status are available.
+   *   3 LOADING  Downloading, responseText holds the partial data.
+   *   4 DONE     Finished with all operations.
+   */
+  const unsigned short UNSENT = 0;
+  const unsigned short OPENED = 1;
+  const unsigned short HEADERS_RECEIVED = 2;
+  const unsigned short LOADING = 3;
+  const unsigned short DONE = 4;
+  readonly attribute unsigned short readyState;
+
+  /**
+   * Override the mime type returned by the server (if any). This may
+   * be used, for example, to force a stream to be treated and parsed
+   * as text/xml, even if the server does not report it as such. This
+   * must be done before the <code>send</code> method is invoked.
+   *
+   * @param mimetype The type used to override that returned by the server
+   *                 (if any).
+   */
+  [binaryname(SlowOverrideMimeType)] void overrideMimeType(in DOMString mimetype);
+
+  /**
+   * Set to true if this is a background service request. This will
+   * prevent a load group being associated with the request, and
+   * suppress any security dialogs from being shown * to the user.
+   * In the cases where one of those dialogs would be shown, the request
+   * will simply fail instead.
+   */
+  attribute boolean mozBackgroundRequest;
+
+  /**
+   * When set to true attempts to make cross-site Access-Control requests
+   * with credentials such as cookies and authorization headers.
+   *
+   * Never affects same-site requests.
+   *
+   * Defaults to false.
+   */
+  attribute boolean withCredentials;
+
+  /**
+   * Initialize the object for use from C++ code with the principal, script
+   * context, and owner window that should be used.
+   *
+   * @param principal The principal to use for the request. This must not be
+   *                  null.
+   * @param globalObject The associated global for the request. Can be the
+   *                     outer window, a sandbox, or a backstage pass.
+   *                     May be null, but then the request cannot create a
+   *                     document.
+   * @param baseURI The base URI to use when resolving relative URIs. May be
+   *                null.
+   * @param loadGroup An optional load group to use when performing the request.
+   *                  This will be used even if the global has a window with a
+   *                  load group.
+   */
+  [noscript] void init(in nsIPrincipal principal,
+                       in nsIGlobalObject globalObject,
+                       in nsIURI baseURI,
+                       [optional] in nsILoadGroup loadGroup);
+
+  /**
+   * Upload process can be tracked by adding event listener to |upload|.
+   */
+  readonly attribute nsIXMLHttpRequestUpload upload;
+
+  /**
+   * If true, the request will be sent without cookie and authentication
+   * headers.
+   */
+  readonly attribute boolean mozAnon;
+
+  /**
+   * If true, the same origin policy will not be enforced on the request.
+   */
+  readonly attribute boolean mozSystem;
+};
+
+[uuid(840d0d00-e83e-4a29-b3c7-67e96e90a499)]
+interface nsIXHRSendable : nsISupports {
+  // contentTypeWithCharset can be set to the contentType or
+  // contentType+charset based on what the spec says.
+  // See: https://fetch.spec.whatwg.org/#concept-bodyinit-extract
+  void getSendInfo(out nsIInputStream body,
+                   out uint64_t contentLength,
+                   out ACString contentTypeWithCharset,
+                   out ACString charset);
+};
+
+%{ C++
+#define NS_XMLHTTPREQUEST_CID                       \
+ { /* d164e770-4157-11d4-9a42-000064657374 */       \
+  0xd164e770, 0x4157, 0x11d4,                       \
+ {0x9a, 0x42, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74} }
+#define NS_XMLHTTPREQUEST_CONTRACTID \
+"@mozilla.org/xmlextras/xmlhttprequest;1"
+%}
diff --git a/layout/build/nsLayoutModule.cpp b/layout/build/nsLayoutModule.cpp
--- a/layout/build/nsLayoutModule.cpp
+++ b/layout/build/nsLayoutModule.cpp
@@ -57,16 +57,17 @@
 #include "nsIEventListenerService.h"
 #include "nsIMessageManager.h"
 
 // Transformiix stuff
 #include "mozilla/dom/XPathEvaluator.h"
 #include "txNodeSetAdaptor.h"
 
 #include "mozilla/dom/DOMParser.h"
+#include "mozilla/dom/XMLHttpRequestMainThread.h"
 #include "nsDOMSerializer.h"
 
 // view stuff
 #include "nsContentCreatorFunctions.h"
 
 #include "nsHostObjectURI.h"
 #include "nsGlobalWindowCommands.h"
 #include "nsIControllerCommandTable.h"
@@ -217,16 +218,17 @@ NS_GENERIC_FACTORY_CONSTRUCTOR(HTMLEdito
 #define PRESENTATION_TCP_SESSION_TRANSPORT_CID \
 { 0xc9d023f4, 0x6228, 0x4c07, { 0x8b, 0x1d, 0x9c, 0x19, 0x57, 0x3f, 0xaa, 0x27 } }
 
 already_AddRefed<nsIPresentationService> NS_CreatePresentationService();
 
 // Factory Constructor
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(txNodeSetAdaptor, Init)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsDOMSerializer)
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(XMLHttpRequestMainThread, Init)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsHostObjectURI)
 NS_GENERIC_FACTORY_CONSTRUCTOR(DOMParser)
 NS_GENERIC_FACTORY_CONSTRUCTOR(LocalStorageManager)
 NS_GENERIC_FACTORY_CONSTRUCTOR(SessionStorageManager)
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(DOMRequestService,
                                          DOMRequestService::FactoryCreate)
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(QuotaManagerService,
                                          QuotaManagerService::FactoryCreate)
@@ -585,16 +587,17 @@ NS_DEFINE_NAMED_CID(NS_WINDOWCOMMANDTABL
 NS_DEFINE_NAMED_CID(NS_WINDOWCONTROLLER_CID);
 NS_DEFINE_NAMED_CID(NS_PLUGINDOCLOADERFACTORY_CID);
 NS_DEFINE_NAMED_CID(NS_PLUGINDOCUMENT_CID);
 NS_DEFINE_NAMED_CID(NS_VIDEODOCUMENT_CID);
 NS_DEFINE_NAMED_CID(NS_STYLESHEETSERVICE_CID);
 NS_DEFINE_NAMED_CID(TRANSFORMIIX_NODESET_CID);
 NS_DEFINE_NAMED_CID(NS_XMLSERIALIZER_CID);
 NS_DEFINE_NAMED_CID(NS_HOSTOBJECTURI_CID);
+NS_DEFINE_NAMED_CID(NS_XMLHTTPREQUEST_CID);
 NS_DEFINE_NAMED_CID(NS_DOMPARSER_CID);
 NS_DEFINE_NAMED_CID(NS_DOMSESSIONSTORAGEMANAGER_CID);
 NS_DEFINE_NAMED_CID(NS_DOMLOCALSTORAGEMANAGER_CID);
 NS_DEFINE_NAMED_CID(NS_TEXTEDITOR_CID);
 NS_DEFINE_NAMED_CID(DOMREQUEST_SERVICE_CID);
 NS_DEFINE_NAMED_CID(QUOTAMANAGER_SERVICE_CID);
 NS_DEFINE_NAMED_CID(SERVICEWORKERMANAGER_CID);
 NS_DEFINE_NAMED_CID(NOTIFICATIONTELEMETRYSERVICE_CID);
@@ -833,16 +836,17 @@ static const mozilla::Module::CIDEntry k
   { &kNS_WINDOWCONTROLLER_CID, false, nullptr, CreateWindowControllerWithSingletonCommandTable },
   { &kNS_PLUGINDOCLOADERFACTORY_CID, false, nullptr, CreateContentDLF },
   { &kNS_PLUGINDOCUMENT_CID, false, nullptr, CreatePluginDocument },
   { &kNS_VIDEODOCUMENT_CID, false, nullptr, CreateVideoDocument },
   { &kNS_STYLESHEETSERVICE_CID, false, nullptr, nsStyleSheetServiceConstructor },
   { &kTRANSFORMIIX_NODESET_CID, false, nullptr, txNodeSetAdaptorConstructor },
   { &kNS_XMLSERIALIZER_CID, false, nullptr, nsDOMSerializerConstructor },
   { &kNS_HOSTOBJECTURI_CID, false, nullptr, nsHostObjectURIConstructor },
+  { &kNS_XMLHTTPREQUEST_CID, false, nullptr, XMLHttpRequestMainThreadConstructor },
   { &kNS_DOMPARSER_CID, false, nullptr, DOMParserConstructor },
   { &kNS_DOMSESSIONSTORAGEMANAGER_CID, false, nullptr, SessionStorageManagerConstructor },
   { &kNS_DOMLOCALSTORAGEMANAGER_CID, false, nullptr, LocalStorageManagerConstructor },
   { &kNS_TEXTEDITOR_CID, false, nullptr, TextEditorConstructor },
   { &kDOMREQUEST_SERVICE_CID, false, nullptr, DOMRequestServiceConstructor },
   { &kQUOTAMANAGER_SERVICE_CID, false, nullptr, QuotaManagerServiceConstructor },
   { &kSERVICEWORKERMANAGER_CID, false, nullptr, ServiceWorkerManagerConstructor },
   { &kNOTIFICATIONTELEMETRYSERVICE_CID, false, nullptr, NotificationTelemetryServiceConstructor },
@@ -946,16 +950,17 @@ static const mozilla::Module::ContractID
 #endif
   { CONTENT_DLF_CONTRACTID, &kNS_CONTENT_DOCUMENT_LOADER_FACTORY_CID },
   { NS_JSPROTOCOLHANDLER_CONTRACTID, &kNS_JSPROTOCOLHANDLER_CID },
   { NS_WINDOWCONTROLLER_CONTRACTID, &kNS_WINDOWCONTROLLER_CID },
   { PLUGIN_DLF_CONTRACTID, &kNS_PLUGINDOCLOADERFACTORY_CID },
   { NS_STYLESHEETSERVICE_CONTRACTID, &kNS_STYLESHEETSERVICE_CID },
   { TRANSFORMIIX_NODESET_CONTRACTID, &kTRANSFORMIIX_NODESET_CID },
   { NS_XMLSERIALIZER_CONTRACTID, &kNS_XMLSERIALIZER_CID },
+  { NS_XMLHTTPREQUEST_CONTRACTID, &kNS_XMLHTTPREQUEST_CID },
   { NS_DOMPARSER_CONTRACTID, &kNS_DOMPARSER_CID },
   { "@mozilla.org/dom/localStorage-manager;1", &kNS_DOMLOCALSTORAGEMANAGER_CID },
   // Keeping the old ContractID for backward compatibility
   { "@mozilla.org/dom/storagemanager;1", &kNS_DOMLOCALSTORAGEMANAGER_CID },
   { "@mozilla.org/dom/sessionStorage-manager;1", &kNS_DOMSESSIONSTORAGEMANAGER_CID },
   { "@mozilla.org/editor/texteditor;1", &kNS_TEXTEDITOR_CID },
   { DOMREQUEST_SERVICE_CONTRACTID, &kDOMREQUEST_SERVICE_CID },
   { QUOTAMANAGER_SERVICE_CONTRACTID, &kQUOTAMANAGER_SERVICE_CID },
diff --git a/xpcom/reflect/xptinfo/ShimInterfaceInfo.cpp b/xpcom/reflect/xptinfo/ShimInterfaceInfo.cpp
--- a/xpcom/reflect/xptinfo/ShimInterfaceInfo.cpp
+++ b/xpcom/reflect/xptinfo/ShimInterfaceInfo.cpp
@@ -51,16 +51,17 @@
 #include "nsIDOMXMLDocument.h"
 #include "nsIDOMXULCommandEvent.h"
 #include "nsIDOMXULElement.h"
 #include "nsIFrameLoader.h"
 #include "nsIListBoxObject.h"
 #include "nsISelection.h"
 #include "nsITreeBoxObject.h"
 #include "nsIWebBrowserPersistable.h"
+#include "nsIXMLHttpRequest.h"
 
 #include "mozilla/dom/CharacterDataBinding.h"
 #include "mozilla/dom/DOMRectBinding.h"
 #include "mozilla/dom/DOMRectListBinding.h"
 #include "mozilla/dom/ClipboardEventBinding.h"
 #include "mozilla/dom/CommentBinding.h"
 #include "mozilla/dom/CSSPrimitiveValueBinding.h"
 #include "mozilla/dom/CSSStyleDeclarationBinding.h"
@@ -115,16 +116,18 @@
 #include "mozilla/dom/StyleSheetListBinding.h"
 #include "mozilla/dom/SVGElementBinding.h"
 #include "mozilla/dom/TextBinding.h"
 #include "mozilla/dom/TimeEventBinding.h"
 #include "mozilla/dom/TreeBoxObjectBinding.h"
 #include "mozilla/dom/UIEventBinding.h"
 #include "mozilla/dom/WheelEventBinding.h"
 #include "mozilla/dom/XMLDocumentBinding.h"
+#include "mozilla/dom/XMLHttpRequestEventTargetBinding.h"
+#include "mozilla/dom/XMLHttpRequestUploadBinding.h"
 #include "mozilla/dom/XMLSerializerBinding.h"
 #include "mozilla/dom/XULCommandEventBinding.h"
 #include "mozilla/dom/XULDocumentBinding.h"
 #include "mozilla/dom/XULElementBinding.h"
 
 using namespace mozilla;
 
 struct ComponentsInterfaceShimEntry {
@@ -224,16 +227,17 @@ const ComponentsInterfaceShimEntry kComp
   DEFINE_SHIM_WITH_CUSTOM_INTERFACE(nsITreeBoxObject, TreeBoxObject),
   DEFINE_SHIM(UIEvent),
   DEFINE_SHIM_WITH_CUSTOM_INTERFACE(nsIWebBrowserPersistable, FrameLoader),
   DEFINE_SHIM(WheelEvent),
   DEFINE_SHIM(XMLDocument),
   DEFINE_SHIM(XULCommandEvent),
   DEFINE_SHIM(XULElement),
   DEFINE_SHIM_WITH_CUSTOM_INTERFACE(nsISelection, Selection),
+  DEFINE_SHIM_WITH_CUSTOM_INTERFACE(nsIXMLHttpRequestUpload, XMLHttpRequestUpload),
 };
 
 #undef DEFINE_SHIM
 #undef DEFINE_SHIM_WITH_CUSTOM_INTERFACE
 
 NS_IMPL_ISUPPORTS(ShimInterfaceInfo, nsISupports, nsIInterfaceInfo)
 
 already_AddRefed<ShimInterfaceInfo>
# HG changeset patch
# User RealDolos <dolos@cock.li>
# Date 1519934482 -3600
#      Thu Mar 01 21:01:22 2018 +0100
# Node ID c1e8ed59a51e13e74969d219e02cebf383392253
# Parent  2f435ce419c868d69b1b1a011e030c72f1bc2981
Add back tabbrowser id

diff --git a/browser/base/content/browser.xul b/browser/base/content/browser.xul
--- a/browser/base/content/browser.xul
+++ b/browser/base/content/browser.xul
@@ -1206,16 +1206,17 @@
         <browser id="sidebar" flex="1" autoscroll="false" disablehistory="true" disablefullscreen="true"
                   style="min-width: 14em; width: 18em; max-width: 36em;" tooltip="aHTMLTooltip"/>
       </vbox>
 
       <splitter id="sidebar-splitter" class="chromeclass-extrachrome sidebar-splitter" hidden="true"/>
       <vbox id="appcontent" flex="1">
         <notificationbox id="high-priority-global-notificationbox" notificationside="top"/>
         <tabbrowser flex="1" contenttooltip="aHTMLTooltip"
+                    id="content"
                     tabcontainer="tabbrowser-tabs"
                     contentcontextmenu="contentAreaContextMenu"
                     autocompletepopup="PopupAutoComplete"
                     selectmenulist="ContentSelectDropdown"
                     datetimepicker="DateTimePickerPanel"/>
       </vbox>
       <vbox id="browser-border-end" hidden="true" layer="true"/>
     </hbox>