Add a slightly modified version of the gecko/44 search service and use it when building Pale Moon

1 files changed, 4971 insertions, 0 deletions

diff --git a/toolkit/components/search/orginal/nsSearchService.js b/toolkit/components/search/orginal/nsSearchService.js
new file mode 100644
index 000000000..3bcf4ce22
--- /dev/null
+++ b/toolkit/components/search/orginal/nsSearchService.js
@@ -0,0 +1,4971 @@
+# 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/.
+
+const Ci = Components.interfaces;
+const Cc = Components.classes;
+const Cr = Components.results;
+const Cu = Components.utils;
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+Components.utils.import("resource://gre/modules/Promise.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "AsyncShutdown",
+  "resource://gre/modules/AsyncShutdown.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "DeferredTask",
+  "resource://gre/modules/DeferredTask.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "OS",
+  "resource://gre/modules/osfile.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+  "resource://gre/modules/Task.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Deprecated",
+  "resource://gre/modules/Deprecated.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "SearchStaticData",
+  "resource://gre/modules/SearchStaticData.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "setTimeout",
+  "resource://gre/modules/Timer.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "clearTimeout",
+  "resource://gre/modules/Timer.jsm");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gTextToSubURI",
+                                   "@mozilla.org/intl/texttosuburi;1",
+                                   "nsITextToSubURI");
+
+Cu.importGlobalProperties(["XMLHttpRequest"]);
+
+// A text encoder to UTF8, used whenever we commit the
+// engine metadata to disk.
+XPCOMUtils.defineLazyGetter(this, "gEncoder",
+                            function() {
+                              return new TextEncoder();
+                            });
+
+const MODE_RDONLY   = 0x01;
+const MODE_WRONLY   = 0x02;
+const MODE_CREATE   = 0x08;
+const MODE_APPEND   = 0x10;
+const MODE_TRUNCATE = 0x20;
+
+// Directory service keys
+const NS_APP_SEARCH_DIR_LIST  = "SrchPluginsDL";
+const NS_APP_DISTRIBUTION_SEARCH_DIR_LIST = "SrchPluginsDistDL";
+const NS_APP_USER_SEARCH_DIR  = "UsrSrchPlugns";
+const NS_APP_SEARCH_DIR       = "SrchPlugns";
+const NS_APP_USER_PROFILE_50_DIR = "ProfD";
+
+// Loading plugins from NS_APP_SEARCH_DIR is no longer supported.
+// Instead, we now load plugins from APP_SEARCH_PREFIX, where a
+// list.txt file needs to exist to list available engines.
+const APP_SEARCH_PREFIX = "resource://search-plugins/";
+
+// Search engine "locations". If this list is changed, be sure to update
+// the engine's _isDefault function accordingly.
+const SEARCH_APP_DIR = 1;
+const SEARCH_PROFILE_DIR = 2;
+const SEARCH_IN_EXTENSION = 3;
+const SEARCH_JAR = 4;
+
+// See documentation in nsIBrowserSearchService.idl.
+const SEARCH_ENGINE_TOPIC        = "browser-search-engine-modified";
+const QUIT_APPLICATION_TOPIC     = "quit-application";
+
+const SEARCH_ENGINE_REMOVED      = "engine-removed";
+const SEARCH_ENGINE_ADDED        = "engine-added";
+const SEARCH_ENGINE_CHANGED      = "engine-changed";
+const SEARCH_ENGINE_LOADED       = "engine-loaded";
+const SEARCH_ENGINE_CURRENT      = "engine-current";
+const SEARCH_ENGINE_DEFAULT      = "engine-default";
+
+// The following constants are left undocumented in nsIBrowserSearchService.idl
+// For the moment, they are meant for testing/debugging purposes only.
+
+/**
+ * Topic used for events involving the service itself.
+ */
+const SEARCH_SERVICE_TOPIC       = "browser-search-service";
+
+/**
+ * Sent whenever metadata is fully written to disk.
+ */
+const SEARCH_SERVICE_METADATA_WRITTEN  = "write-metadata-to-disk-complete";
+
+/**
+ * Sent whenever the cache is fully written to disk.
+ */
+const SEARCH_SERVICE_CACHE_WRITTEN  = "write-cache-to-disk-complete";
+
+// Delay for lazy serialization (ms)
+const LAZY_SERIALIZE_DELAY = 100;
+
+// Delay for batching invalidation of the JSON cache (ms)
+const CACHE_INVALIDATION_DELAY = 1000;
+
+// Current cache version. This should be incremented if the format of the cache
+// file is modified.
+const CACHE_VERSION = 7;
+
+const ICON_DATAURL_PREFIX = "data:image/x-icon;base64,";
+
+const NEW_LINES = /(\r\n|\r|\n)/;
+
+// Set an arbitrary cap on the maximum icon size. Without this, large icons can
+// cause big delays when loading them at startup.
+const MAX_ICON_SIZE   = 10000;
+
+// Default charset to use for sending search parameters. ISO-8859-1 is used to
+// match previous nsInternetSearchService behavior.
+const DEFAULT_QUERY_CHARSET = "ISO-8859-1";
+
+const SEARCH_BUNDLE = "chrome://global/locale/search/search.properties";
+const BRAND_BUNDLE = "chrome://branding/locale/brand.properties";
+
+const OPENSEARCH_NS_10  = "http://a9.com/-/spec/opensearch/1.0/";
+const OPENSEARCH_NS_11  = "http://a9.com/-/spec/opensearch/1.1/";
+
+// Although the specification at http://opensearch.a9.com/spec/1.1/description/
+// gives the namespace names defined above, many existing OpenSearch engines
+// are using the following versions.  We therefore allow either.
+const OPENSEARCH_NAMESPACES = [
+  OPENSEARCH_NS_11, OPENSEARCH_NS_10,
+  "http://a9.com/-/spec/opensearchdescription/1.1/",
+  "http://a9.com/-/spec/opensearchdescription/1.0/"
+];
+
+const OPENSEARCH_LOCALNAME = "OpenSearchDescription";
+
+const MOZSEARCH_NS_10     = "http://www.mozilla.org/2006/browser/search/";
+const MOZSEARCH_LOCALNAME = "SearchPlugin";
+
+const URLTYPE_SUGGEST_JSON = "application/x-suggestions+json";
+const URLTYPE_SEARCH_HTML  = "text/html";
+const URLTYPE_OPENSEARCH   = "application/opensearchdescription+xml";
+
+// Empty base document used to serialize engines to file.
+const EMPTY_DOC = "<?xml version=\"1.0\"?>\n" +
+                  "<" + MOZSEARCH_LOCALNAME +
+                  " xmlns=\"" + MOZSEARCH_NS_10 + "\"" +
+                  " xmlns:os=\"" + OPENSEARCH_NS_11 + "\"" +
+                  "/>";
+
+const BROWSER_SEARCH_PREF = "browser.search.";
+const LOCALE_PREF = "general.useragent.locale";
+
+const USER_DEFINED = "{searchTerms}";
+
+// Custom search parameters
+#ifdef MOZ_OFFICIAL_BRANDING
+const MOZ_OFFICIAL = "official";
+#else
+const MOZ_OFFICIAL = "unofficial";
+#endif
+#expand const MOZ_DISTRIBUTION_ID = __MOZ_DISTRIBUTION_ID__;
+
+const MOZ_PARAM_LOCALE         = /\{moz:locale\}/g;
+const MOZ_PARAM_DIST_ID        = /\{moz:distributionID\}/g;
+const MOZ_PARAM_OFFICIAL       = /\{moz:official\}/g;
+
+// Supported OpenSearch parameters
+// See http://opensearch.a9.com/spec/1.1/querysyntax/#core
+const OS_PARAM_USER_DEFINED    = /\{searchTerms\??\}/g;
+const OS_PARAM_INPUT_ENCODING  = /\{inputEncoding\??\}/g;
+const OS_PARAM_LANGUAGE        = /\{language\??\}/g;
+const OS_PARAM_OUTPUT_ENCODING = /\{outputEncoding\??\}/g;
+
+// Default values
+const OS_PARAM_LANGUAGE_DEF         = "*";
+const OS_PARAM_OUTPUT_ENCODING_DEF  = "UTF-8";
+const OS_PARAM_INPUT_ENCODING_DEF   = "UTF-8";
+
+// "Unsupported" OpenSearch parameters. For example, we don't support
+// page-based results, so if the engine requires that we send the "page index"
+// parameter, we'll always send "1".
+const OS_PARAM_COUNT        = /\{count\??\}/g;
+const OS_PARAM_START_INDEX  = /\{startIndex\??\}/g;
+const OS_PARAM_START_PAGE   = /\{startPage\??\}/g;
+
+// Default values
+const OS_PARAM_COUNT_DEF        = "20"; // 20 results
+const OS_PARAM_START_INDEX_DEF  = "1";  // start at 1st result
+const OS_PARAM_START_PAGE_DEF   = "1";  // 1st page
+
+// Optional parameter
+const OS_PARAM_OPTIONAL     = /\{(?:\w+:)?\w+\?\}/g;
+
+// A array of arrays containing parameters that we don't fully support, and
+// their default values. We will only send values for these parameters if
+// required, since our values are just really arbitrary "guesses" that should
+// give us the output we want.
+var OS_UNSUPPORTED_PARAMS = [
+  [OS_PARAM_COUNT, OS_PARAM_COUNT_DEF],
+  [OS_PARAM_START_INDEX, OS_PARAM_START_INDEX_DEF],
+  [OS_PARAM_START_PAGE, OS_PARAM_START_PAGE_DEF],
+];
+
+// The default engine update interval, in days. This is only used if an engine
+// specifies an updateURL, but not an updateInterval.
+const SEARCH_DEFAULT_UPDATE_INTERVAL = 7;
+
+// The default interval before checking again for the name of the
+// default engine for the region, in seconds. Only used if the response
+// from the server doesn't specify an interval.
+const SEARCH_GEO_DEFAULT_UPDATE_INTERVAL = 2592000; // 30 days.
+
+this.__defineGetter__("FileUtils", function() {
+  delete this.FileUtils;
+  Components.utils.import("resource://gre/modules/FileUtils.jsm");
+  return FileUtils;
+});
+
+this.__defineGetter__("NetUtil", function() {
+  delete this.NetUtil;
+  Components.utils.import("resource://gre/modules/NetUtil.jsm");
+  return NetUtil;
+});
+
+this.__defineGetter__("gChromeReg", function() {
+  delete this.gChromeReg;
+  return this.gChromeReg = Cc["@mozilla.org/chrome/chrome-registry;1"].
+                           getService(Ci.nsIChromeRegistry);
+});
+
+/**
+ * Prefixed to all search debug output.
+ */
+const SEARCH_LOG_PREFIX = "*** Search: ";
+
+/**
+ * Outputs aText to the JavaScript console as well as to stdout.
+ */
+function DO_LOG(aText) {
+  dump(SEARCH_LOG_PREFIX + aText + "\n");
+  Services.console.logStringMessage(aText);
+}
+
+#ifdef DEBUG
+/**
+ * In debug builds, use a live, pref-based (browser.search.log) LOG function
+ * to allow enabling/disabling without a restart.
+ */
+function PREF_LOG(aText) {
+  if (getBoolPref(BROWSER_SEARCH_PREF + "log", false))
+    DO_LOG(aText);
+}
+var LOG = PREF_LOG;
+
+#else
+
+/**
+ * Otherwise, don't log at all by default. This can be overridden at startup
+ * by the pref, see SearchService's _init method.
+ */
+var LOG = function(){};
+
+#endif
+
+/**
+ * Presents an assertion dialog in non-release builds and throws.
+ * @param  message
+ *         A message to display
+ * @param  resultCode
+ *         The NS_ERROR_* value to throw.
+ * @throws resultCode
+ */
+function ERROR(message, resultCode) {
+  NS_ASSERT(false, SEARCH_LOG_PREFIX + message);
+  throw Components.Exception(message, resultCode);
+}
+
+/**
+ * Logs the failure message (if browser.search.log is enabled) and throws.
+ * @param  message
+ *         A message to display
+ * @param  resultCode
+ *         The NS_ERROR_* value to throw.
+ * @throws resultCode or NS_ERROR_INVALID_ARG if resultCode isn't specified.
+ */
+function FAIL(message, resultCode) {
+  LOG(message);
+  throw Components.Exception(message, resultCode || Cr.NS_ERROR_INVALID_ARG);
+}
+
+/**
+ * Truncates big blobs of (data-)URIs to console-friendly sizes
+ * @param str
+ *        String to tone down
+ * @param len
+ *        Maximum length of the string to return. Defaults to the length of a tweet.
+ */
+function limitURILength(str, len) {
+  len = len || 140;
+  if (str.length > len)
+    return str.slice(0, len) + "...";
+  return str;
+}
+
+/**
+ * Ensures an assertion is met before continuing. Should be used to indicate
+ * fatal errors.
+ * @param  assertion
+ *         An assertion that must be met
+ * @param  message
+ *         A message to display if the assertion is not met
+ * @param  resultCode
+ *         The NS_ERROR_* value to throw if the assertion is not met
+ * @throws resultCode
+ */
+function ENSURE_WARN(assertion, message, resultCode) {
+  NS_ASSERT(assertion, SEARCH_LOG_PREFIX + message);
+  if (!assertion)
+    throw Components.Exception(message, resultCode);
+}
+
+function loadListener(aChannel, aEngine, aCallback) {
+  this._channel = aChannel;
+  this._bytes = [];
+  this._engine = aEngine;
+  this._callback = aCallback;
+}
+loadListener.prototype = {
+  _callback: null,
+  _channel: null,
+  _countRead: 0,
+  _engine: null,
+  _stream: null,
+
+  QueryInterface: function SRCH_loadQI(aIID) {
+    if (aIID.equals(Ci.nsISupports)           ||
+        aIID.equals(Ci.nsIRequestObserver)    ||
+        aIID.equals(Ci.nsIStreamListener)     ||
+        aIID.equals(Ci.nsIChannelEventSink)   ||
+        aIID.equals(Ci.nsIInterfaceRequestor) ||
+        // See FIXME comment below
+        aIID.equals(Ci.nsIHttpEventSink)      ||
+        aIID.equals(Ci.nsIProgressEventSink)  ||
+        false)
+      return this;
+
+    throw Cr.NS_ERROR_NO_INTERFACE;
+  },
+
+  // nsIRequestObserver
+  onStartRequest: function SRCH_loadStartR(aRequest, aContext) {
+    LOG("loadListener: Starting request: " + aRequest.name);
+    this._stream = Cc["@mozilla.org/binaryinputstream;1"].
+                   createInstance(Ci.nsIBinaryInputStream);
+  },
+
+  onStopRequest: function SRCH_loadStopR(aRequest, aContext, aStatusCode) {
+    LOG("loadListener: Stopping request: " + aRequest.name);
+
+    var requestFailed = !Components.isSuccessCode(aStatusCode);
+    if (!requestFailed && (aRequest instanceof Ci.nsIHttpChannel))
+      requestFailed = !aRequest.requestSucceeded;
+
+    if (requestFailed || this._countRead == 0) {
+      LOG("loadListener: request failed!");
+      // send null so the callback can deal with the failure
+      this._callback(null, this._engine);
+    } else
+      this._callback(this._bytes, this._engine);
+    this._channel = null;
+    this._engine  = null;
+  },
+
+  // nsIStreamListener
+  onDataAvailable: function SRCH_loadDAvailable(aRequest, aContext,
+                                                aInputStream, aOffset,
+                                                aCount) {
+    this._stream.setInputStream(aInputStream);
+
+    // Get a byte array of the data
+    this._bytes = this._bytes.concat(this._stream.readByteArray(aCount));
+    this._countRead += aCount;
+  },
+
+  // nsIChannelEventSink
+  asyncOnChannelRedirect: function SRCH_loadCRedirect(aOldChannel, aNewChannel,
+                                                      aFlags, callback) {
+    this._channel = aNewChannel;
+    callback.onRedirectVerifyCallback(Components.results.NS_OK);
+  },
+
+  // nsIInterfaceRequestor
+  getInterface: function SRCH_load_GI(aIID) {
+    return this.QueryInterface(aIID);
+  },
+
+  // FIXME: bug 253127
+  // nsIHttpEventSink
+  onRedirect: function (aChannel, aNewChannel) {},
+  // nsIProgressEventSink
+  onProgress: function (aRequest, aContext, aProgress, aProgressMax) {},
+  onStatus: function (aRequest, aContext, aStatus, aStatusArg) {}
+}
+
+function isPartnerBuild() {
+  try {
+    let distroID = Services.prefs.getCharPref("distribution.id");
+
+    // Mozilla-provided builds (i.e. funnelcake) are not partner builds
+    if (distroID && !distroID.startsWith("mozilla")) {
+      return true;
+    }
+  } catch (e) {}
+
+  return false;
+}
+
+// Method to determine if we should be using geo-specific defaults
+function geoSpecificDefaultsEnabled() {
+  let geoSpecificDefaults = false;
+  try {
+    geoSpecificDefaults = Services.prefs.getBoolPref("browser.search.geoSpecificDefaults");
+  } catch(e) {}
+
+  return geoSpecificDefaults;
+}
+
+// Some notes on countryCode and region prefs:
+// * A "countryCode" pref is set via a geoip lookup.  It always reflects the
+//   result of that geoip request.
+// * A "region" pref, once set, is the region actually used for search.  In
+//   most cases it will be identical to the countryCode pref.
+// * The value of "region" and "countryCode" will only not agree in one edge
+//   case - 34/35 users who have previously been configured to use US defaults
+//   based purely on a timezone check will have "region" forced to US,
+//   regardless of what countryCode geoip returns.
+// * We may want to know if we are in the US before we have *either*
+//   countryCode or region - in which case we fallback to a timezone check,
+//   but we don't persist that value anywhere in the expectation we will
+//   eventually get a countryCode/region.
+
+// A method that "migrates" prefs if necessary.
+function migrateRegionPrefs() {
+  // If we already have a "region" pref there's nothing to do.
+  if (Services.prefs.prefHasUserValue("browser.search.region")) {
+    return;
+  }
+
+  // If we have 'isUS' but no 'countryCode' then we are almost certainly
+  // a profile from Fx 34/35 that set 'isUS' based purely on a timezone
+  // check. If this said they were US, we force region to be US.
+  // (But if isUS was false, we leave region alone - we will do a geoip request
+  // and set the region accordingly)
+  try {
+    if (Services.prefs.getBoolPref("browser.search.isUS") &&
+        !Services.prefs.prefHasUserValue("browser.search.countryCode")) {
+      Services.prefs.setCharPref("browser.search.region", "US");
+    }
+  } catch (ex) {
+    // no isUS pref, nothing to do.
+  }
+  // If we have a countryCode pref but no region pref, just force region
+  // to be the countryCode.
+  try {
+    let countryCode = Services.prefs.getCharPref("browser.search.countryCode");
+    if (!Services.prefs.prefHasUserValue("browser.search.region")) {
+      Services.prefs.setCharPref("browser.search.region", countryCode);
+    }
+  } catch (ex) {
+    // no countryCode pref, nothing to do.
+  }
+}
+
+// A method to determine if we are in the United States (US) for the search
+// service.
+// It uses a browser.search.region pref (which typically comes from a geoip
+// request) or if that doesn't exist, falls back to a hacky timezone check.
+function getIsUS() {
+  // Regardless of the region or countryCode, non en-US builds are not
+  // considered to be in the US from the POV of the search service.
+  if (getLocale() != "en-US") {
+    return false;
+  }
+
+  // If we've got a region pref, trust it.
+  try {
+    return Services.prefs.getCharPref("browser.search.region") == "US";
+  } catch(e) {}
+
+  // So we are en-US but have no region pref - fallback to hacky timezone check.
+  let isNA = isUSTimezone();
+  LOG("getIsUS() fell back to a timezone check with the result=" + isNA);
+  return isNA;
+}
+
+// Helper method to modify preference keys with geo-specific modifiers, if needed.
+function getGeoSpecificPrefName(basepref) {
+  if (!geoSpecificDefaultsEnabled() || isPartnerBuild())
+    return basepref;
+  if (getIsUS())
+    return basepref + ".US";
+  return basepref;
+}
+
+// A method that tries to determine if this user is in a US geography.
+function isUSTimezone() {
+  // Timezone assumptions! We assume that if the system clock's timezone is
+  // between Newfoundland and Hawaii, that the user is in North America.
+
+  // This includes all of South America as well, but we have relatively few
+  // en-US users there, so that's OK.
+
+  // 150 minutes = 2.5 hours (UTC-2.5), which is
+  // Newfoundland Daylight Time (http://www.timeanddate.com/time/zones/ndt)
+
+  // 600 minutes = 10 hours (UTC-10), which is
+  // Hawaii-Aleutian Standard Time (http://www.timeanddate.com/time/zones/hast)
+
+  let UTCOffset = (new Date()).getTimezoneOffset();
+  return UTCOffset >= 150 && UTCOffset <= 600;
+}
+
+// A less hacky method that tries to determine our country-code via an XHR
+// geoip lookup.
+// If this succeeds and we are using an en-US locale, we set the pref used by
+// the hacky method above, so isUS() can avoid the hacky timezone method.
+// If it fails we don't touch that pref so isUS() does its normal thing.
+var ensureKnownCountryCode = Task.async(function* () {
+  // If we have a country-code already stored in our prefs we trust it.
+  let countryCode;
+  try {
+    countryCode = Services.prefs.getCharPref("browser.search.countryCode");
+  } catch(e) {}
+
+  if (!countryCode) {
+    // We don't have it cached, so fetch it. fetchCountryCode() will call
+    // storeCountryCode if it gets a result (even if that happens after the
+    // promise resolves) and fetchRegionDefault.
+    yield fetchCountryCode();
+  } else {
+    // if nothing to do, return early.
+    if (!geoSpecificDefaultsEnabled())
+      return;
+
+    let expir = engineMetadataService.getGlobalAttr("searchDefaultExpir") || 0;
+    if (expir > Date.now()) {
+      // The territory default we have already fetched hasn't expired yet.
+      // If we have a default engine or a list of visible default engines
+      // saved, the hashes should be valid, verify them now so that we can
+      // refetch if they have been tampered with.
+      let defaultEngine = engineMetadataService.getGlobalAttr("searchDefault");
+      let visibleDefaultEngines =
+        engineMetadataService.getGlobalAttr("visibleDefaultEngines");
+      if ((!defaultEngine || engineMetadataService.getGlobalAttr("searchDefaultHash") == getVerificationHash(defaultEngine)) &&
+          (!visibleDefaultEngines ||
+           engineMetadataService.getGlobalAttr("visibleDefaultEnginesHash") == getVerificationHash(visibleDefaultEngines))) {
+        // No geo defaults, or valid hashes; nothing to do.
+        return;
+      }
+    }
+
+    yield new Promise(resolve => {
+      let timeoutMS = Services.prefs.getIntPref("browser.search.geoip.timeout");
+      let timerId = setTimeout(() => {
+        timerId = null;
+        resolve();
+      }, timeoutMS);
+
+      let callback = () => {
+        clearTimeout(timerId);
+        resolve();
+      };
+      fetchRegionDefault().then(callback).catch(err => {
+        Components.utils.reportError(err);
+        callback();
+      });
+    });
+  }
+});
+
+// Store the result of the geoip request as well as any other values and
+// telemetry which depend on it.
+function storeCountryCode(cc) {
+  // Set the country-code itself.
+  Services.prefs.setCharPref("browser.search.countryCode", cc);
+  // And set the region pref if we don't already have a value.
+  if (!Services.prefs.prefHasUserValue("browser.search.region")) {
+    Services.prefs.setCharPref("browser.search.region", cc);
+  }
+  // and telemetry...
+  let isTimezoneUS = isUSTimezone();
+  // telemetry to compare our geoip response with platform-specific country data.
+  // On Mac and Windows, we can get a country code via sysinfo
+  let platformCC = Services.sysinfo.get("countryCode");
+  if (platformCC) {
+    let probeUSMismatched, probeNonUSMismatched;
+    switch (Services.appinfo.OS) {
+      case "Darwin":
+        probeUSMismatched = "SEARCH_SERVICE_US_COUNTRY_MISMATCHED_PLATFORM_OSX";
+        probeNonUSMismatched = "SEARCH_SERVICE_NONUS_COUNTRY_MISMATCHED_PLATFORM_OSX";
+        break;
+      case "WINNT":
+        probeUSMismatched = "SEARCH_SERVICE_US_COUNTRY_MISMATCHED_PLATFORM_WIN";
+        probeNonUSMismatched = "SEARCH_SERVICE_NONUS_COUNTRY_MISMATCHED_PLATFORM_WIN";
+        break;
+      default:
+        Cu.reportError("Platform " + Services.appinfo.OS + " has system country code but no search service telemetry probes");
+        break;
+    }
+  }
+}
+
+// Get the country we are in via a XHR geoip request.
+function fetchCountryCode() {
+  // values for the SEARCH_SERVICE_COUNTRY_FETCH_RESULT 'enum' telemetry probe.
+  const TELEMETRY_RESULT_ENUM = {
+    SUCCESS: 0,
+    SUCCESS_WITHOUT_DATA: 1,
+    XHRTIMEOUT: 2,
+    ERROR: 3,
+    // Note that we expect to add finer-grained error types here later (eg,
+    // dns error, network error, ssl error, etc) with .ERROR remaining as the
+    // generic catch-all that doesn't fit into other categories.
+  };
+  let endpoint = Services.urlFormatter.formatURLPref("browser.search.geoip.url");
+  LOG("_fetchCountryCode starting with endpoint " + endpoint);
+  // As an escape hatch, no endpoint means no geoip.
+  if (!endpoint) {
+    return Promise.resolve();
+  }
+  let startTime = Date.now();
+  return new Promise(resolve => {
+    // Instead of using a timeout on the xhr object itself, we simulate one
+    // using a timer and let the XHR request complete.  This allows us to
+    // capture reliable telemetry on what timeout value should actually be
+    // used to ensure most users don't see one while not making it so large
+    // that many users end up doing a sync init of the search service and thus
+    // would see the jank that implies.
+    // (Note we do actually use a timeout on the XHR, but that's set to be a
+    // large value just incase the request never completes - we don't want the
+    // XHR object to live forever)
+    let timeoutMS = Services.prefs.getIntPref("browser.search.geoip.timeout");
+    let geoipTimeoutPossible = true;
+    let timerId = setTimeout(() => {
+      LOG("_fetchCountryCode: timeout fetching country information");
+      timerId = null;
+      resolve();
+    }, timeoutMS);
+
+    let resolveAndReportSuccess = (result, reason) => {
+      // Even if we timed out, we want to save the country code and everything
+      // related so next startup sees the value and doesn't retry this dance.
+      if (result) {
+        storeCountryCode(result);
+      }
+
+      // This notification is just for tests...
+      Services.obs.notifyObservers(null, SEARCH_SERVICE_TOPIC, "geoip-lookup-xhr-complete");
+
+      if (timerId) {
+        geoipTimeoutPossible = false;
+      }
+
+      let callback = () => {
+        // If we've already timed out then we've already resolved the promise,
+        // so there's nothing else to do.
+        if (timerId == null) {
+          return;
+        }
+        clearTimeout(timerId);
+        resolve();
+      };
+
+      if (result && geoSpecificDefaultsEnabled()) {
+        fetchRegionDefault().then(callback).catch(err => {
+          Components.utils.reportError(err);
+          callback();
+        });
+      } else {
+        callback();
+      }
+    };
+
+    let request = new XMLHttpRequest();
+    // This notification is just for tests...
+    Services.obs.notifyObservers(request, SEARCH_SERVICE_TOPIC, "geoip-lookup-xhr-starting");
+    request.timeout = 100000; // 100 seconds as the last-chance fallback
+    request.onload = function(event) {
+      let took = Date.now() - startTime;
+      let cc = event.target.response && event.target.response.country_code;
+      LOG("_fetchCountryCode got success response in " + took + "ms: " + cc);
+      let reason = cc ? TELEMETRY_RESULT_ENUM.SUCCESS : TELEMETRY_RESULT_ENUM.SUCCESS_WITHOUT_DATA;
+      resolveAndReportSuccess(cc, reason);
+    };
+    request.ontimeout = function(event) {
+      LOG("_fetchCountryCode: XHR finally timed-out fetching country information");
+      resolveAndReportSuccess(null, TELEMETRY_RESULT_ENUM.XHRTIMEOUT);
+    };
+    request.onerror = function(event) {
+      LOG("_fetchCountryCode: failed to retrieve country information");
+      resolveAndReportSuccess(null, TELEMETRY_RESULT_ENUM.ERROR);
+    };
+    request.open("POST", endpoint, true);
+    request.setRequestHeader("Content-Type", "application/json");
+    request.responseType = "json";
+    request.send("{}");
+  });
+}
+
+// This will make an HTTP request to a Mozilla server that will return
+// JSON data telling us what engine should be set as the default for
+// the current region, and how soon we should check again.
+//
+// The optional cohort value returned by the server is to be kept locally
+// and sent to the server the next time we ping it. It lets the server
+// identify profiles that have been part of a specific experiment.
+//
+// This promise may take up to 100s to resolve, it's the caller's
+// responsibility to ensure with a timer that we are not going to
+// block the async init for too long.
+var fetchRegionDefault = () => new Promise(resolve => {
+  let urlTemplate = Services.prefs.getDefaultBranch(BROWSER_SEARCH_PREF)
+                            .getCharPref("geoSpecificDefaults.url");
+  let endpoint = Services.urlFormatter.formatURL(urlTemplate);
+
+  // As an escape hatch, no endpoint means no region specific defaults.
+  if (!endpoint) {
+    resolve();
+    return;
+  }
+
+  // Append the optional cohort value.
+  const cohortPref = "browser.search.cohort";
+  let cohort;
+  try {
+    cohort = Services.prefs.getCharPref(cohortPref);
+  } catch(e) {}
+  if (cohort)
+    endpoint += "/" + cohort;
+
+  LOG("fetchRegionDefault starting with endpoint " + endpoint);
+
+  let startTime = Date.now();
+  let request = new XMLHttpRequest();
+  request.timeout = 100000; // 100 seconds as the last-chance fallback
+  request.onload = function(event) {
+    let took = Date.now() - startTime;
+
+    let status = event.target.status;
+    if (status != 200) {
+      LOG("fetchRegionDefault failed with HTTP code " + status);
+      let retryAfter = request.getResponseHeader("retry-after");
+      if (retryAfter) {
+        engineMetadataService.setGlobalAttr("searchDefaultExpir",
+                                            Date.now() + retryAfter * 1000);
+      }
+      resolve();
+      return;
+    }
+
+    let response = event.target.response || {};
+    LOG("received " + response.toSource());
+
+    if (response.cohort) {
+      Services.prefs.setCharPref(cohortPref, response.cohort);
+    } else {
+      Services.prefs.clearUserPref(cohortPref);
+    }
+
+    if (response.settings && response.settings.searchDefault) {
+      let defaultEngine = response.settings.searchDefault;
+      engineMetadataService.setGlobalAttr("searchDefault", defaultEngine);
+      let hash = getVerificationHash(defaultEngine);
+      LOG("fetchRegionDefault saved searchDefault: " + defaultEngine +
+          " with verification hash: " + hash);
+      engineMetadataService.setGlobalAttr("searchDefaultHash", hash);
+    }
+
+    if (response.settings && response.settings.visibleDefaultEngines) {
+      let visibleDefaultEngines = response.settings.visibleDefaultEngines;
+      let string = visibleDefaultEngines.join(",");
+      engineMetadataService.setGlobalAttr("visibleDefaultEngines", string);
+      let hash = getVerificationHash(string);
+      LOG("fetchRegionDefault saved visibleDefaultEngines: " + string +
+          " with verification hash: " + hash);
+      engineMetadataService.setGlobalAttr("visibleDefaultEnginesHash", hash);
+    }
+
+    let interval = response.interval || SEARCH_GEO_DEFAULT_UPDATE_INTERVAL;
+    let milliseconds = interval * 1000; // |interval| is in seconds.
+    engineMetadataService.setGlobalAttr("searchDefaultExpir",
+                                        Date.now() + milliseconds);
+
+    LOG("fetchRegionDefault got success response in " + took + "ms");
+    resolve();
+  };
+  request.ontimeout = function(event) {
+    LOG("fetchRegionDefault: XHR finally timed-out");
+    resolve();
+  };
+  request.onerror = function(event) {
+    LOG("fetchRegionDefault: failed to retrieve territory default information");
+    resolve();
+  };
+  request.open("GET", endpoint, true);
+  request.setRequestHeader("Content-Type", "application/json");
+  request.responseType = "json";
+  request.send();
+});
+
+function getVerificationHash(aName) {
+  let disclaimer = "By modifying this file, I agree that I am doing so " +
+    "only within $appName itself, using official, user-driven search " +
+    "engine selection processes, and in a way which does not circumvent " +
+    "user consent. I acknowledge that any attempt to change this file " +
+    "from outside of $appName is a malicious act, and will be responded " +
+    "to accordingly."
+
+  let salt = OS.Path.basename(OS.Constants.Path.profileDir) + aName +
+             disclaimer.replace(/\$appName/g, Services.appinfo.name);
+
+  let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"]
+                    .createInstance(Ci.nsIScriptableUnicodeConverter);
+  converter.charset = "UTF-8";
+
+  // Data is an array of bytes.
+  let data = converter.convertToByteArray(salt, {});
+  let hasher = Cc["@mozilla.org/security/hash;1"]
+                 .createInstance(Ci.nsICryptoHash);
+  hasher.init(hasher.SHA256);
+  hasher.update(data, data.length);
+
+  return hasher.finish(true);
+}
+
+/**
+ * Safely close a nsISafeOutputStream.
+ * @param aFOS
+ *        The file output stream to close.
+ */
+function closeSafeOutputStream(aFOS) {
+  if (aFOS instanceof Ci.nsISafeOutputStream) {
+    try {
+      aFOS.finish();
+      return;
+    } catch (e) { }
+  }
+  aFOS.close();
+}
+
+/**
+ * Wrapper function for nsIIOService::newURI.
+ * @param aURLSpec
+ *        The URL string from which to create an nsIURI.
+ * @returns an nsIURI object, or null if the creation of the URI failed.
+ */
+function makeURI(aURLSpec, aCharset) {
+  try {
+    return NetUtil.newURI(aURLSpec, aCharset);
+  } catch (ex) { }
+
+  return null;
+}
+
+/**
+ * Wrapper function for nsIIOService::newChannel2.
+ * @param url
+ *        The URL string from which to create an nsIChannel.
+ * @returns an nsIChannel object, or null if the url is invalid.
+ */
+function makeChannel(url) {
+  try {
+    return NetUtil.newChannel({uri: url, loadUsingSystemPrincipal: true});
+  } catch (ex) { }
+
+  return null;
+}
+
+/**
+ * Gets a directory from the directory service.
+ * @param aKey
+ *        The directory service key indicating the directory to get.
+ */
+function getDir(aKey, aIFace) {
+  if (!aKey)
+    FAIL("getDir requires a directory key!");
+
+  return Services.dirsvc.get(aKey, aIFace || Ci.nsIFile);
+}
+
+/**
+ * Gets the current value of the locale.  It's possible for this preference to
+ * be localized, so we have to do a little extra work here.  Similar code
+ * exists in nsHttpHandler.cpp when building the UA string.
+ */
+function getLocale() {
+  let locale = getLocalizedPref(LOCALE_PREF);
+  if (locale)
+    return locale;
+
+  // Not localized.
+  return Services.prefs.getCharPref(LOCALE_PREF);
+}
+
+/**
+ * Wrapper for nsIPrefBranch::getComplexValue.
+ * @param aPrefName
+ *        The name of the pref to get.
+ * @returns aDefault if the requested pref doesn't exist.
+ */
+function getLocalizedPref(aPrefName, aDefault) {
+  const nsIPLS = Ci.nsIPrefLocalizedString;
+  try {
+    return Services.prefs.getComplexValue(aPrefName, nsIPLS).data;
+  } catch (ex) {}
+
+  return aDefault;
+}
+
+/**
+ * Wrapper for nsIPrefBranch::setComplexValue.
+ * @param aPrefName
+ *        The name of the pref to set.
+ */
+function setLocalizedPref(aPrefName, aValue) {
+  const nsIPLS = Ci.nsIPrefLocalizedString;
+  try {
+    var pls = Components.classes["@mozilla.org/pref-localizedstring;1"]
+                        .createInstance(Ci.nsIPrefLocalizedString);
+    pls.data = aValue;
+    Services.prefs.setComplexValue(aPrefName, nsIPLS, pls);
+  } catch (ex) {}
+}
+
+/**
+ * Wrapper for nsIPrefBranch::getBoolPref.
+ * @param aPrefName
+ *        The name of the pref to get.
+ * @returns aDefault if the requested pref doesn't exist.
+ */
+function getBoolPref(aName, aDefault) {
+  if (Services.prefs.getPrefType(aName) != Ci.nsIPrefBranch.PREF_BOOL)
+    return aDefault;
+  return Services.prefs.getBoolPref(aName);
+}
+
+/**
+ * Get a unique nsIFile object with a sanitized name, based on the engine name.
+ * @param aName
+ *        A name to "sanitize". Can be an empty string, in which case a random
+ *        8 character filename will be produced.
+ * @returns A nsIFile object in the user's search engines directory with a
+ *          unique sanitized name.
+ */
+function getSanitizedFile(aName) {
+  var fileName = sanitizeName(aName) + ".xml";
+  var file = getDir(NS_APP_USER_SEARCH_DIR);
+  file.append(fileName);
+  file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
+  return file;
+}
+
+/**
+ * @return a sanitized name to be used as a filename, or a random name
+ *         if a sanitized name cannot be obtained (if aName contains
+ *         no valid characters).
+ */
+function sanitizeName(aName) {
+  const maxLength = 60;
+  const minLength = 1;
+  var name = aName.toLowerCase();
+  name = name.replace(/\s+/g, "-");
+  name = name.replace(/[^-a-z0-9]/g, "");
+
+  // Use a random name if our input had no valid characters.
+  if (name.length < minLength)
+    name = Math.random().toString(36).replace(/^.*\./, '');
+
+  // Force max length.
+  return name.substring(0, maxLength);
+}
+
+/**
+ * Retrieve a pref from the search param branch.
+ *
+ * @param prefName
+ *        The name of the pref.
+ **/
+function getMozParamPref(prefName) {
+  return Services.prefs.getCharPref(BROWSER_SEARCH_PREF + "param." + prefName);
+}
+
+/**
+ * Notifies watchers of SEARCH_ENGINE_TOPIC about changes to an engine or to
+ * the state of the search service.
+ *
+ * @param aEngine
+ *        The nsISearchEngine object to which the change applies.
+ * @param aVerb
+ *        A verb describing the change.
+ *
+ * @see nsIBrowserSearchService.idl
+ */
+var gInitialized = false;
+function notifyAction(aEngine, aVerb) {
+  if (gInitialized) {
+    LOG("NOTIFY: Engine: \"" + aEngine.name + "\"; Verb: \"" + aVerb + "\"");
+    Services.obs.notifyObservers(aEngine, SEARCH_ENGINE_TOPIC, aVerb);
+  }
+}
+
+function  parseJsonFromStream(aInputStream) {
+  const json = Cc["@mozilla.org/dom/json;1"].createInstance(Ci.nsIJSON);
+  const data = json.decodeFromStream(aInputStream, aInputStream.available());
+  return data;
+}
+
+/**
+ * Simple object representing a name/value pair.
+ */
+function QueryParameter(aName, aValue, aPurpose) {
+  if (!aName || (aValue == null))
+    FAIL("missing name or value for QueryParameter!");
+
+  this.name = aName;
+  this.value = aValue;
+  this.purpose = aPurpose;
+}
+
+/**
+ * Perform OpenSearch parameter substitution on aParamValue.
+ *
+ * @param aParamValue
+ *        A string containing OpenSearch search parameters.
+ * @param aSearchTerms
+ *        The user-provided search terms. This string will inserted into
+ *        aParamValue as the value of the OS_PARAM_USER_DEFINED parameter.
+ *        This value must already be escaped appropriately - it is inserted
+ *        as-is.
+ * @param aEngine
+ *        The engine which owns the string being acted on.
+ *
+ * @see http://opensearch.a9.com/spec/1.1/querysyntax/#core
+ */
+function ParamSubstitution(aParamValue, aSearchTerms, aEngine) {
+  var value = aParamValue;
+
+  var distributionID = MOZ_DISTRIBUTION_ID;
+  try {
+    distributionID = Services.prefs.getCharPref(BROWSER_SEARCH_PREF + "distributionID");
+  }
+  catch (ex) { }
+  var official = MOZ_OFFICIAL;
+  try {
+    if (Services.prefs.getBoolPref(BROWSER_SEARCH_PREF + "official"))
+      official = "official";
+    else
+      official = "unofficial";
+  }
+  catch (ex) { }
+
+  // Custom search parameters. These are only available to default search
+  // engines.
+  if (aEngine._isDefault) {
+    value = value.replace(MOZ_PARAM_LOCALE, getLocale());
+    value = value.replace(MOZ_PARAM_DIST_ID, distributionID);
+    value = value.replace(MOZ_PARAM_OFFICIAL, official);
+  }
+
+  // Insert the OpenSearch parameters we're confident about
+  value = value.replace(OS_PARAM_USER_DEFINED, aSearchTerms);
+  value = value.replace(OS_PARAM_INPUT_ENCODING, aEngine.queryCharset);
+  value = value.replace(OS_PARAM_LANGUAGE,
+                        getLocale() || OS_PARAM_LANGUAGE_DEF);
+  value = value.replace(OS_PARAM_OUTPUT_ENCODING,
+                        OS_PARAM_OUTPUT_ENCODING_DEF);
+
+  // Replace any optional parameters
+  value = value.replace(OS_PARAM_OPTIONAL, "");
+
+  // Insert any remaining required params with our default values
+  for (var i = 0; i < OS_UNSUPPORTED_PARAMS.length; ++i) {
+    value = value.replace(OS_UNSUPPORTED_PARAMS[i][0],
+                          OS_UNSUPPORTED_PARAMS[i][1]);
+  }
+
+  return value;
+}
+
+/**
+ * Creates an engineURL object, which holds the query URL and all parameters.
+ *
+ * @param aType
+ *        A string containing the name of the MIME type of the search results
+ *        returned by this URL.
+ * @param aMethod
+ *        The HTTP request method. Must be a case insensitive value of either
+ *        "GET" or "POST".
+ * @param aTemplate
+ *        The URL to which search queries should be sent. For GET requests,
+ *        must contain the string "{searchTerms}", to indicate where the user
+ *        entered search terms should be inserted.
+ * @param aResultDomain
+ *        The root domain for this URL.  Defaults to the template's host.
+ *
+ * @see http://opensearch.a9.com/spec/1.1/querysyntax/#urltag
+ *
+ * @throws NS_ERROR_NOT_IMPLEMENTED if aType is unsupported.
+ */
+function EngineURL(aType, aMethod, aTemplate, aResultDomain) {
+  if (!aType || !aMethod || !aTemplate)
+    FAIL("missing type, method or template for EngineURL!");
+
+  var method = aMethod.toUpperCase();
+  var type   = aType.toLowerCase();
+
+  if (method != "GET" && method != "POST")
+    FAIL("method passed to EngineURL must be \"GET\" or \"POST\"");
+
+  this.type     = type;
+  this.method   = method;
+  this.params   = [];
+  this.rels     = [];
+  // Don't serialize expanded mozparams
+  this.mozparams = {};
+
+  var templateURI = makeURI(aTemplate);
+  if (!templateURI)
+    FAIL("new EngineURL: template is not a valid URI!", Cr.NS_ERROR_FAILURE);
+
+  switch (templateURI.scheme) {
+    case "http":
+    case "https":
+    // Disable these for now, see bug 295018
+    // case "file":
+    // case "resource":
+      this.template = aTemplate;
+      break;
+    default:
+      FAIL("new EngineURL: template uses invalid scheme!", Cr.NS_ERROR_FAILURE);
+  }
+
+  // If no resultDomain was specified in the engine definition file, use the
+  // host from the template.
+  this.resultDomain = aResultDomain || templateURI.host;
+  // We never want to return a "www." prefix, so eventually strip it.
+  if (this.resultDomain.startsWith("www.")) {
+    this.resultDomain = this.resultDomain.substr(4);
+  }
+}
+EngineURL.prototype = {
+
+  addParam: function SRCH_EURL_addParam(aName, aValue, aPurpose) {
+    this.params.push(new QueryParameter(aName, aValue, aPurpose));
+  },
+
+  // Note: This method requires that aObj has a unique name or the previous MozParams entry with
+  // that name will be overwritten.
+  _addMozParam: function SRCH_EURL__addMozParam(aObj) {
+    aObj.mozparam = true;
+    this.mozparams[aObj.name] = aObj;
+  },
+
+  getSubmission: function SRCH_EURL_getSubmission(aSearchTerms, aEngine, aPurpose) {
+    var url = ParamSubstitution(this.template, aSearchTerms, aEngine);
+    // Default to an empty string if the purpose is not provided so that default purpose params
+    // (purpose="") work consistently rather than having to define "null" and "" purposes.
+    var purpose = aPurpose || "";
+
+    // If the 'system' purpose isn't defined in the plugin, fallback to 'searchbar'.
+    if (purpose == "system" && !this.params.some(p => p.purpose == "system"))
+      purpose = "searchbar";
+
+    // Create an application/x-www-form-urlencoded representation of our params
+    // (name=value&name=value&name=value)
+    var dataString = "";
+    for (var i = 0; i < this.params.length; ++i) {
+      var param = this.params[i];
+
+      // If this parameter has a purpose, only add it if the purpose matches
+      if (param.purpose !== undefined && param.purpose != purpose)
+        continue;
+
+      var value = ParamSubstitution(param.value, aSearchTerms, aEngine);
+
+      dataString += (i > 0 ? "&" : "") + param.name + "=" + value;
+    }
+
+    var postData = null;
+    if (this.method == "GET") {
+      // GET method requests have no post data, and append the encoded
+      // query string to the url...
+      if (url.indexOf("?") == -1 && dataString)
+        url += "?";
+      url += dataString;
+    } else if (this.method == "POST") {
+      // POST method requests must wrap the encoded text in a MIME
+      // stream and supply that as POSTDATA.
+      var stringStream = Cc["@mozilla.org/io/string-input-stream;1"].
+                         createInstance(Ci.nsIStringInputStream);
+      stringStream.data = dataString;
+
+      postData = Cc["@mozilla.org/network/mime-input-stream;1"].
+                 createInstance(Ci.nsIMIMEInputStream);
+      postData.addHeader("Content-Type", "application/x-www-form-urlencoded");
+      postData.addContentLength = true;
+      postData.setData(stringStream);
+    }
+
+    return new Submission(makeURI(url), postData);
+  },
+
+  _getTermsParameterName: function SRCH_EURL__getTermsParameterName() {
+    let queryParam = this.params.find(p => p.value == USER_DEFINED);
+    return queryParam ? queryParam.name : "";
+  },
+
+  _hasRelation: function SRC_EURL__hasRelation(aRel) {
+    return this.rels.some(e => e == aRel.toLowerCase());
+  },
+
+  _initWithJSON: function SRC_EURL__initWithJSON(aJson, aEngine) {
+    if (!aJson.params)
+      return;
+
+    this.rels = aJson.rels;
+
+    for (let i = 0; i < aJson.params.length; ++i) {
+      let param = aJson.params[i];
+      if (param.mozparam) {
+        if (param.condition == "pref") {
+          let value = getMozParamPref(param.pref);
+          this.addParam(param.name, value);
+        }
+        this._addMozParam(param);
+      }
+      else
+        this.addParam(param.name, param.value, param.purpose);
+    }
+  },
+
+  /**
+   * Creates a JavaScript object that represents this URL.
+   * @returns An object suitable for serialization as JSON.
+   **/
+  toJSON: function SRCH_EURL_toJSON() {
+    var json = {
+      template: this.template,
+      rels: this.rels,
+      resultDomain: this.resultDomain
+    };
+
+    if (this.type != URLTYPE_SEARCH_HTML)
+      json.type = this.type;
+    if (this.method != "GET")
+      json.method = this.method;
+
+    function collapseMozParams(aParam) {
+      return this.mozparams[aParam.name] || aParam;
+    }
+    json.params = this.params.map(collapseMozParams, this);
+
+    return json;
+  },
+
+  /**
+   * Serializes the engine object to a OpenSearch Url element.
+   * @param aDoc
+   *        The document to use to create the Url element.
+   * @param aElement
+   *        The element to which the created Url element is appended.
+   *
+   * @see http://opensearch.a9.com/spec/1.1/querysyntax/#urltag
+   */
+  _serializeToElement: function SRCH_EURL_serializeToEl(aDoc, aElement) {
+    var url = aDoc.createElementNS(OPENSEARCH_NS_11, "Url");
+    url.setAttribute("type", this.type);
+    url.setAttribute("method", this.method);
+    url.setAttribute("template", this.template);
+    if (this.rels.length)
+      url.setAttribute("rel", this.rels.join(" "));
+    if (this.resultDomain)
+      url.setAttribute("resultDomain", this.resultDomain);
+
+    for (var i = 0; i < this.params.length; ++i) {
+      var param = aDoc.createElementNS(OPENSEARCH_NS_11, "Param");
+      param.setAttribute("name", this.params[i].name);
+      param.setAttribute("value", this.params[i].value);
+      url.appendChild(aDoc.createTextNode("\n  "));
+      url.appendChild(param);
+    }
+    url.appendChild(aDoc.createTextNode("\n"));
+    aElement.appendChild(url);
+  }
+};
+
+/**
+ * nsISearchEngine constructor.
+ * @param aLocation
+ *        A nsILocalFile or nsIURI object representing the location of the
+ *        search engine data file.
+ * @param aIsReadOnly
+ *        Boolean indicating whether the engine should be treated as read-only.
+ *        Read only engines cannot be serialized to file.
+ */
+function Engine(aLocation, aIsReadOnly) {
+  this._readOnly = aIsReadOnly;
+  this._urls = [];
+
+  if (aLocation.type) {
+    if (aLocation.type == "filePath")
+      this._file = aLocation.value;
+    else if (aLocation.type == "uri")
+      this._uri = aLocation.value;
+  } else if (aLocation instanceof Ci.nsILocalFile) {
+    // we already have a file (e.g. loading engines from disk)
+    this._file = aLocation;
+  } else if (aLocation instanceof Ci.nsIURI) {
+    switch (aLocation.scheme) {
+      case "https":
+      case "http":
+      case "ftp":
+      case "data":
+      case "file":
+      case "resource":
+      case "chrome":
+        this._uri = aLocation;
+        break;
+      default:
+        ERROR("Invalid URI passed to the nsISearchEngine constructor",
+              Cr.NS_ERROR_INVALID_ARG);
+    }
+  } else
+    ERROR("Engine location is neither a File nor a URI object",
+          Cr.NS_ERROR_INVALID_ARG);
+}
+
+Engine.prototype = {
+  // The engine's alias (can be null). Initialized to |undefined| to indicate
+  // not-initialized-from-engineMetadataService.
+  _alias: undefined,
+  // A distribution-unique identifier for the engine. Either null or set
+  // when loaded. See getter.
+  _identifier: undefined,
+  // The data describing the engine, in the form of an XML document element.
+  _data: null,
+  // Whether or not the engine is readonly.
+  _readOnly: true,
+  // The engine's description
+  _description: "",
+  // Used to store the engine to replace, if we're an update to an existing
+  // engine.
+  _engineToUpdate: null,
+  // The file from which the plugin was loaded.
+  __file: null,
+  get _file() {
+    if (this.__file && !(this.__file instanceof Ci.nsILocalFile)) {
+      let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
+      file.persistentDescriptor = this.__file;
+      return this.__file = file;
+    }
+    return this.__file;
+  },
+  set _file(aValue) {
+    this.__file = aValue;
+  },
+  // Set to true if the engine has a preferred icon (an icon that should not be
+  // overridden by a non-preferred icon).
+  _hasPreferredIcon: null,
+  // The engine's name.
+  _name: null,
+  // The name of the charset used to submit the search terms.
+  _queryCharset: null,
+  // The engine's raw SearchForm value (URL string pointing to a search form).
+  __searchForm: null,
+  get _searchForm() {
+    return this.__searchForm;
+  },
+  set _searchForm(aValue) {
+    if (/^https?:/i.test(aValue))
+      this.__searchForm = aValue;
+    else
+      LOG("_searchForm: Invalid URL dropped for " + this._name ||
+          "the current engine");
+  },
+  // The URI object from which the engine was retrieved.
+  // This is null for engines loaded from disk, but present for engines loaded
+  // from chrome:// URIs.
+  __uri: null,
+  get _uri() {
+    if (this.__uri && !(this.__uri instanceof Ci.nsIURI))
+      this.__uri = makeURI(this.__uri);
+
+    return this.__uri;
+  },
+  set _uri(aValue) {
+    this.__uri = aValue;
+  },
+  // Whether to obtain user confirmation before adding the engine. This is only
+  // used when the engine is first added to the list.
+  _confirm: false,
+  // Whether to set this as the current engine as soon as it is loaded.  This
+  // is only used when the engine is first added to the list.
+  _useNow: false,
+  // A function to be invoked when this engine object's addition completes (or
+  // fails). Only used for installation via addEngine.
+  _installCallback: null,
+  // Where the engine was loaded from. Can be one of: SEARCH_APP_DIR,
+  // SEARCH_PROFILE_DIR, SEARCH_IN_EXTENSION.
+  __installLocation: null,
+  // The number of days between update checks for new versions
+  _updateInterval: null,
+  // The url to check at for a new update
+  _updateURL: null,
+  // The url to check for a new icon
+  _iconUpdateURL: null,
+  /* Deferred serialization task. */
+  _lazySerializeTask: null,
+  /* The extension ID if added by an extension. */
+  _extensionID: null,
+
+  /**
+   * Retrieves the data from the engine's file.
+   * The document element is placed in the engine's data field.
+   */
+  _initFromFile: function SRCH_ENG_initFromFile() {
+    if (!this._file || !this._file.exists())
+      FAIL("File must exist before calling initFromFile!", Cr.NS_ERROR_UNEXPECTED);
+
+    var fileInStream = Cc["@mozilla.org/network/file-input-stream;1"].
+                       createInstance(Ci.nsIFileInputStream);
+
+    fileInStream.init(this._file, MODE_RDONLY, FileUtils.PERMS_FILE, false);
+
+    var domParser = Cc["@mozilla.org/xmlextras/domparser;1"].
+                    createInstance(Ci.nsIDOMParser);
+    var doc = domParser.parseFromStream(fileInStream, "UTF-8",
+                                        this._file.fileSize,
+                                        "text/xml");
+
+    this._data = doc.documentElement;
+    fileInStream.close();
+
+    // Now that the data is loaded, initialize the engine object
+    this._initFromData();
+  },
+
+  /**
+   * Retrieves the data from the engine's file asynchronously.
+   * The document element is placed in the engine's data field.
+   *
+   * @returns {Promise} A promise, resolved successfully if initializing from
+   * data succeeds, rejected if it fails.
+   */
+  _asyncInitFromFile: function SRCH_ENG__asyncInitFromFile() {
+    return Task.spawn(function() {
+      if (!this._file || !(yield OS.File.exists(this._file.path)))
+        FAIL("File must exist before calling initFromFile!", Cr.NS_ERROR_UNEXPECTED);
+
+      let fileURI = NetUtil.ioService.newFileURI(this._file);
+      yield this._retrieveSearchXMLData(fileURI.spec);
+
+      // Now that the data is loaded, initialize the engine object
+      this._initFromData();
+    }.bind(this));
+  },
+
+  /**
+   * Retrieves the engine data from a URI. Initializes the engine, flushes to
+   * disk, and notifies the search service once initialization is complete.
+   */
+  _initFromURIAndLoad: function SRCH_ENG_initFromURIAndLoad() {
+    ENSURE_WARN(this._uri instanceof Ci.nsIURI,
+                "Must have URI when calling _initFromURIAndLoad!",
+                Cr.NS_ERROR_UNEXPECTED);
+
+    LOG("_initFromURIAndLoad: Downloading engine from: \"" + this._uri.spec + "\".");
+
+    var chan = NetUtil.ioService.newChannelFromURI2(this._uri,
+                                                    null,      // aLoadingNode
+                                                    Services.scriptSecurityManager.getSystemPrincipal(),
+                                                    null,      // aTriggeringPrincipal
+                                                    Ci.nsILoadInfo.SEC_NORMAL,
+                                                    Ci.nsIContentPolicy.TYPE_OTHER);
+
+    if (this._engineToUpdate && (chan instanceof Ci.nsIHttpChannel)) {
+      var lastModified = engineMetadataService.getAttr(this._engineToUpdate,
+                                                       "updatelastmodified");
+      if (lastModified)
+        chan.setRequestHeader("If-Modified-Since", lastModified, false);
+    }
+    var listener = new loadListener(chan, this, this._onLoad);
+    chan.notificationCallbacks = listener;
+    chan.asyncOpen(listener, null);
+  },
+
+  /**
+   * Retrieves the engine data from a URI asynchronously and initializes it.
+   *
+   * @returns {Promise} A promise, resolved successfully if retrieveing data
+   * succeeds.
+   */
+  _asyncInitFromURI: function SRCH_ENG__asyncInitFromURI() {
+    return Task.spawn(function() {
+      LOG("_asyncInitFromURI: Loading engine from: \"" + this._uri.spec + "\".");
+      yield this._retrieveSearchXMLData(this._uri.spec);
+      // Now that the data is loaded, initialize the engine object
+      this._initFromData();
+    }.bind(this));
+  },
+
+  /**
+   * Retrieves the engine data for a given URI asynchronously.
+   *
+   * @returns {Promise} A promise, resolved successfully if retrieveing data
+   * succeeds.
+   */
+  _retrieveSearchXMLData: function SRCH_ENG__retrieveSearchXMLData(aURL) {
+    let deferred = Promise.defer();
+    let request = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].
+                    createInstance(Ci.nsIXMLHttpRequest);
+    request.overrideMimeType("text/xml");
+    request.onload = (aEvent) => {
+      let responseXML = aEvent.target.responseXML;
+      this._data = responseXML.documentElement;
+      deferred.resolve();
+    };
+    request.onerror = function(aEvent) {
+      deferred.resolve();
+    };
+    request.open("GET", aURL, true);
+    request.send();
+
+    return deferred.promise;
+  },
+
+  _initFromURISync: function SRCH_ENG_initFromURISync() {
+    ENSURE_WARN(this._uri instanceof Ci.nsIURI,
+                "Must have URI when calling _initFromURISync!",
+                Cr.NS_ERROR_UNEXPECTED);
+
+    ENSURE_WARN(this._uri.schemeIs("resource"), "_initFromURISync called for non-resource URI",
+                Cr.NS_ERROR_FAILURE);
+
+    LOG("_initFromURISync: Loading engine from: \"" + this._uri.spec + "\".");
+
+    var chan = NetUtil.ioService.newChannelFromURI2(this._uri,
+                                                    null,      // aLoadingNode
+                                                    Services.scriptSecurityManager.getSystemPrincipal(),
+                                                    null,      // aTriggeringPrincipal
+                                                    Ci.nsILoadInfo.SEC_NORMAL,
+                                                    Ci.nsIContentPolicy.TYPE_OTHER);
+
+    var stream = chan.open();
+    var parser = Cc["@mozilla.org/xmlextras/domparser;1"].
+                 createInstance(Ci.nsIDOMParser);
+    var doc = parser.parseFromStream(stream, "UTF-8", stream.available(), "text/xml");
+
+    this._data = doc.documentElement;
+
+    // Now that the data is loaded, initialize the engine object
+    this._initFromData();
+  },
+
+  /**
+   * Attempts to find an EngineURL object in the set of EngineURLs for
+   * this Engine that has the given type string.  (This corresponds to the
+   * "type" attribute in the "Url" node in the OpenSearch spec.)
+   * This method will return the first matching URL object found, or null
+   * if no matching URL is found.
+   *
+   * @param aType string to match the EngineURL's type attribute
+   * @param aRel [optional] only return URLs that with this rel value
+   */
+  _getURLOfType: function SRCH_ENG__getURLOfType(aType, aRel) {
+    for (var i = 0; i < this._urls.length; ++i) {
+      if (this._urls[i].type == aType && (!aRel || this._urls[i]._hasRelation(aRel)))
+        return this._urls[i];
+    }
+
+    return null;
+  },
+
+  _confirmAddEngine: function SRCH_SVC_confirmAddEngine() {
+    var stringBundle = Services.strings.createBundle(SEARCH_BUNDLE);
+    var titleMessage = stringBundle.GetStringFromName("addEngineConfirmTitle");
+
+    // Display only the hostname portion of the URL.
+    var dialogMessage =
+        stringBundle.formatStringFromName("addEngineConfirmation",
+                                          [this._name, this._uri.host], 2);
+    var checkboxMessage = null;
+    if (!getBoolPref(BROWSER_SEARCH_PREF + "noCurrentEngine", false))
+      checkboxMessage = stringBundle.GetStringFromName("addEngineAsCurrentText");
+
+    var addButtonLabel =
+        stringBundle.GetStringFromName("addEngineAddButtonLabel");
+
+    var ps = Services.prompt;
+    var buttonFlags = (ps.BUTTON_TITLE_IS_STRING * ps.BUTTON_POS_0) +
+                      (ps.BUTTON_TITLE_CANCEL    * ps.BUTTON_POS_1) +
+                       ps.BUTTON_POS_0_DEFAULT;
+
+    var checked = {value: false};
+    // confirmEx returns the index of the button that was pressed.  Since "Add"
+    // is button 0, we want to return the negation of that value.
+    var confirm = !ps.confirmEx(null,
+                                titleMessage,
+                                dialogMessage,
+                                buttonFlags,
+                                addButtonLabel,
+                                null, null, // button 1 & 2 names not used
+                                checkboxMessage,
+                                checked);
+
+    return {confirmed: confirm, useNow: checked.value};
+  },
+
+  /**
+   * Handle the successful download of an engine. Initializes the engine and
+   * triggers parsing of the data. The engine is then flushed to disk. Notifies
+   * the search service once initialization is complete.
+   */
+  _onLoad: function SRCH_ENG_onLoad(aBytes, aEngine) {
+    /**
+     * Handle an error during the load of an engine by notifying the engine's
+     * error callback, if any.
+     */
+    function onError(errorCode = Ci.nsISearchInstallCallback.ERROR_UNKNOWN_FAILURE) {
+      // Notify the callback of the failure
+      if (aEngine._installCallback) {
+        aEngine._installCallback(errorCode);
+      }
+    }
+
+    function promptError(strings = {}, error = undefined) {
+      onError(error);
+
+      if (aEngine._engineToUpdate) {
+        // We're in an update, so just fail quietly
+        LOG("updating " + aEngine._engineToUpdate.name + " failed");
+        return;
+      }
+      var brandBundle = Services.strings.createBundle(BRAND_BUNDLE);
+      var brandName = brandBundle.GetStringFromName("brandShortName");
+
+      var searchBundle = Services.strings.createBundle(SEARCH_BUNDLE);
+      var msgStringName = strings.error || "error_loading_engine_msg2";
+      var titleStringName = strings.title || "error_loading_engine_title";
+      var title = searchBundle.GetStringFromName(titleStringName);
+      var text = searchBundle.formatStringFromName(msgStringName,
+                                                   [brandName, aEngine._location],
+                                                   2);
+
+      Services.ww.getNewPrompter(null).alert(title, text);
+    }
+
+    if (!aBytes) {
+      promptError();
+      return;
+    }
+
+    var engineToUpdate = null;
+    if (aEngine._engineToUpdate) {
+      engineToUpdate = aEngine._engineToUpdate.wrappedJSObject;
+
+      // Make this new engine use the old engine's file.
+      aEngine._file = engineToUpdate._file;
+    }
+
+    var parser = Cc["@mozilla.org/xmlextras/domparser;1"].
+                 createInstance(Ci.nsIDOMParser);
+    var doc = parser.parseFromBuffer(aBytes, aBytes.length, "text/xml");
+    aEngine._data = doc.documentElement;
+
+    try {
+      // Initialize the engine from the obtained data
+      aEngine._initFromData();
+    } catch (ex) {
+      LOG("_onLoad: Failed to init engine!\n" + ex);
+      // Report an error to the user
+      promptError();
+      return;
+    }
+
+    // Check that when adding a new engine (e.g., not updating an
+    // existing one), a duplicate engine does not already exist.
+    if (!engineToUpdate) {
+      if (Services.search.getEngineByName(aEngine.name)) {
+        // If we're confirming the engine load, then display a "this is a
+        // duplicate engine" prompt; otherwise, fail silently.
+        if (aEngine._confirm) {
+          promptError({ error: "error_duplicate_engine_msg",
+                        title: "error_invalid_engine_title"
+                      }, Ci.nsISearchInstallCallback.ERROR_DUPLICATE_ENGINE);
+        } else {
+          onError(Ci.nsISearchInstallCallback.ERROR_DUPLICATE_ENGINE);
+        }
+        LOG("_onLoad: duplicate engine found, bailing");
+        return;
+      }
+    }
+
+    // If requested, confirm the addition now that we have the title.
+    // This property is only ever true for engines added via
+    // nsIBrowserSearchService::addEngine.
+    if (aEngine._confirm) {
+      var confirmation = aEngine._confirmAddEngine();
+      LOG("_onLoad: confirm is " + confirmation.confirmed +
+          "; useNow is " + confirmation.useNow);
+      if (!confirmation.confirmed) {
+        onError();
+        return;
+      }
+      aEngine._useNow = confirmation.useNow;
+    }
+
+    // If we don't yet have a file, get one now. The only case where we would
+    // already have a file is if this is an update and _file was set above.
+    if (!aEngine._file)
+      aEngine._file = getSanitizedFile(aEngine.name);
+
+    if (engineToUpdate) {
+      // Keep track of the last modified date, so that we can make conditional
+      // requests for future updates.
+      engineMetadataService.setAttr(aEngine, "updatelastmodified",
+                                    (new Date()).toUTCString());
+
+      // If we're updating an app-shipped engine, ensure that the updateURLs
+      // are the same.
+      if (engineToUpdate._isInAppDir) {
+        let oldUpdateURL = engineToUpdate._updateURL;
+        let newUpdateURL = aEngine._updateURL;
+        let oldSelfURL = engineToUpdate._getURLOfType(URLTYPE_OPENSEARCH, "self");
+        if (oldSelfURL) {
+          oldUpdateURL = oldSelfURL.template;
+          let newSelfURL = aEngine._getURLOfType(URLTYPE_OPENSEARCH, "self");
+          if (!newSelfURL) {
+            LOG("_onLoad: updateURL missing in updated engine for " +
+                aEngine.name + " aborted");
+            onError();
+            return;
+          }
+          newUpdateURL = newSelfURL.template;
+        }
+
+        if (oldUpdateURL != newUpdateURL) {
+          LOG("_onLoad: updateURLs do not match! Update of " + aEngine.name + " aborted");
+          onError();
+          return;
+        }
+      }
+
+      // Set the new engine's icon, if it doesn't yet have one.
+      if (!aEngine._iconURI && engineToUpdate._iconURI)
+        aEngine._iconURI = engineToUpdate._iconURI;
+    }
+
+    // Write the engine to file. For readOnly engines, they'll be stored in the
+    // cache following the notification below.
+    if (!aEngine._readOnly)
+      aEngine._serializeToFile();
+
+    // Notify the search service of the successful load. It will deal with
+    // updates by checking aEngine._engineToUpdate.
+    notifyAction(aEngine, SEARCH_ENGINE_LOADED);
+
+    // Notify the callback if needed
+    if (aEngine._installCallback) {
+      aEngine._installCallback();
+    }
+  },
+
+  /**
+   * Creates a key by serializing an object that contains the icon's width
+   * and height.
+   *
+   * @param aWidth
+   *        Width of the icon.
+   * @param aHeight
+   *        Height of the icon.
+   * @returns key string
+   */
+  _getIconKey: function SRCH_ENG_getIconKey(aWidth, aHeight) {
+    let keyObj = {
+     width: aWidth,
+     height: aHeight
+    };
+
+    return JSON.stringify(keyObj);
+  },
+
+  /**
+   * Add an icon to the icon map used by getIconURIBySize() and getIcons().
+   *
+   * @param aWidth
+   *        Width of the icon.
+   * @param aHeight
+   *        Height of the icon.
+   * @param aURISpec
+   *        String with the icon's URI.
+   */
+  _addIconToMap: function SRCH_ENG_addIconToMap(aWidth, aHeight, aURISpec) {
+    // Use an object instead of a Map() because it needs to be serializable.
+    this._iconMapObj = this._iconMapObj || {};
+    let key = this._getIconKey(aWidth, aHeight);
+    this._iconMapObj[key] = aURISpec;
+  },
+
+  /**
+   * Sets the .iconURI property of the engine. If both aWidth and aHeight are
+   * provided an entry will be added to _iconMapObj that will enable accessing
+   * icon's data through getIcons() and getIconURIBySize() APIs.
+   *
+   *  @param aIconURL
+   *         A URI string pointing to the engine's icon. Must have a http[s],
+   *         ftp, or data scheme. Icons with HTTP[S] or FTP schemes will be
+   *         downloaded and converted to data URIs for storage in the engine
+   *         XML files, if the engine is not readonly.
+   *  @param aIsPreferred
+   *         Whether or not this icon is to be preferred. Preferred icons can
+   *         override non-preferred icons.
+   *  @param aWidth (optional)
+   *         Width of the icon.
+   *  @param aHeight (optional)
+   *         Height of the icon.
+   */
+  _setIcon: function SRCH_ENG_setIcon(aIconURL, aIsPreferred, aWidth, aHeight) {
+    var uri = makeURI(aIconURL);
+
+    // Ignore bad URIs
+    if (!uri)
+      return;
+
+    LOG("_setIcon: Setting icon url \"" + limitURILength(uri.spec) + "\" for engine \""
+        + this.name + "\".");
+    // Only accept remote icons from http[s] or ftp
+    switch (uri.scheme) {
+      case "data":
+        if (!this._hasPreferredIcon || aIsPreferred) {
+          this._iconURI = uri;
+          notifyAction(this, SEARCH_ENGINE_CHANGED);
+          this._hasPreferredIcon = aIsPreferred;
+        }
+
+        if (aWidth && aHeight) {
+          this._addIconToMap(aWidth, aHeight, aIconURL)
+        }
+        break;
+      case "http":
+      case "https":
+      case "ftp":
+        // No use downloading the icon if the engine file is read-only
+        LOG("_setIcon: Downloading icon: \"" + uri.spec +
+            "\" for engine: \"" + this.name + "\"");
+        var chan = NetUtil.ioService.newChannelFromURI2(uri,
+                                                        null,      // aLoadingNode
+                                                        Services.scriptSecurityManager.getSystemPrincipal(),
+                                                        null,      // aTriggeringPrincipal
+                                                        Ci.nsILoadInfo.SEC_NORMAL,
+                                                        Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE);
+
+        let iconLoadCallback = function (aByteArray, aEngine) {
+          // This callback may run after we've already set a preferred icon,
+          // so check again.
+          if (aEngine._hasPreferredIcon && !aIsPreferred)
+            return;
+
+          if (!aByteArray || aByteArray.length > MAX_ICON_SIZE) {
+            LOG("iconLoadCallback: load failed, or the icon was too large!");
+            return;
+          }
+
+          var str = btoa(String.fromCharCode.apply(null, aByteArray));
+          let dataURL = ICON_DATAURL_PREFIX + str;
+          aEngine._iconURI = makeURI(dataURL);
+
+          if (aWidth && aHeight) {
+            aEngine._addIconToMap(aWidth, aHeight, dataURL)
+          }
+
+          // The engine might not have a file yet, if it's being downloaded,
+          // because the request for the engine file itself (_onLoad) may not
+          // yet be complete. In that case, this change will be written to
+          // file when _onLoad is called. For readonly engines, we'll store
+          // the changes in the cache once notified below.
+          if (aEngine._file && !aEngine._readOnly)
+            aEngine._serializeToFile();
+
+          notifyAction(aEngine, SEARCH_ENGINE_CHANGED);
+          aEngine._hasPreferredIcon = aIsPreferred;
+        }
+
+        // If we're currently acting as an "update engine", then the callback
+        // should set the icon on the engine we're updating and not us, since
+        // |this| might be gone by the time the callback runs.
+        var engineToSet = this._engineToUpdate || this;
+
+        var listener = new loadListener(chan, engineToSet, iconLoadCallback);
+        chan.notificationCallbacks = listener;
+        chan.asyncOpen(listener, null);
+        break;
+    }
+  },
+
+  /**
+   * Initialize this Engine object from the collected data.
+   */
+  _initFromData: function SRCH_ENG_initFromData() {
+    ENSURE_WARN(this._data, "Can't init an engine with no data!",
+                Cr.NS_ERROR_UNEXPECTED);
+
+    // Ensure we have a supported engine type before attempting to parse it.
+    let element = this._data;
+    if ((element.localName == MOZSEARCH_LOCALNAME &&
+         element.namespaceURI == MOZSEARCH_NS_10) ||
+        (element.localName == OPENSEARCH_LOCALNAME &&
+         OPENSEARCH_NAMESPACES.indexOf(element.namespaceURI) != -1)) {
+      LOG("_init: Initing search plugin from " + this._location);
+
+      this._parse();
+
+    } else
+      FAIL(this._location + " is not a valid search plugin.", Cr.NS_ERROR_FAILURE);
+
+    // No need to keep a ref to our data (which in some cases can be a document
+    // element) past this point
+    this._data = null;
+  },
+
+  /**
+   * Initialize this Engine object from a collection of metadata.
+   */
+  _initFromMetadata: function SRCH_ENG_initMetaData(aName, aIconURL, aAlias,
+                                                    aDescription, aMethod,
+                                                    aTemplate, aExtensionID) {
+    ENSURE_WARN(!this._readOnly,
+                "Can't call _initFromMetaData on a readonly engine!",
+                Cr.NS_ERROR_FAILURE);
+
+    this._urls.push(new EngineURL(URLTYPE_SEARCH_HTML, aMethod, aTemplate));
+
+    this._name = aName;
+    this.alias = aAlias;
+    this._description = aDescription;
+    this._setIcon(aIconURL, true);
+    this._extensionID = aExtensionID;
+
+    this._serializeToFile();
+  },
+
+  /**
+   * Extracts data from an OpenSearch URL element and creates an EngineURL
+   * object which is then added to the engine's list of URLs.
+   *
+   * @throws NS_ERROR_FAILURE if a URL object could not be created.
+   *
+   * @see http://opensearch.a9.com/spec/1.1/querysyntax/#urltag.
+   * @see EngineURL()
+   */
+  _parseURL: function SRCH_ENG_parseURL(aElement) {
+    var type     = aElement.getAttribute("type");
+    // According to the spec, method is optional, defaulting to "GET" if not
+    // specified
+    var method   = aElement.getAttribute("method") || "GET";
+    var template = aElement.getAttribute("template");
+    var resultDomain = aElement.getAttribute("resultdomain");
+
+    try {
+      var url = new EngineURL(type, method, template, resultDomain);
+    } catch (ex) {
+      FAIL("_parseURL: failed to add " + template + " as a URL",
+           Cr.NS_ERROR_FAILURE);
+    }
+
+    if (aElement.hasAttribute("rel"))
+      url.rels = aElement.getAttribute("rel").toLowerCase().split(/\s+/);
+
+    for (var i = 0; i < aElement.childNodes.length; ++i) {
+      var param = aElement.childNodes[i];
+      if (param.localName == "Param") {
+        try {
+          url.addParam(param.getAttribute("name"), param.getAttribute("value"));
+        } catch (ex) {
+          // Ignore failure
+          LOG("_parseURL: Url element has an invalid param");
+        }
+      } else if (param.localName == "MozParam" &&
+                 // We only support MozParams for default search engines
+                 this._isDefault) {
+        var value;
+        let condition = param.getAttribute("condition");
+
+        // MozParams must have a condition to be valid
+        if (!condition) {
+          let engineLoc = this._location;
+          let paramName = param.getAttribute("name");
+          LOG("_parseURL: MozParam (" + paramName + ") without a condition attribute found parsing engine: " + engineLoc);
+          continue;
+        }
+
+        switch (condition) {
+          case "purpose":
+            url.addParam(param.getAttribute("name"),
+                         param.getAttribute("value"),
+                         param.getAttribute("purpose"));
+            // _addMozParam is not needed here since it can be serialized fine without. _addMozParam
+            // also requires a unique "name" which is not normally the case when @purpose is used.
+            break;
+          case "pref":
+            try {
+              value = getMozParamPref(param.getAttribute("pref"), value);
+              url.addParam(param.getAttribute("name"), value);
+              url._addMozParam({"pref": param.getAttribute("pref"),
+                                "name": param.getAttribute("name"),
+                                "condition": "pref"});
+            } catch (e) { }
+            break;
+          default:
+            let engineLoc = this._location;
+            let paramName = param.getAttribute("name");
+            LOG("_parseURL: MozParam (" + paramName + ") has an unknown condition: " + condition + ". Found parsing engine: " + engineLoc);
+          break;
+        }
+      }
+    }
+
+    this._urls.push(url);
+  },
+
+  /**
+   * Get the icon from an OpenSearch Image element.
+   * @see http://opensearch.a9.com/spec/1.1/description/#image
+   */
+  _parseImage: function SRCH_ENG_parseImage(aElement) {
+    LOG("_parseImage: Image textContent: \"" + limitURILength(aElement.textContent) + "\"");
+
+    let width = parseInt(aElement.getAttribute("width"), 10);
+    let height = parseInt(aElement.getAttribute("height"), 10);
+    let isPrefered = width == 16 && height == 16;
+
+    if (isNaN(width) || isNaN(height) || width <= 0 || height <=0) {
+      LOG("OpenSearch image element must have positive width and height.");
+      return;
+    }
+
+    this._setIcon(aElement.textContent, isPrefered, width, height);
+  },
+
+  /**
+   * Extract search engine information from the collected data to initialize
+   * the engine object.
+   */
+  _parse: function SRCH_ENG_parse() {
+    var doc = this._data;
+
+    // The OpenSearch spec sets a default value for the input encoding.
+    this._queryCharset = OS_PARAM_INPUT_ENCODING_DEF;
+
+    for (var i = 0; i < doc.childNodes.length; ++i) {
+      var child = doc.childNodes[i];
+      switch (child.localName) {
+        case "ShortName":
+          this._name = child.textContent;
+          break;
+        case "Description":
+          this._description = child.textContent;
+          break;
+        case "Url":
+          try {
+            this._parseURL(child);
+          } catch (ex) {
+            // Parsing of the element failed, just skip it.
+            LOG("_parse: failed to parse URL child: " + ex);
+          }
+          break;
+        case "Image":
+          this._parseImage(child);
+          break;
+        case "InputEncoding":
+          this._queryCharset = child.textContent.toUpperCase();
+          break;
+
+        // Non-OpenSearch elements
+        case "SearchForm":
+          this._searchForm = child.textContent;
+          break;
+        case "UpdateUrl":
+          this._updateURL = child.textContent;
+          break;
+        case "UpdateInterval":
+          this._updateInterval = parseInt(child.textContent);
+          break;
+        case "IconUpdateUrl":
+          this._iconUpdateURL = child.textContent;
+          break;
+        case "ExtensionID":
+          this._extensionID = child.textContent;
+          break;
+      }
+    }
+    if (!this.name || (this._urls.length == 0))
+      FAIL("_parse: No name, or missing URL!", Cr.NS_ERROR_FAILURE);
+    if (!this.supportsResponseType(URLTYPE_SEARCH_HTML))
+      FAIL("_parse: No text/html result type!", Cr.NS_ERROR_FAILURE);
+  },
+
+  /**
+   * Init from a JSON record.
+   **/
+  _initWithJSON: function SRCH_ENG__initWithJSON(aJson) {
+    this.__id = aJson._id;
+    this._name = aJson._name;
+    this._description = aJson.description;
+    if (aJson._hasPreferredIcon == undefined)
+      this._hasPreferredIcon = true;
+    else
+      this._hasPreferredIcon = false;
+    this._queryCharset = aJson.queryCharset || DEFAULT_QUERY_CHARSET;
+    this.__searchForm = aJson.__searchForm;
+    this.__installLocation = aJson._installLocation || SEARCH_APP_DIR;
+    this._updateInterval = aJson._updateInterval || null;
+    this._updateURL = aJson._updateURL || null;
+    this._iconUpdateURL = aJson._iconUpdateURL || null;
+    if (aJson._readOnly == undefined)
+      this._readOnly = true;
+    else
+      this._readOnly = false;
+    this._iconURI = makeURI(aJson._iconURL);
+    this._iconMapObj = aJson._iconMapObj;
+    if (aJson.extensionID) {
+      this._extensionID = aJson.extensionID;
+    }
+    for (let i = 0; i < aJson._urls.length; ++i) {
+      let url = aJson._urls[i];
+      let engineURL = new EngineURL(url.type || URLTYPE_SEARCH_HTML,
+                                    url.method || "GET", url.template,
+                                    url.resultDomain);
+      engineURL._initWithJSON(url, this);
+      this._urls.push(engineURL);
+    }
+  },
+
+  /**
+   * Creates a JavaScript object that represents this engine.
+   * @returns An object suitable for serialization as JSON.
+   **/
+  toJSON: function SRCH_ENG_toJSON() {
+    var json = {
+      _id: this._id,
+      _name: this._name,
+      description: this.description,
+      __searchForm: this.__searchForm,
+      _iconURL: this._iconURL,
+      _iconMapObj: this._iconMapObj,
+      _urls: this._urls
+    };
+
+    if (this._file instanceof Ci.nsILocalFile)
+      json.filePath = this._file.persistentDescriptor;
+    if (this._uri)
+      json._url = this._uri.spec;
+    if (this._installLocation != SEARCH_APP_DIR)
+      json._installLocation = this._installLocation;
+    if (this._updateInterval)
+      json._updateInterval = this._updateInterval;
+    if (this._updateURL)
+      json._updateURL = this._updateURL;
+    if (this._iconUpdateURL)
+      json._iconUpdateURL = this._iconUpdateURL;
+    if (!this._hasPreferredIcon)
+      json._hasPreferredIcon = this._hasPreferredIcon;
+    if (this.queryCharset != DEFAULT_QUERY_CHARSET)
+      json.queryCharset = this.queryCharset;
+    if (!this._readOnly)
+      json._readOnly = this._readOnly;
+    if (this._extensionID) {
+      json.extensionID = this._extensionID;
+    }
+
+    return json;
+  },
+
+  /**
+   * Returns an XML document object containing the search plugin information,
+   * which can later be used to reload the engine.
+   */
+  _serializeToElement: function SRCH_ENG_serializeToEl() {
+    function appendTextNode(aNameSpace, aLocalName, aValue) {
+      if (!aValue)
+        return null;
+      var node = doc.createElementNS(aNameSpace, aLocalName);
+      node.appendChild(doc.createTextNode(aValue));
+      docElem.appendChild(node);
+      docElem.appendChild(doc.createTextNode("\n"));
+      return node;
+    }
+
+    var parser = Cc["@mozilla.org/xmlextras/domparser;1"].
+                 createInstance(Ci.nsIDOMParser);
+
+    var doc = parser.parseFromString(EMPTY_DOC, "text/xml");
+    var docElem = doc.documentElement;
+
+    docElem.appendChild(doc.createTextNode("\n"));
+
+    appendTextNode(OPENSEARCH_NS_11, "ShortName", this.name);
+    appendTextNode(OPENSEARCH_NS_11, "Description", this._description);
+    appendTextNode(OPENSEARCH_NS_11, "InputEncoding", this._queryCharset);
+
+    if (this._iconURI) {
+      var imageNode = appendTextNode(OPENSEARCH_NS_11, "Image",
+                                     this._iconURI.spec);
+      if (imageNode) {
+        imageNode.setAttribute("width", "16");
+        imageNode.setAttribute("height", "16");
+      }
+    }
+
+    appendTextNode(MOZSEARCH_NS_10, "UpdateInterval", this._updateInterval);
+    appendTextNode(MOZSEARCH_NS_10, "UpdateUrl", this._updateURL);
+    appendTextNode(MOZSEARCH_NS_10, "IconUpdateUrl", this._iconUpdateURL);
+    appendTextNode(MOZSEARCH_NS_10, "SearchForm", this._searchForm);
+
+    if (this._extensionID) {
+      appendTextNode(MOZSEARCH_NS_10, "ExtensionID", this._extensionID);
+    }
+
+    for (var i = 0; i < this._urls.length; ++i)
+      this._urls[i]._serializeToElement(doc, docElem);
+    docElem.appendChild(doc.createTextNode("\n"));
+
+    return doc;
+  },
+
+  get lazySerializeTask() {
+    if (!this._lazySerializeTask) {
+      let task = function taskCallback() {
+        this._serializeToFile();
+      }.bind(this);
+      this._lazySerializeTask = new DeferredTask(task, LAZY_SERIALIZE_DELAY);
+    }
+
+    return this._lazySerializeTask;
+  },
+
+  /**
+   * Serializes the engine object to file.
+   */
+  _serializeToFile: function SRCH_ENG_serializeToFile() {
+    var file = this._file;
+    ENSURE_WARN(!this._readOnly, "Can't serialize a read only engine!",
+                Cr.NS_ERROR_FAILURE);
+    ENSURE_WARN(file && file.exists(), "Can't serialize: file doesn't exist!",
+                Cr.NS_ERROR_UNEXPECTED);
+
+    var fos = Cc["@mozilla.org/network/safe-file-output-stream;1"].
+              createInstance(Ci.nsIFileOutputStream);
+
+    // Serialize the engine first - we don't want to overwrite a good file
+    // if this somehow fails.
+    var doc = this._serializeToElement();
+
+    fos.init(file, (MODE_WRONLY | MODE_TRUNCATE), FileUtils.PERMS_FILE, 0);
+
+    try {
+      var serializer = Cc["@mozilla.org/xmlextras/xmlserializer;1"].
+                       createInstance(Ci.nsIDOMSerializer);
+      serializer.serializeToStream(doc.documentElement, fos, null);
+    } catch (e) {
+      LOG("_serializeToFile: Error serializing engine:\n" + e);
+    }
+
+    closeSafeOutputStream(fos);
+
+    Services.obs.notifyObservers(file.clone(), SEARCH_SERVICE_TOPIC,
+                                 "write-engine-to-disk-complete");
+  },
+
+  /**
+   * Remove the engine's file from disk. The search service calls this once it
+   * removes the engine from its internal store. This function will throw if
+   * the file cannot be removed.
+   */
+  _remove: function SRCH_ENG_remove() {
+    if (this._readOnly)
+      FAIL("Can't remove read only engine!", Cr.NS_ERROR_FAILURE);
+    if (!this._file || !this._file.exists())
+      FAIL("Can't remove engine: file doesn't exist!", Cr.NS_ERROR_FILE_NOT_FOUND);
+
+    this._file.remove(false);
+  },
+
+  // nsISearchEngine
+  get alias() {
+    if (this._alias === undefined)
+      this._alias = engineMetadataService.getAttr(this, "alias");
+
+    return this._alias;
+  },
+  set alias(val) {
+    this._alias = val;
+    engineMetadataService.setAttr(this, "alias", val);
+    notifyAction(this, SEARCH_ENGINE_CHANGED);
+  },
+
+  /**
+   * Return the built-in identifier of app-provided engines.
+   *
+   * Note that this identifier is substantially similar to _id, with the
+   * following exceptions:
+   *
+   * * There is no trailing file extension.
+   * * There is no [app] prefix.
+   *
+   * @return a string identifier, or null.
+   */
+  get identifier() {
+    if (this._identifier !== undefined) {
+      return this._identifier;
+    }
+
+    // No identifier if If the engine isn't app-provided
+    if (!this._isInAppDir && !this._isInJAR) {
+      return this._identifier = null;
+    }
+
+    let leaf = this._getLeafName();
+    ENSURE_WARN(leaf, "identifier: app-provided engine has no leafName");
+
+    // Strip file extension.
+    let ext = leaf.lastIndexOf(".");
+    if (ext == -1) {
+      return this._identifier = leaf;
+    }
+    return this._identifier = leaf.substring(0, ext);
+  },
+
+  get description() {
+    return this._description;
+  },
+
+  get hidden() {
+    return engineMetadataService.getAttr(this, "hidden") || false;
+  },
+  set hidden(val) {
+    var value = !!val;
+    if (value != this.hidden) {
+      engineMetadataService.setAttr(this, "hidden", value);
+      notifyAction(this, SEARCH_ENGINE_CHANGED);
+    }
+  },
+
+  get iconURI() {
+    if (this._iconURI)
+      return this._iconURI;
+    return null;
+  },
+
+  get _iconURL() {
+    if (!this._iconURI)
+      return "";
+    return this._iconURI.spec;
+  },
+
+  // Where the engine is being loaded from: will return the URI's spec if the
+  // engine is being downloaded and does not yet have a file. This is only used
+  // for logging and error messages.
+  get _location() {
+    if (this._file)
+      return this._file.path;
+
+    if (this._uri)
+      return this._uri.spec;
+
+    return "";
+  },
+
+  /**
+   * @return the leaf name of the filename or URI of this plugin,
+   *         or null if no file or URI is known.
+   */
+  _getLeafName: function () {
+    if (this._file) {
+      return this._file.leafName;
+    }
+    if (this._uri && this._uri instanceof Ci.nsIURL) {
+      return this._uri.fileName;
+    }
+    return null;
+  },
+
+  // The file that the plugin is loaded from is a unique identifier for it.  We
+  // use this as the identifier to store data in the sqlite database
+  __id: null,
+  get _id() {
+    if (this.__id) {
+      return this.__id;
+    }
+
+    let leafName = this._getLeafName();
+
+    // Treat engines loaded from JARs the same way we treat app shipped
+    // engines.
+    // Theoretically, these could also come from extensions, but there's no
+    // real way for extensions to register their chrome locations at the
+    // moment, so let's not deal with that case.
+    // This means we're vulnerable to conflicts if a file loaded from a JAR
+    // has the same filename as a file loaded from the app dir, but with a
+    // different engine name. People using the JAR functionality should be
+    // careful not to do that!
+    if (this._isInAppDir || this._isInJAR) {
+      // App dir and JAR engines should always have leafNames
+      ENSURE_WARN(leafName, "_id: no leafName for appDir or JAR engine",
+                  Cr.NS_ERROR_UNEXPECTED);
+      return this.__id = "[app]/" + leafName;
+    }
+
+    if (this._isInProfile) {
+      ENSURE_WARN(leafName, "_id: no leafName for profile engine",
+                  Cr.NS_ERROR_UNEXPECTED);
+      return this.__id = "[profile]/" + leafName;
+    }
+
+    // If the engine isn't a JAR engine, it should have a file.
+    ENSURE_WARN(this._file, "_id: no _file for non-JAR engine",
+                Cr.NS_ERROR_UNEXPECTED);
+
+    // We're not in the profile or appdir, so this must be an extension-shipped
+    // plugin. Use the full filename.
+    return this.__id = this._file.path;
+  },
+
+  // This indicates where we found the .xml file to load the engine,
+  // and attempts to hide user-identifiable data (such as username).
+  get _anonymizedLoadPath() {
+    /* Examples of expected output:
+     *   jar:[app]/omni.ja!browser/engine.xml
+     *     'browser' here is the name of the chrome package, not a folder.
+     *   [profile]/searchplugins/engine.xml
+     *   [distribution]/searchplugins/common/engine.xml
+     *   [other]/engine.xml
+     */
+
+    let leafName = this._getLeafName();
+    if (!leafName)
+      return "null";
+
+    let prefix = "", suffix = "";
+    let file = this._file;
+    if (!file) {
+      let uri = this._uri;
+      if (uri.schemeIs("resource")) {
+        uri = makeURI(Services.io.getProtocolHandler("resource")
+                              .QueryInterface(Ci.nsISubstitutingProtocolHandler)
+                              .resolveURI(uri));
+      }
+      if (uri.schemeIs("chrome")) {
+        let packageName = uri.hostPort;
+        uri = gChromeReg.convertChromeURL(uri);
+        if (uri instanceof Ci.nsINestedURI) {
+          prefix = "jar:";
+          suffix = "!" + packageName + "/" + leafName;
+          uri = uri.innermostURI;
+        }
+        uri.QueryInterface(Ci.nsIFileURL)
+        file = uri.file;
+      } else {
+        return "[" + uri.scheme + "]/" + leafName;
+      }
+    }
+
+    let id;
+    let enginePath = file.path;
+
+    const NS_XPCOM_CURRENT_PROCESS_DIR = "XCurProcD";
+    const NS_APP_USER_PROFILE_50_DIR = "ProfD";
+    const XRE_APP_DISTRIBUTION_DIR = "XREAppDist";
+
+    const knownDirs = {
+      app: NS_XPCOM_CURRENT_PROCESS_DIR,
+      profile: NS_APP_USER_PROFILE_50_DIR,
+      distribution: XRE_APP_DISTRIBUTION_DIR
+    };
+
+    for (let key in knownDirs) {
+      let path;
+      try {
+        path = getDir(knownDirs[key]).path;
+      } catch(e) {
+        // Getting XRE_APP_DISTRIBUTION_DIR throws during unit tests.
+        continue;
+      }
+      if (enginePath.startsWith(path)) {
+        id = "[" + key + "]" + enginePath.slice(path.length).replace(/\\/g, "/");
+        break;
+      }
+    }
+
+    // If the folder doesn't have a known ancestor, don't record its path to
+    // avoid leaking user identifiable data.
+    if (!id)
+      id = "[other]/" + file.leafName;
+
+    return prefix + id + suffix;
+  },
+
+  get _installLocation() {
+    if (this.__installLocation === null) {
+      if (!this._file) {
+        ENSURE_WARN(this._uri, "Engines without files must have URIs",
+                    Cr.NS_ERROR_UNEXPECTED);
+        this.__installLocation = SEARCH_JAR;
+      }
+      else if (this._file.parent.equals(getDir(NS_APP_SEARCH_DIR)))
+        this.__installLocation = SEARCH_APP_DIR;
+      else if (this._file.parent.equals(getDir(NS_APP_USER_SEARCH_DIR)))
+        this.__installLocation = SEARCH_PROFILE_DIR;
+      else
+        this.__installLocation = SEARCH_IN_EXTENSION;
+    }
+
+    return this.__installLocation;
+  },
+
+  get _isInJAR() {
+    return this._installLocation == SEARCH_JAR;
+  },
+  get _isInAppDir() {
+    return this._installLocation == SEARCH_APP_DIR;
+  },
+  get _isInProfile() {
+    return this._installLocation == SEARCH_PROFILE_DIR;
+  },
+
+  get _isDefault() {
+    // For now, our concept of a "default engine" is "one that is not in the
+    // user's profile directory", which is currently equivalent to "is app- or
+    // extension-shipped".
+    return !this._isInProfile;
+  },
+
+  get _hasUpdates() {
+    // Whether or not the engine has an update URL
+    let selfURL = this._getURLOfType(URLTYPE_OPENSEARCH, "self");
+    return !!(this._updateURL || this._iconUpdateURL || selfURL);
+  },
+
+  get name() {
+    return this._name;
+  },
+
+  get searchForm() {
+    return this._getSearchFormWithPurpose();
+  },
+
+  _getSearchFormWithPurpose(aPurpose = "") {
+    // First look for a <Url rel="searchform">
+    var searchFormURL = this._getURLOfType(URLTYPE_SEARCH_HTML, "searchform");
+    if (searchFormURL) {
+      let submission = searchFormURL.getSubmission("", this, aPurpose);
+
+      // If the rel=searchform URL is not type="get" (i.e. has postData),
+      // ignore it, since we can only return a URL.
+      if (!submission.postData)
+        return submission.uri.spec;
+    }
+
+    if (!this._searchForm) {
+      // No SearchForm specified in the engine definition file, use the prePath
+      // (e.g. https://foo.com for https://foo.com/search.php?q=bar).
+      var htmlUrl = this._getURLOfType(URLTYPE_SEARCH_HTML);
+      ENSURE_WARN(htmlUrl, "Engine has no HTML URL!", Cr.NS_ERROR_UNEXPECTED);
+      this._searchForm = makeURI(htmlUrl.template).prePath;
+    }
+
+    return ParamSubstitution(this._searchForm, "", this);
+  },
+
+  get queryCharset() {
+    if (this._queryCharset)
+      return this._queryCharset;
+    return this._queryCharset = "windows-1252"; // the default
+  },
+
+  // from nsISearchEngine
+  addParam: function SRCH_ENG_addParam(aName, aValue, aResponseType) {
+    if (!aName || (aValue == null))
+      FAIL("missing name or value for nsISearchEngine::addParam!");
+    ENSURE_WARN(!this._readOnly,
+                "called nsISearchEngine::addParam on a read-only engine!",
+                Cr.NS_ERROR_FAILURE);
+    if (!aResponseType)
+      aResponseType = URLTYPE_SEARCH_HTML;
+
+    var url = this._getURLOfType(aResponseType);
+    if (!url)
+      FAIL("Engine object has no URL for response type " + aResponseType,
+           Cr.NS_ERROR_FAILURE);
+
+    url.addParam(aName, aValue);
+
+    // Serialize the changes to file lazily
+    this.lazySerializeTask.arm();
+  },
+
+#ifdef ANDROID
+  get _defaultMobileResponseType() {
+    let type = URLTYPE_SEARCH_HTML;
+
+    let sysInfo = Cc["@mozilla.org/system-info;1"].getService(Ci.nsIPropertyBag2);
+    let isTablet = sysInfo.get("tablet");
+    if (isTablet && this.supportsResponseType("application/x-moz-tabletsearch")) {
+      // Check for a tablet-specific search URL override
+      type = "application/x-moz-tabletsearch";
+    } else if (!isTablet && this.supportsResponseType("application/x-moz-phonesearch")) {
+      // Check for a phone-specific search URL override
+      type = "application/x-moz-phonesearch";
+    }
+
+    delete this._defaultMobileResponseType;
+    return this._defaultMobileResponseType = type;
+  },
+#endif
+
+  // from nsISearchEngine
+  getSubmission: function SRCH_ENG_getSubmission(aData, aResponseType, aPurpose) {
+#ifdef ANDROID
+    if (!aResponseType) {
+      aResponseType = this._defaultMobileResponseType;
+    }
+#endif
+    if (!aResponseType) {
+      aResponseType = URLTYPE_SEARCH_HTML;
+    }
+
+    var url = this._getURLOfType(aResponseType);
+
+    if (!url)
+      return null;
+
+    if (!aData) {
+      // Return a dummy submission object with our searchForm attribute
+      return new Submission(makeURI(this._getSearchFormWithPurpose(aPurpose)), null);
+    }
+
+    LOG("getSubmission: In data: \"" + aData + "\"; Purpose: \"" + aPurpose + "\"");
+    var data = "";
+    try {
+      data = gTextToSubURI.ConvertAndEscape(this.queryCharset, aData);
+    } catch (ex) {
+      LOG("getSubmission: Falling back to default queryCharset!");
+      data = gTextToSubURI.ConvertAndEscape(DEFAULT_QUERY_CHARSET, aData);
+    }
+    LOG("getSubmission: Out data: \"" + data + "\"");
+    return url.getSubmission(data, this, aPurpose);
+  },
+
+  // from nsISearchEngine
+  supportsResponseType: function SRCH_ENG_supportsResponseType(type) {
+    return (this._getURLOfType(type) != null);
+  },
+
+  // from nsISearchEngine
+  getResultDomain: function SRCH_ENG_getResultDomain(aResponseType) {
+#ifdef ANDROID
+    if (!aResponseType) {
+      aResponseType = this._defaultMobileResponseType;
+    }
+#endif
+    if (!aResponseType) {
+      aResponseType = URLTYPE_SEARCH_HTML;
+    }
+
+    LOG("getResultDomain: responseType: \"" + aResponseType + "\"");
+
+    let url = this._getURLOfType(aResponseType);
+    if (url)
+      return url.resultDomain;
+    return "";
+  },
+
+  /**
+   * Returns URL parsing properties used by _buildParseSubmissionMap.
+   */
+  getURLParsingInfo: function () {
+#ifdef ANDROID
+    let responseType = this._defaultMobileResponseType;
+#else
+    let responseType = URLTYPE_SEARCH_HTML;
+#endif
+
+    LOG("getURLParsingInfo: responseType: \"" + responseType + "\"");
+
+    let url = this._getURLOfType(responseType);
+    if (!url || url.method != "GET") {
+      return null;
+    }
+
+    let termsParameterName = url._getTermsParameterName();
+    if (!termsParameterName) {
+      return null;
+    }
+
+    let templateUrl = NetUtil.newURI(url.template).QueryInterface(Ci.nsIURL);
+    return {
+      mainDomain: templateUrl.host,
+      path: templateUrl.filePath.toLowerCase(),
+      termsParameterName: termsParameterName,
+    };
+  },
+
+  // nsISupports
+  QueryInterface: function SRCH_ENG_QI(aIID) {
+    if (aIID.equals(Ci.nsISearchEngine) ||
+        aIID.equals(Ci.nsISupports))
+      return this;
+    throw Cr.NS_ERROR_NO_INTERFACE;
+  },
+
+  get wrappedJSObject() {
+    return this;
+  },
+
+  /**
+   * Returns a string with the URL to an engine's icon matching both width and
+   * height. Returns null if icon with specified dimensions is not found.
+   *
+   * @param width
+   *        Width of the requested icon.
+   * @param height
+   *        Height of the requested icon.
+   */
+  getIconURLBySize: function SRCH_ENG_getIconURLBySize(aWidth, aHeight) {
+    if (!this._iconMapObj)
+      return null;
+
+    let key = this._getIconKey(aWidth, aHeight);
+    if (key in this._iconMapObj) {
+      return this._iconMapObj[key];
+    }
+    return null;
+  },
+
+  /**
+   * Gets an array of all available icons. Each entry is an object with
+   * width, height and url properties. width and height are numeric and
+   * represent the icon's dimensions. url is a string with the URL for
+   * the icon.
+   */
+  getIcons: function SRCH_ENG_getIcons() {
+    let result = [];
+
+    if (!this._iconMapObj)
+      return result;
+
+    for (let key of Object.keys(this._iconMapObj)) {
+      let iconSize = JSON.parse(key);
+      result.push({
+        width: iconSize.width,
+        height: iconSize.height,
+        url: this._iconMapObj[key]
+      });
+    }
+
+    return result;
+  },
+
+  /**
+   * Opens a speculative connection to the engine's search URI
+   * (and suggest URI, if different) to reduce request latency
+   *
+   * @param  options
+   *         An object that must contain the following fields:
+   *         {window} the content window for the window performing the search
+   *
+   * @throws NS_ERROR_INVALID_ARG if options is omitted or lacks required
+   *         elemeents
+   */
+  speculativeConnect: function SRCH_ENG_speculativeConnect(options) {
+    if (!options || !options.window) {
+      Cu.reportError("invalid options arg passed to nsISearchEngine.speculativeConnect");
+      throw Cr.NS_ERROR_INVALID_ARG;
+    }
+    let connector =
+        Services.io.QueryInterface(Components.interfaces.nsISpeculativeConnect);
+
+    let searchURI = this.getSubmission("dummy").uri;
+
+    let callbacks = options.window.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
+                           .getInterface(Components.interfaces.nsIWebNavigation)
+                           .QueryInterface(Components.interfaces.nsILoadContext);
+
+    connector.speculativeConnect(searchURI, callbacks);
+
+    if (this.supportsResponseType(URLTYPE_SUGGEST_JSON)) {
+      let suggestURI = this.getSubmission("dummy", URLTYPE_SUGGEST_JSON).uri;
+      if (suggestURI.prePath != searchURI.prePath)
+        connector.speculativeConnect(suggestURI, callbacks);
+    }
+  },
+};
+
+// nsISearchSubmission
+function Submission(aURI, aPostData = null) {
+  this._uri = aURI;
+  this._postData = aPostData;
+}
+Submission.prototype = {
+  get uri() {
+    return this._uri;
+  },
+  get postData() {
+    return this._postData;
+  },
+  QueryInterface: function SRCH_SUBM_QI(aIID) {
+    if (aIID.equals(Ci.nsISearchSubmission) ||
+        aIID.equals(Ci.nsISupports))
+      return this;
+    throw Cr.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+// nsISearchParseSubmissionResult
+function ParseSubmissionResult(aEngine, aTerms, aTermsOffset, aTermsLength) {
+  this._engine = aEngine;
+  this._terms = aTerms;
+  this._termsOffset = aTermsOffset;
+  this._termsLength = aTermsLength;
+}
+ParseSubmissionResult.prototype = {
+  get engine() {
+    return this._engine;
+  },
+  get terms() {
+    return this._terms;
+  },
+  get termsOffset() {
+    return this._termsOffset;
+  },
+  get termsLength() {
+    return this._termsLength;
+  },
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsISearchParseSubmissionResult]),
+}
+
+const gEmptyParseSubmissionResult =
+      Object.freeze(new ParseSubmissionResult(null, "", -1, 0));
+
+function executeSoon(func) {
+  Services.tm.mainThread.dispatch(func, Ci.nsIThread.DISPATCH_NORMAL);
+}
+
+/**
+ * Check for sync initialization has completed or not.
+ *
+ * @param {aPromise} A promise.
+ *
+ * @returns the value returned by the invoked method.
+ * @throws NS_ERROR_ALREADY_INITIALIZED if sync initialization has completed.
+ */
+function checkForSyncCompletion(aPromise) {
+  return aPromise.then(function(aValue) {
+    if (gInitialized) {
+      throw Components.Exception("Synchronous fallback was called and has " +
+                                 "finished so no need to pursue asynchronous " +
+                                 "initialization",
+                                 Cr.NS_ERROR_ALREADY_INITIALIZED);
+    }
+    return aValue;
+  });
+}
+
+// nsIBrowserSearchService
+function SearchService() {
+  // Replace empty LOG function with the useful one if the log pref is set.
+  if (getBoolPref(BROWSER_SEARCH_PREF + "log", false))
+    LOG = DO_LOG;
+
+  this._initObservers = Promise.defer();
+}
+
+SearchService.prototype = {
+  classID: Components.ID("{7319788a-fe93-4db3-9f39-818cf08f4256}"),
+
+  // The current status of initialization. Note that it does not determine if
+  // initialization is complete, only if an error has been encountered so far.
+  _initRV: Cr.NS_OK,
+
+  // The boolean indicates that the initialization has started or not.
+  _initStarted: null,
+
+  // If initialization has not been completed yet, perform synchronous
+  // initialization.
+  // Throws in case of initialization error.
+  _ensureInitialized: function  SRCH_SVC__ensureInitialized() {
+    if (gInitialized) {
+      if (!Components.isSuccessCode(this._initRV)) {
+        LOG("_ensureInitialized: failure");
+        throw this._initRV;
+      }
+      return;
+    }
+
+    let warning =
+      "Search service falling back to synchronous initialization. " +
+      "This is generally the consequence of an add-on using a deprecated " +
+      "search service API.";
+    Deprecated.warning(warning, "https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIBrowserSearchService#async_warning");
+    LOG(warning);
+
+    engineMetadataService.syncInit();
+    this._syncInit();
+    if (!Components.isSuccessCode(this._initRV)) {
+      throw this._initRV;
+    }
+  },
+
+  // Synchronous implementation of the initializer.
+  // Used by |_ensureInitialized| as a fallback if initialization is not
+  // complete.
+  _syncInit: function SRCH_SVC__syncInit() {
+    LOG("_syncInit start");
+    this._initStarted = true;
+    migrateRegionPrefs();
+    try {
+      this._syncLoadEngines();
+    } catch (ex) {
+      this._initRV = Cr.NS_ERROR_FAILURE;
+      LOG("_syncInit: failure loading engines: " + ex);
+    }
+    this._addObservers();
+
+    gInitialized = true;
+
+    this._initObservers.resolve(this._initRV);
+
+    Services.obs.notifyObservers(null, SEARCH_SERVICE_TOPIC, "init-complete");
+
+    LOG("_syncInit end");
+  },
+
+  /**
+   * Asynchronous implementation of the initializer.
+   *
+   * @returns {Promise} A promise, resolved successfully if the initialization
+   * succeeds.
+   */
+  _asyncInit: function SRCH_SVC__asyncInit() {
+    migrateRegionPrefs();
+    return Task.spawn(function() {
+      LOG("_asyncInit start");
+      try {
+        yield checkForSyncCompletion(ensureKnownCountryCode());
+      } catch (ex if ex.result != Cr.NS_ERROR_ALREADY_INITIALIZED) {
+        LOG("_asyncInit: failure determining country code: " + ex);
+      }
+      try {
+        yield checkForSyncCompletion(this._asyncLoadEngines());
+      } catch (ex if ex.result != Cr.NS_ERROR_ALREADY_INITIALIZED) {
+        this._initRV = Cr.NS_ERROR_FAILURE;
+        LOG("_asyncInit: failure loading engines: " + ex);
+      }
+      this._addObservers();
+      gInitialized = true;
+      this._initObservers.resolve(this._initRV);
+      Services.obs.notifyObservers(null, SEARCH_SERVICE_TOPIC, "init-complete");
+
+      LOG("_asyncInit: Completed _asyncInit");
+    }.bind(this));
+  },
+
+
+  _engines: { },
+  __sortedEngines: null,
+  _visibleDefaultEngines: [],
+  get _sortedEngines() {
+    if (!this.__sortedEngines)
+      return this._buildSortedEngineList();
+    return this.__sortedEngines;
+  },
+
+  // Get the original Engine object that is the default for this region,
+  // ignoring changes the user may have subsequently made.
+  get _originalDefaultEngine() {
+    let defaultEngine = engineMetadataService.getGlobalAttr("searchDefault");
+    if (defaultEngine &&
+        engineMetadataService.getGlobalAttr("searchDefaultHash") != getVerificationHash(defaultEngine)) {
+      LOG("get _originalDefaultEngine, invalid searchDefaultHash for: " + defaultEngine);
+      defaultEngine = "";
+    }
+
+    if (!defaultEngine) {
+      let defaultPrefB = Services.prefs.getDefaultBranch(BROWSER_SEARCH_PREF);
+      let nsIPLS = Ci.nsIPrefLocalizedString;
+
+      let defPref = getGeoSpecificPrefName("defaultenginename");
+      try {
+        defaultEngine = defaultPrefB.getComplexValue(defPref, nsIPLS).data;
+      } catch (ex) {
+        // If the default pref is invalid (e.g. an add-on set it to a bogus value)
+        // getEngineByName will just return null, which is the best we can do.
+      }
+    }
+
+    return this.getEngineByName(defaultEngine);
+  },
+
+  resetToOriginalDefaultEngine: function SRCH_SVC__resetToOriginalDefaultEngine() {
+    this.currentEngine = this._originalDefaultEngine;
+  },
+
+  _buildCache: function SRCH_SVC__buildCache() {
+    let cache = {};
+    let locale = getLocale();
+    let buildID = Services.appinfo.platformBuildID;
+
+    // Allows us to force a cache refresh should the cache format change.
+    cache.version = CACHE_VERSION;
+    // We don't want to incur the costs of stat()ing each plugin on every
+    // startup when the only (supported) time they will change is during
+    // runtime (where we refresh for changes through the API) and app updates
+    // (where the buildID is obviously going to change).
+    // Extension-shipped plugins are the only exception to this, but their
+    // directories are blown away during updates, so we'll detect their changes.
+    cache.buildID = buildID;
+    cache.locale = locale;
+
+    cache.directories = {};
+    cache.visibleDefaultEngines = this._visibleDefaultEngines;
+
+    let getParent = engine => {
+      if (engine._file)
+        return engine._file.parent;
+
+      let uri = engine._uri;
+      if (!uri.schemeIs("resource")) {
+        LOG("getParent: engine URI must be a resource URI if it has no file");
+        return null;
+      }
+
+      // use the underlying JAR file, for resource URIs
+      let chan = makeChannel(uri.spec);
+      if (chan)
+        return this._convertChannelToFile(chan);
+
+      LOG("getParent: couldn't map resource:// URI to a file");
+      return null;
+    };
+
+    for (let name in this._engines) {
+      let engine = this._engines[name];
+      let parent = getParent(engine);
+      if (!parent) {
+        LOG("Error: no parent for engine " + engine._location + ", failing to cache it");
+
+        continue;
+      }
+
+      let cacheKey = parent.path;
+      if (!cache.directories[cacheKey]) {
+        let cacheEntry = {};
+        cacheEntry.lastModifiedTime = parent.lastModifiedTime;
+        cacheEntry.engines = [];
+        cache.directories[cacheKey] = cacheEntry;
+      }
+      cache.directories[cacheKey].engines.push(engine);
+    }
+
+    try {
+      LOG("_buildCache: Writing to cache file.");
+      let path = OS.Path.join(OS.Constants.Path.profileDir, "search.json");
+      let data = gEncoder.encode(JSON.stringify(cache));
+      let promise = OS.File.writeAtomic(path, data, { tmpPath: path + ".tmp"});
+
+      promise.then(
+        function onSuccess() {
+          Services.obs.notifyObservers(null, SEARCH_SERVICE_TOPIC, SEARCH_SERVICE_CACHE_WRITTEN);
+        },
+        function onError(e) {
+          LOG("_buildCache: failure during writeAtomic: " + e);
+        }
+      );
+    } catch (ex) {
+      LOG("_buildCache: Could not write to cache file: " + ex);
+    }
+  },
+
+  _syncLoadEngines: function SRCH_SVC__syncLoadEngines() {
+    LOG("_syncLoadEngines: start");
+    // See if we have a cache file so we don't have to parse a bunch of XML.
+    let cache = {};
+    let cacheFile = getDir(NS_APP_USER_PROFILE_50_DIR);
+    cacheFile.append("search.json");
+    if (cacheFile.exists())
+      cache = this._readCacheFile(cacheFile);
+
+    let [chromeFiles, chromeURIs] = this._findJAREngines();
+
+    let distDirs = [];
+    let locations;
+    try {
+      locations = getDir(NS_APP_DISTRIBUTION_SEARCH_DIR_LIST,
+                         Ci.nsISimpleEnumerator);
+    } catch (e) {
+      // NS_APP_DISTRIBUTION_SEARCH_DIR_LIST is defined by each app
+      // so this throws during unit tests (but not xpcshell tests).
+      locations = {hasMoreElements: () => false};
+    }
+    while (locations.hasMoreElements()) {
+      let dir = locations.getNext().QueryInterface(Ci.nsIFile);
+      if (dir.directoryEntries.hasMoreElements())
+        distDirs.push(dir);
+    }
+
+    let otherDirs = [];
+    locations = getDir(NS_APP_SEARCH_DIR_LIST, Ci.nsISimpleEnumerator);
+    while (locations.hasMoreElements()) {
+      let dir = locations.getNext().QueryInterface(Ci.nsIFile);
+      if (dir.directoryEntries.hasMoreElements())
+        otherDirs.push(dir);
+    }
+
+    let toLoad = chromeFiles.concat(distDirs, otherDirs);
+
+    function modifiedDir(aDir) {
+      return (!cache.directories || !cache.directories[aDir.path] ||
+              cache.directories[aDir.path].lastModifiedTime != aDir.lastModifiedTime);
+    }
+
+    function notInCachePath(aPathToLoad) {
+      return cachePaths.indexOf(aPathToLoad.path) == -1;
+    }
+    function notInCacheVisibleEngines(aEngineName) {
+      return cache.visibleDefaultEngines.indexOf(aEngineName) == -1;
+    }
+
+    let buildID = Services.appinfo.platformBuildID;
+    // Gecko44: let cachePaths = [path for (path in cache.directories)];
+    let cachePaths = [];
+    for (path in cache.directories) {
+      cachePaths.push(path);
+    }
+    
+
+    let rebuildCache = !cache.directories ||
+                       cache.version != CACHE_VERSION ||
+                       cache.locale != getLocale() ||
+                       cache.buildID != buildID ||
+                       cachePaths.length != toLoad.length ||
+                       toLoad.some(notInCachePath) ||
+                       cache.visibleDefaultEngines.length != this._visibleDefaultEngines.length ||
+                       this._visibleDefaultEngines.some(notInCacheVisibleEngines) ||
+                       toLoad.some(modifiedDir);
+
+    if (rebuildCache) {
+      LOG("_loadEngines: Absent or outdated cache. Loading engines from disk.");
+      distDirs.forEach(this._loadEnginesFromDir, this);
+
+      this._loadFromChromeURLs(chromeURIs);
+
+      otherDirs.forEach(this._loadEnginesFromDir, this);
+
+      this._buildCache();
+      return;
+    }
+
+    LOG("_loadEngines: loading from cache directories");
+    for (let cacheKey in cache.directories) {
+      let dir = cache.directories[cacheKey];
+      this._loadEnginesFromCache(dir);
+    }
+
+    LOG("_loadEngines: done");
+  },
+
+  /**
+   * Loads engines asynchronously.
+   *
+   * @returns {Promise} A promise, resolved successfully if loading data
+   * succeeds.
+   */
+  _asyncLoadEngines: function SRCH_SVC__asyncLoadEngines() {
+    return Task.spawn(function() {
+      LOG("_asyncLoadEngines: start");
+      // See if we have a cache file so we don't have to parse a bunch of XML.
+      let cache = {};
+      let cacheFilePath = OS.Path.join(OS.Constants.Path.profileDir, "search.json");
+      cache = yield checkForSyncCompletion(this._asyncReadCacheFile(cacheFilePath));
+
+      Services.obs.notifyObservers(null, SEARCH_SERVICE_TOPIC, "find-jar-engines");
+      let [chromeFiles, chromeURIs] =
+        yield checkForSyncCompletion(this._asyncFindJAREngines());
+
+      // Get the non-empty distribution directories into distDirs...
+      let distDirs = [];
+      let locations;
+      try {
+        locations = getDir(NS_APP_DISTRIBUTION_SEARCH_DIR_LIST,
+                           Ci.nsISimpleEnumerator);
+      } catch (e) {
+        // NS_APP_DISTRIBUTION_SEARCH_DIR_LIST is defined by each app
+        // so this throws during unit tests (but not xpcshell tests).
+        locations = {hasMoreElements: () => false};
+      }
+      while (locations.hasMoreElements()) {
+        let dir = locations.getNext().QueryInterface(Ci.nsIFile);
+        let iterator = new OS.File.DirectoryIterator(dir.path,
+                                                     { winPattern: "*.xml" });
+        try {
+          // Add dir to distDirs if it contains any files.
+          yield checkForSyncCompletion(iterator.next());
+          distDirs.push(dir);
+        } catch (ex if ex.result != Cr.NS_ERROR_ALREADY_INITIALIZED) {
+          // Catch for StopIteration exception.
+        } finally {
+          iterator.close();
+        }
+      }
+
+      // Add the non-empty directories of NS_APP_SEARCH_DIR_LIST to
+      // otherDirs...
+      let otherDirs = [];
+      locations = getDir(NS_APP_SEARCH_DIR_LIST, Ci.nsISimpleEnumerator);
+      while (locations.hasMoreElements()) {
+        let dir = locations.getNext().QueryInterface(Ci.nsIFile);
+        let iterator = new OS.File.DirectoryIterator(dir.path,
+                                                     { winPattern: "*.xml" });
+        try {
+          // Add dir to otherDirs if it contains any files.
+          yield checkForSyncCompletion(iterator.next());
+          otherDirs.push(dir);
+        } catch (ex if ex.result != Cr.NS_ERROR_ALREADY_INITIALIZED) {
+          // Catch for StopIteration exception.
+        } finally {
+          iterator.close();
+        }
+      }
+
+      let toLoad = chromeFiles.concat(distDirs, otherDirs);
+      function hasModifiedDir(aList) {
+        return Task.spawn(function() {
+          let modifiedDir = false;
+
+          for (let dir of aList) {
+            if (!cache.directories || !cache.directories[dir.path]) {
+              modifiedDir = true;
+              break;
+            }
+
+            let info = yield OS.File.stat(dir.path);
+            if (cache.directories[dir.path].lastModifiedTime !=
+                info.lastModificationDate.getTime()) {
+              modifiedDir = true;
+              break;
+            }
+          }
+          throw new Task.Result(modifiedDir);
+        });
+      }
+
+      function notInCachePath(aPathToLoad) {
+        return cachePaths.indexOf(aPathToLoad.path) == -1;
+      }
+      function notInCacheVisibleEngines(aEngineName) {
+        return cache.visibleDefaultEngines.indexOf(aEngineName) == -1;
+      }
+
+      let buildID = Services.appinfo.platformBuildID;
+      // Gecko44: let cachePaths = [path for (path in cache.directories)];
+      let cachePaths = [];
+      for (path in cache.directories) {
+        cachePaths.push(path);
+      }
+
+      let rebuildCache = !cache.directories ||
+                         cache.version != CACHE_VERSION ||
+                         cache.locale != getLocale() ||
+                         cache.buildID != buildID ||
+                         cachePaths.length != toLoad.length ||
+                         toLoad.some(notInCachePath) ||
+                         cache.visibleDefaultEngines.length != this._visibleDefaultEngines.length ||
+                         this._visibleDefaultEngines.some(notInCacheVisibleEngines) ||
+                         (yield checkForSyncCompletion(hasModifiedDir(toLoad)));
+
+      if (rebuildCache) {
+        LOG("_asyncLoadEngines: Absent or outdated cache. Loading engines from disk.");
+        let engines = [];
+        for (let loadDir of distDirs) {
+          let enginesFromDir =
+            yield checkForSyncCompletion(this._asyncLoadEnginesFromDir(loadDir));
+          engines = engines.concat(enginesFromDir);
+        }
+        let enginesFromURLs =
+           yield checkForSyncCompletion(this._asyncLoadFromChromeURLs(chromeURIs));
+        engines = engines.concat(enginesFromURLs);
+        for (let loadDir of otherDirs) {
+          let enginesFromDir =
+            yield checkForSyncCompletion(this._asyncLoadEnginesFromDir(loadDir));
+          engines = engines.concat(enginesFromDir);
+        }
+
+        for (let engine of engines) {
+          this._addEngineToStore(engine);
+        }
+        this._buildCache();
+        return;
+      }
+
+      LOG("_asyncLoadEngines: loading from cache directories");
+      for (let cacheKey in cache.directories) {
+        let dir = cache.directories[cacheKey];
+        this._loadEnginesFromCache(dir);
+      }
+
+      LOG("_asyncLoadEngines: done");
+    }.bind(this));
+  },
+
+  _asyncReInit: function () {
+    LOG("_asyncReInit");
+    // Start by clearing the initialized state, so we don't abort early.
+    gInitialized = false;
+
+    // Clear the engines, too, so we don't stick with the stale ones.
+    this._engines = {};
+    this.__sortedEngines = null;
+    this._currentEngine = null;
+    this._defaultEngine = null;
+    this._visibleDefaultEngines = [];
+
+    // Clear the metadata service.
+    engineMetadataService._initialized = false;
+    engineMetadataService._initializer = null;
+
+    Task.spawn(function* () {
+      try {
+        LOG("Restarting engineMetadataService");
+        yield engineMetadataService.init();
+        yield ensureKnownCountryCode();
+
+        // Due to the HTTP requests done by ensureKnownCountryCode, it's possible that
+        // at this point a synchronous init has been forced by other code.
+        if (!gInitialized)
+          yield this._asyncLoadEngines();
+
+        // Typically we'll re-init as a result of a pref observer,
+        // so signal to 'callers' that we're done.
+        Services.obs.notifyObservers(null, SEARCH_SERVICE_TOPIC, "reinit-complete");
+        gInitialized = true;
+      } catch (err) {
+        LOG("Reinit failed: " + err);
+        Services.obs.notifyObservers(null, SEARCH_SERVICE_TOPIC, "reinit-failed");
+      }
+    }.bind(this));
+  },
+
+  _readCacheFile: function SRCH_SVC__readCacheFile(aFile) {
+    let stream = Cc["@mozilla.org/network/file-input-stream;1"].
+                 createInstance(Ci.nsIFileInputStream);
+    let json = Cc["@mozilla.org/dom/json;1"].createInstance(Ci.nsIJSON);
+
+    try {
+      stream.init(aFile, MODE_RDONLY, FileUtils.PERMS_FILE, 0);
+      return json.decodeFromStream(stream, stream.available());
+    } catch (ex) {
+      LOG("_readCacheFile: Error reading cache file: " + ex);
+    } finally {
+      stream.close();
+    }
+    return false;
+  },
+
+  /**
+   * Read from a given cache file asynchronously.
+   *
+   * @param aPath the file path.
+   *
+   * @returns {Promise} A promise, resolved successfully if retrieveing data
+   * succeeds.
+   */
+  _asyncReadCacheFile: function SRCH_SVC__asyncReadCacheFile(aPath) {
+    return Task.spawn(function() {
+      let json;
+      try {
+        let bytes = yield OS.File.read(aPath);
+        json = JSON.parse(new TextDecoder().decode(bytes));
+      } catch (ex) {
+        LOG("_asyncReadCacheFile: Error reading cache file: " + ex);
+        json = {};
+      }
+      throw new Task.Result(json);
+    });
+  },
+
+  _batchTask: null,
+  get batchTask() {
+    if (!this._batchTask) {
+      let task = function taskCallback() {
+        LOG("batchTask: Invalidating engine cache");
+        this._buildCache();
+      }.bind(this);
+      this._batchTask = new DeferredTask(task, CACHE_INVALIDATION_DELAY);
+    }
+    return this._batchTask;
+  },
+
+  _addEngineToStore: function SRCH_SVC_addEngineToStore(aEngine) {
+    LOG("_addEngineToStore: Adding engine: \"" + aEngine.name + "\"");
+
+    // See if there is an existing engine with the same name. However, if this
+    // engine is updating another engine, it's allowed to have the same name.
+    var hasSameNameAsUpdate = (aEngine._engineToUpdate &&
+                               aEngine.name == aEngine._engineToUpdate.name);
+    if (aEngine.name in this._engines && !hasSameNameAsUpdate) {
+      LOG("_addEngineToStore: Duplicate engine found, aborting!");
+      return;
+    }
+
+    if (aEngine._engineToUpdate) {
+      // We need to replace engineToUpdate with the engine that just loaded.
+      var oldEngine = aEngine._engineToUpdate;
+
+      // Remove the old engine from the hash, since it's keyed by name, and our
+      // name might change (the update might have a new name).
+      delete this._engines[oldEngine.name];
+
+      // Hack: we want to replace the old engine with the new one, but since
+      // people may be holding refs to the nsISearchEngine objects themselves,
+      // we'll just copy over all "private" properties (those without a getter
+      // or setter) from one object to the other.
+      for (var p in aEngine) {
+        if (!(aEngine.__lookupGetter__(p) || aEngine.__lookupSetter__(p)))
+          oldEngine[p] = aEngine[p];
+      }
+      aEngine = oldEngine;
+      aEngine._engineToUpdate = null;
+
+      // Add the engine back
+      this._engines[aEngine.name] = aEngine;
+      notifyAction(aEngine, SEARCH_ENGINE_CHANGED);
+    } else {
+      // Not an update, just add the new engine.
+      this._engines[aEngine.name] = aEngine;
+      // Only add the engine to the list of sorted engines if the initial list
+      // has already been built (i.e. if this.__sortedEngines is non-null). If
+      // it hasn't, we're loading engines from disk and the sorted engine list
+      // will be built once we need it.
+      if (this.__sortedEngines) {
+        this.__sortedEngines.push(aEngine);
+        this._saveSortedEngineList();
+      }
+      notifyAction(aEngine, SEARCH_ENGINE_ADDED);
+    }
+
+    if (aEngine._hasUpdates) {
+      // Schedule the engine's next update, if it isn't already.
+      if (!engineMetadataService.getAttr(aEngine, "updateexpir"))
+        engineUpdateService.scheduleNextUpdate(aEngine);
+    }
+  },
+
+  _loadEnginesFromCache: function SRCH_SVC__loadEnginesFromCache(aDir) {
+    let engines = aDir.engines;
+    LOG("_loadEnginesFromCache: Loading from cache. " + engines.length + " engines to load.");
+    for (let i = 0; i < engines.length; i++) {
+      let json = engines[i];
+
+      try {
+        let engine;
+        if (json.filePath)
+          engine = new Engine({type: "filePath", value: json.filePath},
+                               json._readOnly);
+        else if (json._url)
+          engine = new Engine({type: "uri", value: json._url}, json._readOnly);
+
+        engine._initWithJSON(json);
+        this._addEngineToStore(engine);
+      } catch (ex) {
+        LOG("Failed to load " + engines[i]._name + " from cache: " + ex);
+        LOG("Engine JSON: " + engines[i].toSource());
+      }
+    }
+  },
+
+  _loadEnginesFromDir: function SRCH_SVC__loadEnginesFromDir(aDir) {
+    LOG("_loadEnginesFromDir: Searching in " + aDir.path + " for search engines.");
+
+    // Check whether aDir is the user profile dir
+    var isInProfile = aDir.equals(getDir(NS_APP_USER_SEARCH_DIR));
+
+    var files = aDir.directoryEntries
+                    .QueryInterface(Ci.nsIDirectoryEnumerator);
+
+    while (files.hasMoreElements()) {
+      var file = files.nextFile;
+
+      // Ignore hidden and empty files, and directories
+      if (!file.isFile() || file.fileSize == 0 || file.isHidden())
+        continue;
+
+      var fileURL = NetUtil.ioService.newFileURI(file).QueryInterface(Ci.nsIURL);
+      var fileExtension = fileURL.fileExtension.toLowerCase();
+      var isWritable = isInProfile && file.isWritable();
+
+      if (fileExtension != "xml") {
+        // Not an engine
+        continue;
+      }
+
+      var addedEngine = null;
+      try {
+        addedEngine = new Engine(file, !isWritable);
+        addedEngine._initFromFile();
+      } catch (ex) {
+        LOG("_loadEnginesFromDir: Failed to load " + file.path + "!\n" + ex);
+        continue;
+      }
+
+      this._addEngineToStore(addedEngine);
+    }
+  },
+
+  /**
+   * Loads engines from a given directory asynchronously.
+   *
+   * @param aDir the directory.
+   *
+   * @returns {Promise} A promise, resolved successfully if retrieveing data
+   * succeeds.
+   */
+  _asyncLoadEnginesFromDir: function SRCH_SVC__asyncLoadEnginesFromDir(aDir) {
+    LOG("_asyncLoadEnginesFromDir: Searching in " + aDir.path + " for search engines.");
+
+    // Check whether aDir is the user profile dir
+    let isInProfile = aDir.equals(getDir(NS_APP_USER_SEARCH_DIR));
+    let iterator = new OS.File.DirectoryIterator(aDir.path);
+    return Task.spawn(function() {
+      let osfiles = yield iterator.nextBatch();
+      iterator.close();
+
+      let engines = [];
+      for (let osfile of osfiles) {
+        if (osfile.isDir || osfile.isSymLink)
+          continue;
+
+        let fileInfo = yield OS.File.stat(osfile.path);
+        if (fileInfo.size == 0)
+          continue;
+
+        let parts = osfile.path.split(".");
+        if (parts.length <= 1 || (parts.pop()).toLowerCase() != "xml") {
+          // Not an engine
+          continue;
+        }
+
+        let addedEngine = null;
+        try {
+          let file = new FileUtils.File(osfile.path);
+          let isWritable = isInProfile;
+          addedEngine = new Engine(file, !isWritable);
+          yield checkForSyncCompletion(addedEngine._asyncInitFromFile());
+        } catch (ex if ex.result != Cr.NS_ERROR_ALREADY_INITIALIZED) {
+          LOG("_asyncLoadEnginesFromDir: Failed to load " + osfile.path + "!\n" + ex);
+          continue;
+        }
+        engines.push(addedEngine);
+      }
+      throw new Task.Result(engines);
+    }.bind(this));
+  },
+
+  _loadFromChromeURLs: function SRCH_SVC_loadFromChromeURLs(aURLs) {
+    aURLs.forEach(function (url) {
+      try {
+        LOG("_loadFromChromeURLs: loading engine from chrome url: " + url);
+
+        let engine = new Engine(makeURI(url), true);
+
+        engine._initFromURISync();
+
+        this._addEngineToStore(engine);
+      } catch (ex) {
+        LOG("_loadFromChromeURLs: failed to load engine: " + ex);
+      }
+    }, this);
+  },
+
+  /**
+   * Loads engines from Chrome URLs asynchronously.
+   *
+   * @param aURLs a list of URLs.
+   *
+   * @returns {Promise} A promise, resolved successfully if loading data
+   * succeeds.
+   */
+  _asyncLoadFromChromeURLs: function SRCH_SVC__asyncLoadFromChromeURLs(aURLs) {
+    return Task.spawn(function() {
+      let engines = [];
+      for (let url of aURLs) {
+        try {
+          LOG("_asyncLoadFromChromeURLs: loading engine from chrome url: " + url);
+          let engine = new Engine(NetUtil.newURI(url), true);
+          yield checkForSyncCompletion(engine._asyncInitFromURI());
+          engines.push(engine);
+        } catch (ex if ex.result != Cr.NS_ERROR_ALREADY_INITIALIZED) {
+          LOG("_asyncLoadFromChromeURLs: failed to load engine: " + ex);
+        }
+      }
+      throw new Task.Result(engines);
+    }.bind(this));
+  },
+
+  _convertChannelToFile: function(chan) {
+    let fileURI = chan.URI;
+    while (fileURI instanceof Ci.nsIJARURI)
+      fileURI = fileURI.JARFile;
+    fileURI.QueryInterface(Ci.nsIFileURL);
+
+    return fileURI.file;
+  },
+
+  _findJAREngines: function SRCH_SVC_findJAREngines() {
+    LOG("_findJAREngines: looking for engines in JARs")
+
+    let chan = makeChannel(APP_SEARCH_PREFIX + "list.txt");
+    if (!chan) {
+      LOG("_findJAREngines: " + APP_SEARCH_PREFIX + " isn't registered");
+      return [[], []];
+    }
+
+    let uris = [];
+    let chromeFiles = [];
+
+    // Find the underlying JAR file (_loadEngines uses it to determine
+    // whether it needs to invalidate the cache)
+    let jarPackaging = false;
+    if (chan.URI instanceof Ci.nsIJARURI) {
+      chromeFiles.push(this._convertChannelToFile(chan));
+      jarPackaging = true;
+    }
+
+    let sis = Cc["@mozilla.org/scriptableinputstream;1"].
+                createInstance(Ci.nsIScriptableInputStream);
+    sis.init(chan.open());
+    this._parseListTxt(sis.read(sis.available()), jarPackaging,
+                       chromeFiles, uris);
+    return [chromeFiles, uris];
+  },
+
+  /**
+   * Loads jar engines asynchronously.
+   *
+   * @returns {Promise} A promise, resolved successfully if finding jar engines
+   * succeeds.
+   */
+  _asyncFindJAREngines: function SRCH_SVC__asyncFindJAREngines() {
+    return Task.spawn(function() {
+      LOG("_asyncFindJAREngines: looking for engines in JARs")
+
+      let listURL = APP_SEARCH_PREFIX + "list.txt";
+      let chan = makeChannel(listURL);
+      if (!chan) {
+        LOG("_asyncFindJAREngines: " + APP_SEARCH_PREFIX + " isn't registered");
+        throw new Task.Result([[], []]);
+      }
+
+      let uris = [];
+      let chromeFiles = [];
+
+      // Find the underlying JAR file (_loadEngines uses it to determine
+      // whether it needs to invalidate the cache)
+      let jarPackaging = false;
+      if (chan.URI instanceof Ci.nsIJARURI) {
+        chromeFiles.push(this._convertChannelToFile(chan));
+        jarPackaging = true;
+      }
+
+      // Read list.txt to find the engines we need to load.
+      let deferred = Promise.defer();
+      let request = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].
+                      createInstance(Ci.nsIXMLHttpRequest);
+      request.overrideMimeType("text/plain");
+      request.onload = function(aEvent) {
+        deferred.resolve(aEvent.target.responseText);
+      };
+      request.onerror = function(aEvent) {
+        LOG("_asyncFindJAREngines: failed to read " + listURL);
+        deferred.resolve("");
+      };
+      request.open("GET", NetUtil.newURI(listURL).spec, true);
+      request.send();
+      let list = yield deferred.promise;
+
+      this._parseListTxt(list, jarPackaging, chromeFiles, uris);
+      throw new Task.Result([chromeFiles, uris]);
+    }.bind(this));
+  },
+
+  _parseListTxt: function SRCH_SVC_parseListTxt(list, jarPackaging,
+                                                chromeFiles, uris) {
+    let names = list.split("\n").filter(n => !!n);
+    // This maps the names of our built-in engines to a boolean
+    // indicating whether it should be hidden by default.
+    let jarNames = new Map();
+    for (let name of names) {
+      if (name.endsWith(":hidden")) {
+        name = name.split(":")[0];
+        jarNames.set(name, true);
+      } else {
+        jarNames.set(name, false);
+      }
+    }
+
+    // Check if we have a useable country specific list of visible default engines.
+    let engineNames;
+    let visibleDefaultEngines =
+      engineMetadataService.getGlobalAttr("visibleDefaultEngines");
+    if (visibleDefaultEngines &&
+        engineMetadataService.getGlobalAttr("visibleDefaultEnginesHash") == getVerificationHash(visibleDefaultEngines)) {
+      engineNames = visibleDefaultEngines.split(",");
+
+      for (let engineName of engineNames) {
+        // If all engineName values are part of jarNames,
+        // then we can use the country specific list, otherwise ignore it.
+        // The visibleDefaultEngines string containing the name of an engine we
+        // don't ship indicates the server is misconfigured to answer requests
+        // from the specific Firefox version we are running, so ignoring the
+        // value altogether is safer.
+        if (!jarNames.has(engineName)) {
+          LOG("_parseListTxt: ignoring visibleDefaultEngines value because " +
+              engineName + " is not in the jar engines we have found");
+          engineNames = null;
+          break;
+        }
+      }
+    }
+
+    // Fallback to building a list based on the :hidden suffixes found in list.txt.
+    if (!engineNames) {
+      engineNames = [];
+      for (let [name, hidden] of jarNames) {
+        if (!hidden)
+          engineNames.push(name);
+      }
+    }
+
+    for (let name of engineNames) {
+      let uri = APP_SEARCH_PREFIX + name + ".xml";
+      uris.push(uri);
+      if (!jarPackaging) {
+        // Flat packaging requires that _loadEngines checks the modification
+        // time of each engine file.
+        let chan = makeChannel(uri);
+        if (chan)
+          chromeFiles.push(this._convertChannelToFile(chan));
+        else
+          LOG("_findJAREngines: couldn't resolve " + uri);
+      }
+    }
+
+    // Store this so that it can be used while writing the cache file.
+    this._visibleDefaultEngines = engineNames;
+  },
+
+
+  _saveSortedEngineList: function SRCH_SVC_saveSortedEngineList() {
+    LOG("SRCH_SVC_saveSortedEngineList: starting");
+
+    // Set the useDB pref to indicate that from now on we should use the order
+    // information stored in the database.
+    Services.prefs.setBoolPref(BROWSER_SEARCH_PREF + "useDBForOrder", true);
+
+    var engines = this._getSortedEngines(true);
+
+    let instructions = [];
+    for (var i = 0; i < engines.length; ++i) {
+      instructions.push(
+        {key: "order",
+         value: i+1,
+         engine: engines[i]
+        });
+    }
+
+    engineMetadataService.setAttrs(instructions);
+    LOG("SRCH_SVC_saveSortedEngineList: done");
+  },
+
+  _buildSortedEngineList: function SRCH_SVC_buildSortedEngineList() {
+    LOG("_buildSortedEngineList: building list");
+    var addedEngines = { };
+    this.__sortedEngines = [];
+    var engine;
+
+    // If the user has specified a custom engine order, read the order
+    // information from the engineMetadataService instead of the default
+    // prefs.
+    if (getBoolPref(BROWSER_SEARCH_PREF + "useDBForOrder", false)) {
+      LOG("_buildSortedEngineList: using db for order");
+
+      // Flag to keep track of whether or not we need to call _saveSortedEngineList.
+      let needToSaveEngineList = false;
+
+      for (let name in this._engines) {
+        let engine = this._engines[name];
+        var orderNumber = engineMetadataService.getAttr(engine, "order");
+
+        // Since the DB isn't regularly cleared, and engine files may disappear
+        // without us knowing, we may already have an engine in this slot. If
+        // that happens, we just skip it - it will be added later on as an
+        // unsorted engine.
+        if (orderNumber && !this.__sortedEngines[orderNumber-1]) {
+          this.__sortedEngines[orderNumber-1] = engine;
+          addedEngines[engine.name] = engine;
+        } else {
+          // We need to call _saveSortedEngineList so this gets sorted out.
+          needToSaveEngineList = true;
+        }
+      }
+
+      // Filter out any nulls for engines that may have been removed
+      var filteredEngines = this.__sortedEngines.filter(function(a) { return !!a; });
+      if (this.__sortedEngines.length != filteredEngines.length)
+        needToSaveEngineList = true;
+      this.__sortedEngines = filteredEngines;
+
+      if (needToSaveEngineList)
+        this._saveSortedEngineList();
+    } else {
+      // The DB isn't being used, so just read the engine order from the prefs
+      var i = 0;
+      var engineName;
+      var prefName;
+
+      try {
+        var extras =
+          Services.prefs.getChildList(BROWSER_SEARCH_PREF + "order.extra.");
+
+        for (prefName of extras) {
+          engineName = Services.prefs.getCharPref(prefName);
+
+          engine = this._engines[engineName];
+          if (!engine || engine.name in addedEngines)
+            continue;
+
+          this.__sortedEngines.push(engine);
+          addedEngines[engine.name] = engine;
+        }
+      }
+      catch (e) { }
+
+      let prefNameBase = getGeoSpecificPrefName(BROWSER_SEARCH_PREF + "order");
+      while (true) {
+        prefName = prefNameBase + "." + (++i);
+        engineName = getLocalizedPref(prefName);
+        if (!engineName)
+          break;
+
+        engine = this._engines[engineName];
+        if (!engine || engine.name in addedEngines)
+          continue;
+
+        this.__sortedEngines.push(engine);
+        addedEngines[engine.name] = engine;
+      }
+    }
+
+    // Array for the remaining engines, alphabetically sorted.
+    let alphaEngines = [];
+
+    for (let name in this._engines) {
+      let engine = this._engines[name];
+      if (!(engine.name in addedEngines))
+        alphaEngines.push(this._engines[engine.name]);
+    }
+
+    let locale = Cc["@mozilla.org/intl/nslocaleservice;1"]
+                   .getService(Ci.nsILocaleService)
+                   .newLocale(getLocale());
+    let collation = Cc["@mozilla.org/intl/collation-factory;1"]
+                      .createInstance(Ci.nsICollationFactory)
+                      .CreateCollation(locale);
+    const strength = Ci.nsICollation.kCollationCaseInsensitiveAscii;
+    let comparator = (a, b) => collation.compareString(strength, a.name, b.name);
+    alphaEngines.sort(comparator);
+    return this.__sortedEngines = this.__sortedEngines.concat(alphaEngines);
+  },
+
+  /**
+   * Get a sorted array of engines.
+   * @param aWithHidden
+   *        True if hidden plugins should be included in the result.
+   */
+  _getSortedEngines: function SRCH_SVC_getSorted(aWithHidden) {
+    if (aWithHidden)
+      return this._sortedEngines;
+
+    return this._sortedEngines.filter(function (engine) {
+                                        return !engine.hidden;
+                                      });
+  },
+
+  // nsIBrowserSearchService
+  init: function SRCH_SVC_init(observer) {
+    LOG("SearchService.init");
+    let self = this;
+    if (!this._initStarted) {
+      this._initStarted = true;
+      Task.spawn(function task() {
+        try {
+          yield checkForSyncCompletion(engineMetadataService.init());
+          // Complete initialization by calling asynchronous initializer.
+          yield self._asyncInit();
+        } catch (ex if ex.result == Cr.NS_ERROR_ALREADY_INITIALIZED) {
+          // No need to pursue asynchronous because synchronous fallback was
+          // called and has finished.
+        } catch (ex) {
+          self._initObservers.reject(ex);
+        }
+      });
+    }
+    if (observer) {
+      this._initObservers.promise.then(
+        function onSuccess() {
+          try {
+            observer.onInitComplete(self._initRV);
+          } catch (e) {
+            Cu.reportError(e);
+          }
+        },
+        function onError(aReason) {
+          Cu.reportError("Internal error while initializing SearchService: " + aReason);
+          observer.onInitComplete(Components.results.NS_ERROR_UNEXPECTED);
+        }
+      );
+    }
+  },
+
+  get isInitialized() {
+    return gInitialized;
+  },
+
+  getEngines: function SRCH_SVC_getEngines(aCount) {
+    this._ensureInitialized();
+    LOG("getEngines: getting all engines");
+    var engines = this._getSortedEngines(true);
+    aCount.value = engines.length;
+    return engines;
+  },
+
+  getVisibleEngines: function SRCH_SVC_getVisible(aCount) {
+    this._ensureInitialized();
+    LOG("getVisibleEngines: getting all visible engines");
+    var engines = this._getSortedEngines(false);
+    aCount.value = engines.length;
+    return engines;
+  },
+
+  getDefaultEngines: function SRCH_SVC_getDefault(aCount) {
+    this._ensureInitialized();
+    function isDefault(engine) {
+      return engine._isDefault;
+    };
+    var engines = this._sortedEngines.filter(isDefault);
+    var engineOrder = {};
+    var engineName;
+    var i = 1;
+
+    // Build a list of engines which we have ordering information for.
+    // We're rebuilding the list here because _sortedEngines contain the
+    // current order, but we want the original order.
+
+    // First, look at the "browser.search.order.extra" branch.
+    try {
+      var extras = Services.prefs.getChildList(BROWSER_SEARCH_PREF + "order.extra.");
+
+      for (var prefName of extras) {
+        engineName = Services.prefs.getCharPref(prefName);
+
+        if (!(engineName in engineOrder))
+          engineOrder[engineName] = i++;
+      }
+    } catch (e) {
+      LOG("Getting extra order prefs failed: " + e);
+    }
+
+    // Now look through the "browser.search.order" branch.
+    let prefNameBase = getGeoSpecificPrefName(BROWSER_SEARCH_PREF + "order");
+    for (var j = 1; ; j++) {
+      let prefName = prefNameBase + "." + j;
+      engineName = getLocalizedPref(prefName);
+      if (!engineName)
+        break;
+
+      if (!(engineName in engineOrder))
+        engineOrder[engineName] = i++;
+    }
+
+    LOG("getDefaultEngines: engineOrder: " + engineOrder.toSource());
+
+    function compareEngines (a, b) {
+      var aIdx = engineOrder[a.name];
+      var bIdx = engineOrder[b.name];
+
+      if (aIdx && bIdx)
+        return aIdx - bIdx;
+      if (aIdx)
+        return -1;
+      if (bIdx)
+        return 1;
+
+      return a.name.localeCompare(b.name);
+    }
+    engines.sort(compareEngines);
+
+    aCount.value = engines.length;
+    return engines;
+  },
+
+  getEngineByName: function SRCH_SVC_getEngineByName(aEngineName) {
+    this._ensureInitialized();
+    return this._engines[aEngineName] || null;
+  },
+
+  getEngineByAlias: function SRCH_SVC_getEngineByAlias(aAlias) {
+    this._ensureInitialized();
+    for (var engineName in this._engines) {
+      var engine = this._engines[engineName];
+      if (engine && engine.alias == aAlias)
+        return engine;
+    }
+    return null;
+  },
+
+  addEngineWithDetails: function SRCH_SVC_addEWD(aName, aIconURL, aAlias,
+                                                 aDescription, aMethod,
+                                                 aTemplate, aExtensionID) {
+    this._ensureInitialized();
+    if (!aName)
+      FAIL("Invalid name passed to addEngineWithDetails!");
+    if (!aMethod)
+      FAIL("Invalid method passed to addEngineWithDetails!");
+    if (!aTemplate)
+      FAIL("Invalid template passed to addEngineWithDetails!");
+    if (this._engines[aName])
+      FAIL("An engine with that name already exists!", Cr.NS_ERROR_FILE_ALREADY_EXISTS);
+
+    var engine = new Engine(getSanitizedFile(aName), false);
+    engine._initFromMetadata(aName, aIconURL, aAlias, aDescription,
+                             aMethod, aTemplate, aExtensionID);
+    this._addEngineToStore(engine);
+  },
+
+  addEngine: function SRCH_SVC_addEngine(aEngineURL, aDataType, aIconURL,
+                                         aConfirm, aCallback) {
+    LOG("addEngine: Adding \"" + aEngineURL + "\".");
+    this._ensureInitialized();
+    try {
+      var uri = makeURI(aEngineURL);
+      var engine = new Engine(uri, false);
+      if (aCallback) {
+        engine._installCallback = function (errorCode) {
+          try {
+            if (errorCode == null)
+              aCallback.onSuccess(engine);
+            else
+              aCallback.onError(errorCode);
+          } catch (ex) {
+            Cu.reportError("Error invoking addEngine install callback: " + ex);
+          }
+          // Clear the reference to the callback now that it's been invoked.
+          engine._installCallback = null;
+        };
+      }
+      engine._initFromURIAndLoad();
+    } catch (ex) {
+      // Drop the reference to the callback, if set
+      if (engine)
+        engine._installCallback = null;
+      FAIL("addEngine: Error adding engine:\n" + ex, Cr.NS_ERROR_FAILURE);
+    }
+    engine._setIcon(aIconURL, false);
+    engine._confirm = aConfirm;
+  },
+
+  removeEngine: function SRCH_SVC_removeEngine(aEngine) {
+    this._ensureInitialized();
+    if (!aEngine)
+      FAIL("no engine passed to removeEngine!");
+
+    var engineToRemove = null;
+    for (var e in this._engines) {
+      if (aEngine.wrappedJSObject == this._engines[e])
+        engineToRemove = this._engines[e];
+    }
+
+    if (!engineToRemove)
+      FAIL("removeEngine: Can't find engine to remove!", Cr.NS_ERROR_FILE_NOT_FOUND);
+
+    if (engineToRemove == this.currentEngine) {
+      this._currentEngine = null;
+    }
+
+    if (engineToRemove == this.defaultEngine) {
+      this._defaultEngine = null;
+    }
+
+    if (engineToRemove._readOnly) {
+      // Just hide it (the "hidden" setter will notify) and remove its alias to
+      // avoid future conflicts with other engines.
+      engineToRemove.hidden = true;
+      engineToRemove.alias = null;
+    } else {
+      // Cancel the serialized task if it's pending.  Since the task is a
+      // synchronous function, we don't need to wait on the "finalize" method.
+      if (engineToRemove._lazySerializeTask) {
+        engineToRemove._lazySerializeTask.disarm();
+        engineToRemove._lazySerializeTask = null;
+      }
+
+      // Remove the engine file from disk (this might throw)
+      engineToRemove._remove();
+      engineToRemove._file = null;
+
+      // Remove the engine from _sortedEngines
+      var index = this._sortedEngines.indexOf(engineToRemove);
+      if (index == -1)
+        FAIL("Can't find engine to remove in _sortedEngines!", Cr.NS_ERROR_FAILURE);
+      this.__sortedEngines.splice(index, 1);
+
+      // Remove the engine from the internal store
+      delete this._engines[engineToRemove.name];
+
+      notifyAction(engineToRemove, SEARCH_ENGINE_REMOVED);
+
+      // Since we removed an engine, we need to update the preferences.
+      this._saveSortedEngineList();
+    }
+  },
+
+  moveEngine: function SRCH_SVC_moveEngine(aEngine, aNewIndex) {
+    this._ensureInitialized();
+    if ((aNewIndex > this._sortedEngines.length) || (aNewIndex < 0))
+      FAIL("SRCH_SVC_moveEngine: Index out of bounds!");
+    if (!(aEngine instanceof Ci.nsISearchEngine))
+      FAIL("SRCH_SVC_moveEngine: Invalid engine passed to moveEngine!");
+    if (aEngine.hidden)
+      FAIL("moveEngine: Can't move a hidden engine!", Cr.NS_ERROR_FAILURE);
+
+    var engine = aEngine.wrappedJSObject;
+
+    var currentIndex = this._sortedEngines.indexOf(engine);
+    if (currentIndex == -1)
+      FAIL("moveEngine: Can't find engine to move!", Cr.NS_ERROR_UNEXPECTED);
+
+    // Our callers only take into account non-hidden engines when calculating
+    // aNewIndex, but we need to move it in the array of all engines, so we
+    // need to adjust aNewIndex accordingly. To do this, we count the number
+    // of hidden engines in the list before the engine that we're taking the
+    // place of. We do this by first finding newIndexEngine (the engine that
+    // we were supposed to replace) and then iterating through the complete
+    // engine list until we reach it, increasing aNewIndex for each hidden
+    // engine we find on our way there.
+    //
+    // This could be further simplified by having our caller pass in
+    // newIndexEngine directly instead of aNewIndex.
+    var newIndexEngine = this._getSortedEngines(false)[aNewIndex];
+    if (!newIndexEngine)
+      FAIL("moveEngine: Can't find engine to replace!", Cr.NS_ERROR_UNEXPECTED);
+
+    for (var i = 0; i < this._sortedEngines.length; ++i) {
+      if (newIndexEngine == this._sortedEngines[i])
+        break;
+      if (this._sortedEngines[i].hidden)
+        aNewIndex++;
+    }
+
+    if (currentIndex == aNewIndex)
+      return; // nothing to do!
+
+    // Move the engine
+    var movedEngine = this.__sortedEngines.splice(currentIndex, 1)[0];
+    this.__sortedEngines.splice(aNewIndex, 0, movedEngine);
+
+    notifyAction(engine, SEARCH_ENGINE_CHANGED);
+
+    // Since we moved an engine, we need to update the preferences.
+    this._saveSortedEngineList();
+  },
+
+  restoreDefaultEngines: function SRCH_SVC_resetDefaultEngines() {
+    this._ensureInitialized();
+    for (let name in this._engines) {
+      let e = this._engines[name];
+      // Unhide all default engines
+      if (e.hidden && e._isDefault)
+        e.hidden = false;
+    }
+  },
+
+  get defaultEngine() {
+    this._ensureInitialized();
+    if (!this._defaultEngine) {
+      let defPref = getGeoSpecificPrefName(BROWSER_SEARCH_PREF + "defaultenginename");
+      let defaultEngine = this.getEngineByName(getLocalizedPref(defPref, ""))
+      if (!defaultEngine)
+        defaultEngine = this._getSortedEngines(false)[0] || null;
+      this._defaultEngine = defaultEngine;
+    }
+    if (this._defaultEngine.hidden)
+      return this._getSortedEngines(false)[0];
+    return this._defaultEngine;
+  },
+
+  set defaultEngine(val) {
+    this._ensureInitialized();
+    // Sometimes we get wrapped nsISearchEngine objects (external XPCOM callers),
+    // and sometimes we get raw Engine JS objects (callers in this file), so
+    // handle both.
+    if (!(val instanceof Ci.nsISearchEngine) && !(val instanceof Engine))
+      FAIL("Invalid argument passed to defaultEngine setter");
+
+    let newDefaultEngine = this.getEngineByName(val.name);
+    if (!newDefaultEngine)
+      FAIL("Can't find engine in store!", Cr.NS_ERROR_UNEXPECTED);
+
+    if (newDefaultEngine == this._defaultEngine)
+      return;
+
+    this._defaultEngine = newDefaultEngine;
+
+    let defPref = getGeoSpecificPrefName(BROWSER_SEARCH_PREF + "defaultenginename");
+
+    // If we change the default engine in the future, that change should impact
+    // users who have switched away from and then back to the build's "default"
+    // engine. So clear the user pref when the defaultEngine is set to the
+    // build's default engine, so that the defaultEngine getter falls back to
+    // whatever the default is.
+    if (this._defaultEngine == this._originalDefaultEngine) {
+      Services.prefs.clearUserPref(defPref);
+    }
+    else {
+      setLocalizedPref(defPref, this._defaultEngine.name);
+    }
+
+    notifyAction(this._defaultEngine, SEARCH_ENGINE_DEFAULT);
+  },
+
+  get currentEngine() {
+    this._ensureInitialized();
+    if (!this._currentEngine) {
+      let name = engineMetadataService.getGlobalAttr("current");
+      if (engineMetadataService.getGlobalAttr("hash") == getVerificationHash(name)) {
+        this._currentEngine = this.getEngineByName(name);
+      }
+    }
+
+    if (!this._currentEngine || this._currentEngine.hidden)
+      this._currentEngine = this._originalDefaultEngine;
+    if (!this._currentEngine || this._currentEngine.hidden)
+      this._currentEngine = this._getSortedEngines(false)[0];
+
+    if (!this._currentEngine) {
+      // Last resort fallback: unhide the original default engine.
+      this._currentEngine = this._originalDefaultEngine;
+      if (this._currentEngine)
+        this._currentEngine.hidden = false;
+    }
+
+    return this._currentEngine;
+  },
+
+  set currentEngine(val) {
+    this._ensureInitialized();
+    // Sometimes we get wrapped nsISearchEngine objects (external XPCOM callers),
+    // and sometimes we get raw Engine JS objects (callers in this file), so
+    // handle both.
+    if (!(val instanceof Ci.nsISearchEngine) && !(val instanceof Engine))
+      FAIL("Invalid argument passed to currentEngine setter");
+
+    var newCurrentEngine = this.getEngineByName(val.name);
+    if (!newCurrentEngine)
+      FAIL("Can't find engine in store!", Cr.NS_ERROR_UNEXPECTED);
+
+    if (newCurrentEngine == this._currentEngine)
+      return;
+
+    this._currentEngine = newCurrentEngine;
+
+    // If we change the default engine in the future, that change should impact
+    // users who have switched away from and then back to the build's "default"
+    // engine. So clear the user pref when the currentEngine is set to the
+    // build's default engine, so that the currentEngine getter falls back to
+    // whatever the default is.
+    let newName = this._currentEngine.name;
+    if (this._currentEngine == this._originalDefaultEngine) {
+      newName = "";
+    }
+
+    engineMetadataService.setGlobalAttr("current", newName);
+    engineMetadataService.setGlobalAttr("hash", getVerificationHash(newName));
+
+    notifyAction(this._currentEngine, SEARCH_ENGINE_CURRENT);
+  },
+
+  getDefaultEngineInfo() {
+    let result = {};
+
+    let engine;
+    try {
+      engine = this.defaultEngine;
+    } catch(e) {
+      // The defaultEngine getter will throw if there's no engine at all,
+      // which shouldn't happen unless an add-on or a test deleted all of them.
+      // Our preferences UI doesn't let users do that.
+      Cu.reportError("getDefaultEngineInfo: No default engine");
+    }
+
+    if (!engine) {
+      result.name = "NONE";
+    } else {
+      if (engine.name)
+        result.name = engine.name;
+
+      result.loadPath = engine._anonymizedLoadPath;
+
+      // For privacy, we only collect the submission URL for engines
+      // from the application or distribution folder...
+      let sendSubmissionURL =
+        /^(?:jar:)?(?:\[app\]|\[distribution\])/.test(result.loadPath);
+
+      // ... or engines sorted by default near the top of the list.
+      if (!sendSubmissionURL) {
+        let extras =
+          Services.prefs.getChildList(BROWSER_SEARCH_PREF + "order.extra.");
+
+        for (let prefName of extras) {
+          try {
+            if (result.name == Services.prefs.getCharPref(prefName)) {
+              sendSubmissionURL = true;
+              break;
+            }
+          } catch(e) {}
+        }
+
+        let prefNameBase = getGeoSpecificPrefName(BROWSER_SEARCH_PREF + "order");
+        let i = 0;
+        while (!sendSubmissionURL) {
+          let prefName = prefNameBase + "." + (++i);
+          let engineName = getLocalizedPref(prefName);
+          if (!engineName)
+            break;
+          if (result.name == engineName) {
+            sendSubmissionURL = true;
+            break;
+          }
+        }
+      }
+
+      if (sendSubmissionURL) {
+        let uri = engine._getURLOfType("text/html")
+                        .getSubmission("", engine, "searchbar").uri;
+        uri.userPass = ""; // Avoid reporting a username or password.
+        result.submissionURL = uri.spec;
+      }
+    }
+
+    return result;
+  },
+
+  /**
+   * This map is built lazily after the available search engines change.  It
+   * allows quick parsing of an URL representing a search submission into the
+   * search engine name and original terms.
+   *
+   * The keys are strings containing the domain name and lowercase path of the
+   * engine submission, for example "www.google.com/search".
+   *
+   * The values are objects with these properties:
+   * {
+   *   engine: The associated nsISearchEngine.
+   *   termsParameterName: Name of the URL parameter containing the search
+   *                       terms, for example "q".
+   * }
+   */
+  _parseSubmissionMap: null,
+
+  _buildParseSubmissionMap: function SRCH_SVC__buildParseSubmissionMap() {
+    LOG("_buildParseSubmissionMap");
+    this._parseSubmissionMap = new Map();
+
+    // Used only while building the map, indicates which entries do not refer to
+    // the main domain of the engine but to an alternate domain, for example
+    // "www.google.fr" for the "www.google.com" search engine.
+    let keysOfAlternates = new Set();
+
+    for (let engine of this._sortedEngines) {
+      LOG("Processing engine: " + engine.name);
+
+      if (engine.hidden) {
+        LOG("Engine is hidden.");
+        continue;
+      }
+
+      let urlParsingInfo = engine.getURLParsingInfo();
+      if (!urlParsingInfo) {
+        LOG("Engine does not support URL parsing.");
+        continue;
+      }
+
+      // Store the same object on each matching map key, as an optimization.
+      let mapValueForEngine = {
+        engine: engine,
+        termsParameterName: urlParsingInfo.termsParameterName,
+      };
+
+      let processDomain = (domain, isAlternate) => {
+        let key = domain + urlParsingInfo.path;
+
+        // Apply the logic for which main domains take priority over alternate
+        // domains, even if they are found later in the ordered engine list.
+        let existingEntry = this._parseSubmissionMap.get(key);
+        if (!existingEntry) {
+          LOG("Adding new entry: " + key);
+          if (isAlternate) {
+            keysOfAlternates.add(key);
+          }
+        } else if (!isAlternate && keysOfAlternates.has(key)) {
+          LOG("Overriding alternate entry: " + key +
+              " (" + existingEntry.engine.name + ")");
+          keysOfAlternates.delete(key);
+        } else {
+          LOG("Keeping existing entry: " + key +
+              " (" + existingEntry.engine.name + ")");
+          return;
+        }
+
+        this._parseSubmissionMap.set(key, mapValueForEngine);
+      };
+
+      processDomain(urlParsingInfo.mainDomain, false);
+      SearchStaticData.getAlternateDomains(urlParsingInfo.mainDomain)
+                      .forEach(d => processDomain(d, true));
+    }
+  },
+
+  parseSubmissionURL: function SRCH_SVC_parseSubmissionURL(aURL) {
+    this._ensureInitialized();
+    LOG("parseSubmissionURL: Parsing \"" + aURL + "\".");
+
+    if (!this._parseSubmissionMap) {
+      this._buildParseSubmissionMap();
+    }
+
+    // Extract the elements of the provided URL first.
+    let soughtKey, soughtQuery;
+    try {
+      let soughtUrl = NetUtil.newURI(aURL).QueryInterface(Ci.nsIURL);
+
+      // Exclude any URL that is not HTTP or HTTPS from the beginning.
+      if (soughtUrl.scheme != "http" && soughtUrl.scheme != "https") {
+        LOG("The URL scheme is not HTTP or HTTPS.");
+        return gEmptyParseSubmissionResult;
+      }
+
+      // Reading these URL properties may fail and raise an exception.
+      soughtKey = soughtUrl.host + soughtUrl.filePath.toLowerCase();
+      soughtQuery = soughtUrl.query;
+    } catch (ex) {
+      // Errors while parsing the URL or accessing the properties are not fatal.
+      LOG("The value does not look like a structured URL.");
+      return gEmptyParseSubmissionResult;
+    }
+
+    // Look up the domain and path in the map to identify the search engine.
+    let mapEntry = this._parseSubmissionMap.get(soughtKey);
+    if (!mapEntry) {
+      LOG("No engine associated with domain and path: " + soughtKey);
+      return gEmptyParseSubmissionResult;
+    }
+
+    // Extract the search terms from the parameter, for example "caff%C3%A8"
+    // from the URL "https://www.google.com/search?q=caff%C3%A8&client=firefox".
+    let encodedTerms = null;
+    for (let param of soughtQuery.split("&")) {
+      let equalPos = param.indexOf("=");
+      if (equalPos != -1 &&
+          param.substr(0, equalPos) == mapEntry.termsParameterName) {
+        // This is the parameter we are looking for.
+        encodedTerms = param.substr(equalPos + 1);
+        break;
+      }
+    }
+    if (encodedTerms === null) {
+      LOG("Missing terms parameter: " + mapEntry.termsParameterName);
+      return gEmptyParseSubmissionResult;
+    }
+
+    let length = 0;
+    let offset = aURL.indexOf("?") + 1;
+    let query = aURL.slice(offset);
+    // Iterate a second time over the original input string to determine the
+    // correct search term offset and length in the original encoding.
+    for (let param of query.split("&")) {
+      let equalPos = param.indexOf("=");
+      if (equalPos != -1 &&
+          param.substr(0, equalPos) == mapEntry.termsParameterName) {
+        // This is the parameter we are looking for.
+        offset += equalPos + 1;
+        length = param.length - equalPos - 1;
+        break;
+      }
+      offset += param.length + 1;
+    }
+
+    // Decode the terms using the charset defined in the search engine.
+    let terms;
+    try {
+      terms = gTextToSubURI.UnEscapeAndConvert(
+                                       mapEntry.engine.queryCharset,
+                                       encodedTerms.replace(/\+/g, " "));
+    } catch (ex) {
+      // Decoding errors will cause this match to be ignored.
+      LOG("Parameter decoding failed. Charset: " +
+          mapEntry.engine.queryCharset);
+      return gEmptyParseSubmissionResult;
+    }
+
+    LOG("Match found. Terms: " + terms);
+    return new ParseSubmissionResult(mapEntry.engine, terms, offset, length);
+  },
+
+  // nsIObserver
+  observe: function SRCH_SVC_observe(aEngine, aTopic, aVerb) {
+    switch (aTopic) {
+      case SEARCH_ENGINE_TOPIC:
+        switch (aVerb) {
+          case SEARCH_ENGINE_LOADED:
+            var engine = aEngine.QueryInterface(Ci.nsISearchEngine);
+            LOG("nsSearchService::observe: Done installation of " + engine.name
+                + ".");
+            this._addEngineToStore(engine.wrappedJSObject);
+            if (engine.wrappedJSObject._useNow) {
+              LOG("nsSearchService::observe: setting current");
+              this.currentEngine = aEngine;
+            }
+            // The addition of the engine to the store always triggers an ADDED
+            // or a CHANGED notification, that will trigger the task below.
+            break;
+          case SEARCH_ENGINE_ADDED:
+          case SEARCH_ENGINE_CHANGED:
+          case SEARCH_ENGINE_REMOVED:
+            this.batchTask.disarm();
+            this.batchTask.arm();
+            // Invalidate the map used to parse URLs to search engines.
+            this._parseSubmissionMap = null;
+            break;
+        }
+        break;
+
+      case QUIT_APPLICATION_TOPIC:
+        this._removeObservers();
+        break;
+
+      case "nsPref:changed":
+        if (aVerb == LOCALE_PREF) {
+          // Locale changed. Re-init. We rely on observers, because we can't
+          // return this promise to anyone.
+          this._asyncReInit();
+          break;
+        }
+    }
+  },
+
+  // nsITimerCallback
+  notify: function SRCH_SVC_notify(aTimer) {
+    LOG("_notify: checking for updates");
+
+    if (!getBoolPref(BROWSER_SEARCH_PREF + "update", true))
+      return;
+
+    // Our timer has expired, but unfortunately, we can't get any data from it.
+    // Therefore, we need to walk our engine-list, looking for expired engines
+    var currentTime = Date.now();
+    LOG("currentTime: " + currentTime);
+    for (let name in this._engines) {
+      let engine = this._engines[name].wrappedJSObject;
+      if (!engine._hasUpdates)
+        continue;
+
+      LOG("checking " + engine.name);
+
+      var expirTime = engineMetadataService.getAttr(engine, "updateexpir");
+      LOG("expirTime: " + expirTime + "\nupdateURL: " + engine._updateURL +
+          "\niconUpdateURL: " + engine._iconUpdateURL);
+
+      var engineExpired = expirTime <= currentTime;
+
+      if (!expirTime || !engineExpired) {
+        LOG("skipping engine");
+        continue;
+      }
+
+      LOG(engine.name + " has expired");
+
+      engineUpdateService.update(engine);
+
+      // Schedule the next update
+      engineUpdateService.scheduleNextUpdate(engine);
+
+    } // end engine iteration
+  },
+
+  _addObservers: function SRCH_SVC_addObservers() {
+    Services.obs.addObserver(this, SEARCH_ENGINE_TOPIC, false);
+    Services.obs.addObserver(this, QUIT_APPLICATION_TOPIC, false);
+
+#ifdef MOZ_FENNEC
+    Services.prefs.addObserver(LOCALE_PREF, this, false);
+#endif
+
+    // The current stage of shutdown. Used to help analyze crash
+    // signatures in case of shutdown timeout.
+    let shutdownState = {
+      step: "Not started",
+      latestError: {
+        message: undefined,
+        stack: undefined
+      }
+    };
+    OS.File.profileBeforeChange.addBlocker(
+      "Search service: shutting down",
+      () => Task.spawn(function* () {
+        if (this._batchTask) {
+          shutdownState.step = "Finalizing batched task";
+          try {
+            yield this._batchTask.finalize();
+            shutdownState.step = "Batched task finalized";
+          } catch (ex) {
+            shutdownState.step = "Batched task failed to finalize";
+
+            shutdownState.latestError.message = "" + ex;
+            if (ex && typeof ex == "object") {
+              shutdownState.latestError.stack = ex.stack || undefined;
+            }
+
+            // Ensure that error is reported and that it causes tests
+            // to fail.
+            Promise.reject(ex);
+          }
+        }
+
+        shutdownState.step = "Finalizing engine metadata service";
+        yield engineMetadataService.finalize();
+        shutdownState.step = "Engine metadata service finalized";
+
+      }.bind(this)),
+
+      () => shutdownState
+    );
+  },
+
+  _removeObservers: function SRCH_SVC_removeObservers() {
+    Services.obs.removeObserver(this, SEARCH_ENGINE_TOPIC);
+    Services.obs.removeObserver(this, QUIT_APPLICATION_TOPIC);
+
+#ifdef MOZ_FENNEC
+    Services.prefs.removeObserver(LOCALE_PREF, this);
+#endif
+  },
+
+  QueryInterface: function SRCH_SVC_QI(aIID) {
+    if (aIID.equals(Ci.nsIBrowserSearchService) ||
+        aIID.equals(Ci.nsIObserver)             ||
+        aIID.equals(Ci.nsITimerCallback)        ||
+        aIID.equals(Ci.nsISupports))
+      return this;
+    throw Cr.NS_ERROR_NO_INTERFACE;
+  }
+};
+
+var engineMetadataService = {
+  _jsonFile: OS.Path.join(OS.Constants.Path.profileDir, "search-metadata.json"),
+
+  // Boolean flag that is true if initialization was successful.
+  _initialized: false,
+
+  // A promise fulfilled once initialization is complete
+  _initializer: null,
+
+  /**
+   * Asynchronous initializer
+   *
+   * Note: In the current implementation, initialization never fails.
+   */
+  init: function epsInit() {
+    if (!this._initializer) {
+      // Launch asynchronous initialization
+      let initializer = this._initializer = Promise.defer();
+      Task.spawn((function task_init() {
+        LOG("metadata init: starting");
+        if (this._initialized) {
+          throw new Error("metadata init: invalid state, _initialized is " +
+                          "true but initialization promise has not been " +
+                          "resolved");
+        }
+        // 1. Load json file if it exists
+        try {
+          let contents = yield OS.File.read(this._jsonFile);
+          if (this._initialized) {
+            // No need to pursue asynchronous initialization,
+            // synchronous fallback was called and has finished.
+            return;
+          }
+          this._store = JSON.parse(new TextDecoder().decode(contents));
+        } catch (ex) {
+          if (this._initialized) {
+            // No need to pursue asynchronous initialization,
+            // synchronous fallback was called and has finished.
+            return;
+          }
+          // Couldn't load json, use an empty store
+          LOG("metadata init: could not load JSON file " + ex);
+          this._store = {};
+        }
+
+        this._initialized = true;
+        LOG("metadata init: complete");
+      }).bind(this)).then(
+        // 3. Inform any observers
+        function onSuccess() {
+          initializer.resolve();
+        },
+        function onError() {
+          initializer.reject();
+        }
+      );
+    }
+    return this._initializer.promise;
+  },
+
+  /**
+   * Synchronous implementation of initializer
+   *
+   * This initializer is able to pick wherever the async initializer
+   * is waiting. The asynchronous initializer is expected to stop
+   * if it detects that the synchronous initializer has completed
+   * initialization.
+   */
+  syncInit: function epsSyncInit() {
+    LOG("metadata syncInit start");
+    if (this._initialized) {
+      return;
+    }
+    let jsonFile = new FileUtils.File(this._jsonFile);
+    // 1. Load json file if it exists
+    if (jsonFile.exists()) {
+      try {
+        let uri = Services.io.newFileURI(jsonFile);
+        let stream = Services.io.newChannelFromURI2(uri,
+                                                    null,      // aLoadingNode
+                                                    Services.scriptSecurityManager.getSystemPrincipal(),
+                                                    null,      // aTriggeringPrincipal
+                                                    Ci.nsILoadInfo.SEC_NORMAL,
+                                                    Ci.nsIContentPolicy.TYPE_OTHER).open();
+        this._store = parseJsonFromStream(stream);
+      } catch (x) {
+        LOG("metadata syncInit: could not load JSON file " + x);
+        this._store = {};
+      }
+    } else {
+      LOG("metadata syncInit: using an empty store");
+      this._store = {};
+    }
+
+    this._initialized = true;
+
+    // 3. Inform any observers
+    if (this._initializer) {
+      this._initializer.resolve();
+    } else {
+      this._initializer = Promise.resolve();
+    }
+    LOG("metadata syncInit end");
+  },
+
+  getAttr: function epsGetAttr(engine, name) {
+    let record = this._store[engine._id];
+    if (!record) {
+      return null;
+    }
+
+    // attr names must be lower case
+    let aName = name.toLowerCase();
+    if (!record[aName])
+      return null;
+    return record[aName];
+  },
+
+  _globalFakeEngine: {_id: "[global]"},
+  getGlobalAttr: function epsGetGlobalAttr(name) {
+    return this.getAttr(this._globalFakeEngine, name);
+  },
+
+  _setAttr: function epsSetAttr(engine, name, value) {
+    // attr names must be lower case
+    name = name.toLowerCase();
+    let db = this._store;
+    let record = db[engine._id];
+    if (!record) {
+      record = db[engine._id] = {};
+    }
+    if (!record[name] || (record[name] != value)) {
+      record[name] = value;
+      return true;
+    }
+    return false;
+  },
+
+  /**
+   * Set one metadata attribute for an engine.
+   *
+   * If an actual change has taken place, the attribute is committed
+   * automatically (and lazily), using this._commit.
+   *
+   * @param {nsISearchEngine} engine The engine to update.
+   * @param {string} key The name of the attribute. Case-insensitive. In
+   * the current implementation, this _must not_ conflict with properties
+   * of |Object|.
+   * @param {*} value A value to store.
+   */
+  setAttr: function epsSetAttr(engine, key, value) {
+    if (this._setAttr(engine, key, value)) {
+      this._commit();
+    }
+  },
+
+  setGlobalAttr: function epsGetGlobalAttr(key, value) {
+    this.setAttr(this._globalFakeEngine, key, value);
+  },
+
+  /**
+   * Bulk set metadata attributes for a number of engines.
+   *
+   * If actual changes have taken place, the store is committed
+   * automatically (and lazily), using this._commit.
+   *
+   * @param {Array.<{engine: nsISearchEngine, key: string, value: *}>} changes
+   * The list of changes to effect. See |setAttr| for the documentation of
+   * |engine|, |key|, |value|.
+   */
+  setAttrs: function epsSetAttrs(changes) {
+    let self = this;
+    let changed = false;
+    changes.forEach(function(change) {
+      changed |= self._setAttr(change.engine, change.key, change.value);
+    });
+    if (changed) {
+      this._commit();
+    }
+  },
+
+  /**
+   * Flush any waiting write.
+   */
+  finalize: function () {
+    return this._lazyWriter ? this._lazyWriter.finalize()
+                            : Promise.resolve();
+  },
+
+  /**
+   * Commit changes to disk, asynchronously.
+   *
+   * Calls to this function are actually delayed by LAZY_SERIALIZE_DELAY
+   * (= 100ms). If the function is called again before the expiration of
+   * the delay, commits are merged and the function is again delayed by
+   * the same amount of time.
+   */
+  _commit: function epsCommit() {
+    LOG("metadata _commit: start");
+    if (!this._store) {
+      LOG("metadata _commit: nothing to do");
+      return;
+    }
+
+    if (!this._lazyWriter) {
+      LOG("metadata _commit: initializing lazy writer");
+      let writeCommit = function () {
+        LOG("metadata writeCommit: start");
+        let data = gEncoder.encode(JSON.stringify(engineMetadataService._store));
+        let path = engineMetadataService._jsonFile;
+        LOG("metadata writeCommit: path " + path);
+        let promise = OS.File.writeAtomic(path, data, { tmpPath: path + ".tmp" });
+        promise = promise.then(
+          function onSuccess() {
+            Services.obs.notifyObservers(null,
+              SEARCH_SERVICE_TOPIC,
+              SEARCH_SERVICE_METADATA_WRITTEN);
+            LOG("metadata writeCommit: done");
+          }
+        );
+        return promise;
+      }
+      this._lazyWriter = new DeferredTask(writeCommit, LAZY_SERIALIZE_DELAY);
+    }
+    LOG("metadata _commit: (re)setting timer");
+    this._lazyWriter.disarm();
+    this._lazyWriter.arm();
+  },
+  _lazyWriter: null
+};
+
+engineMetadataService._initialized = false;
+
+const SEARCH_UPDATE_LOG_PREFIX = "*** Search update: ";
+
+/**
+ * Outputs aText to the JavaScript console as well as to stdout, if the search
+ * logging pref (browser.search.update.log) is set to true.
+ */
+function ULOG(aText) {
+  if (getBoolPref(BROWSER_SEARCH_PREF + "update.log", false)) {
+    dump(SEARCH_UPDATE_LOG_PREFIX + aText + "\n");
+    Services.console.logStringMessage(aText);
+  }
+}
+
+var engineUpdateService = {
+  scheduleNextUpdate: function eus_scheduleNextUpdate(aEngine) {
+    var interval = aEngine._updateInterval || SEARCH_DEFAULT_UPDATE_INTERVAL;
+    var milliseconds = interval * 86400000; // |interval| is in days
+    engineMetadataService.setAttr(aEngine, "updateexpir",
+                                  Date.now() + milliseconds);
+  },
+
+  update: function eus_Update(aEngine) {
+    let engine = aEngine.wrappedJSObject;
+    ULOG("update called for " + aEngine._name);
+    if (!getBoolPref(BROWSER_SEARCH_PREF + "update", true) || !engine._hasUpdates)
+      return;
+
+    let testEngine = null;
+    let updateURL = engine._getURLOfType(URLTYPE_OPENSEARCH);
+    let updateURI = (updateURL && updateURL._hasRelation("self")) ?
+                     updateURL.getSubmission("", engine).uri :
+                     makeURI(engine._updateURL);
+    if (updateURI) {
+      if (engine._isDefault && !updateURI.schemeIs("https")) {
+        ULOG("Invalid scheme for default engine update");
+        return;
+      }
+
+      ULOG("updating " + engine.name + " from " + updateURI.spec);
+      testEngine = new Engine(updateURI, false);
+      testEngine._engineToUpdate = engine;
+      testEngine._initFromURIAndLoad();
+    } else
+      ULOG("invalid updateURI");
+
+    if (engine._iconUpdateURL) {
+      // If we're updating the engine too, use the new engine object,
+      // otherwise use the existing engine object.
+      (testEngine || engine)._setIcon(engine._iconUpdateURL, true);
+    }
+  }
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([SearchService]);
+
+#include ../../../toolkit/modules/debug.js