The Tor Browser: comparison toolkit/components/search/nsSearchService.js

comparison: toolkit/components/search/nsSearchService.js

toolkit/components/search/nsSearchService.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:00efed7a1cf9
+# 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, "TelemetryStopwatch",
+"resource://gre/modules/TelemetryStopwatch.jsm");
+// A text encoder to UTF8, used whenever we commit the
+// engine metadata to disk.
+XPCOMUtils.defineLazyGetter(this, "gEncoder",
+function() {
+return new TextEncoder();
+});
+const PERMS_FILE      = 0644;
+const PERMS_DIRECTORY = 0755;
+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_USER_SEARCH_DIR  = "UsrSrchPlugns";
+const NS_APP_SEARCH_DIR       = "SrchPlugns";
+const NS_APP_USER_PROFILE_50_DIR = "ProfD";
+// 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";
+const SEARCH_TYPE_MOZSEARCH      = Ci.nsISearchEngine.TYPE_MOZSEARCH;
+const SEARCH_TYPE_OPENSEARCH     = Ci.nsISearchEngine.TYPE_OPENSEARCH;
+const SEARCH_TYPE_SHERLOCK       = Ci.nsISearchEngine.TYPE_SHERLOCK;
+const SEARCH_DATA_XML            = Ci.nsISearchEngine.DATA_XML;
+const SEARCH_DATA_TEXT           = Ci.nsISearchEngine.DATA_TEXT;
+// 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 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;
+// Returns false for whitespace-only or commented out lines in a
+// Sherlock file, true otherwise.
+function isUsefulLine(aLine) {
+return !(/^\s*($|#)/i.test(aLine));
+}
+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;
+}
+/**
+* Utilities for dealing with promises and Task.jsm
+*/
+const TaskUtils = {
+/**
+* Add logging to a promise.
+*
+* @param {Promise} promise
+* @return {Promise} A promise behaving as |promise|, but with additional
+* logging in case of uncaught error.
+*/
+captureErrors: function captureErrors(promise) {
+return promise.then(
+null,
+function onError(reason) {
+LOG("Uncaught asynchronous error: " + reason + " at\n" + reason.stack);
+throw reason;
+}
+);
+},
+/**
+* Spawn a new Task from a generator.
+*
+* This function behaves as |Task.spawn|, with the exception that it
+* adds logging in case of uncaught error. For more information, see
+* the documentation of |Task.jsm|.
+*
+* @param {generator} gen Some generator.
+* @return {Promise} A promise built from |gen|, with the same semantics
+* as |Task.spawn(gen)|.
+*/
+spawn: function spawn(gen) {
+return this.captureErrors(Task.spawn(gen));
+},
+/**
+* Execute a mozIStorage statement asynchronously, wrapping the
+* result in a promise.
+*
+* @param {mozIStorageStaement} statement A statement to be executed
+* asynchronously. The semantics are the same as these of |statement.execute|.
+* @param {function*} onResult A callback, called for each successive result.
+*
+* @return {Promise} A promise, resolved successfully if |statement.execute|
+* succeeds, rejected if it fails.
+*/
+executeStatement: function executeStatement(statement, onResult) {
+let deferred = Promise.defer();
+onResult = onResult || function() {};
+statement.executeAsync({
+handleResult: onResult,
+handleError: function handleError(aError) {
+deferred.reject(aError);
+},
+handleCompletion: function handleCompletion(aReason) {
+statement.finalize();
+// Note that, in case of error, deferred.reject(aError)
+// has already been called by this point, so the call to
+// |deferred.resolve| is simply ignored.
+deferred.resolve(aReason);
+}
+});
+return deferred.promise;
+}
+};
+/**
+* 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) {}
+}
+/**
+* Used to verify a given DOM node's localName and namespaceURI.
+* @param aElement
+*        The element to verify.
+* @param aLocalNameArray
+*        An array of strings to compare against aElement's localName.
+* @param aNameSpaceArray
+*        An array of strings to compare against aElement's namespaceURI.
+*
+* @returns false if aElement is null, or if its localName or namespaceURI
+*          does not match one of the elements in the aLocalNameArray or
+*          aNameSpaceArray arrays, respectively.
+* @throws NS_ERROR_INVALID_ARG if aLocalNameArray or aNameSpaceArray are null.
+*/
+function checkNameSpace(aElement, aLocalNameArray, aNameSpaceArray) {
+if (!aLocalNameArray || !aNameSpaceArray)
+FAIL("missing aLocalNameArray or aNameSpaceArray for checkNameSpace");
+return (aElement                                                &&
+(aLocalNameArray.indexOf(aElement.localName)    != -1)  &&
+(aNameSpaceArray.indexOf(aElement.namespaceURI) != -1));
+}
+/**
+* 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;
+}
+/**
+* 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);
+}
+/**
+* The following two functions are essentially copied from
+* nsInternetSearchService. They are required for backwards compatibility.
+*/
+function queryCharsetFromCode(aCode) {
+const codes = [];
+codes[0] = "macintosh";
+codes[6] = "x-mac-greek";
+codes[35] = "x-mac-turkish";
+codes[513] = "ISO-8859-1";
+codes[514] = "ISO-8859-2";
+codes[517] = "ISO-8859-5";
+codes[518] = "ISO-8859-6";
+codes[519] = "ISO-8859-7";
+codes[520] = "ISO-8859-8";
+codes[521] = "ISO-8859-9";
+codes[1280] = "windows-1252";
+codes[1281] = "windows-1250";
+codes[1282] = "windows-1251";
+codes[1283] = "windows-1253";
+codes[1284] = "windows-1254";
+codes[1285] = "windows-1255";
+codes[1286] = "windows-1256";
+codes[1536] = "us-ascii";
+codes[1584] = "GB2312";
+codes[1585] = "gbk";
+codes[1600] = "EUC-KR";
+codes[2080] = "ISO-2022-JP";
+codes[2096] = "ISO-2022-CN";
+codes[2112] = "ISO-2022-KR";
+codes[2336] = "EUC-JP";
+codes[2352] = "GB2312";
+codes[2353] = "x-euc-tw";
+codes[2368] = "EUC-KR";
+codes[2561] = "Shift_JIS";
+codes[2562] = "KOI8-R";
+codes[2563] = "Big5";
+codes[2565] = "HZ-GB-2312";
+if (codes[aCode])
+return codes[aCode];
+// Don't bother being fancy about what to return in the failure case.
+return "windows-1252";
+}
+function fileCharsetFromCode(aCode) {
+const codes = [
+"macintosh",             // 0
+"Shift_JIS",             // 1
+"Big5",                  // 2
+"EUC-KR",                // 3
+"X-MAC-ARABIC",          // 4
+"X-MAC-HEBREW",          // 5
+"X-MAC-GREEK",           // 6
+"X-MAC-CYRILLIC",        // 7
+"X-MAC-DEVANAGARI" ,     // 9
+"X-MAC-GURMUKHI",        // 10
+"X-MAC-GUJARATI",        // 11
+"X-MAC-ORIYA",           // 12
+"X-MAC-BENGALI",         // 13
+"X-MAC-TAMIL",           // 14
+"X-MAC-TELUGU",          // 15
+"X-MAC-KANNADA",         // 16
+"X-MAC-MALAYALAM",       // 17
+"X-MAC-SINHALESE",       // 18
+"X-MAC-BURMESE",         // 19
+"X-MAC-KHMER",           // 20
+"X-MAC-THAI",            // 21
+"X-MAC-LAOTIAN",         // 22
+"X-MAC-GEORGIAN",        // 23
+"X-MAC-ARMENIAN",        // 24
+"GB2312",                // 25
+"X-MAC-TIBETAN",         // 26
+"X-MAC-MONGOLIAN",       // 27
+"X-MAC-ETHIOPIC",        // 28
+"X-MAC-CENTRALEURROMAN", // 29
+"X-MAC-VIETNAMESE",      // 30
+"X-MAC-EXTARABIC"        // 31
+];
+// Sherlock files have always defaulted to macintosh, so do that here too
+return codes[aCode] || codes[0];
+}
+/**
+* Returns a string interpretation of aBytes using aCharset, or null on
+* failure.
+*/
+function bytesToString(aBytes, aCharset) {
+var converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].
+createInstance(Ci.nsIScriptableUnicodeConverter);
+LOG("bytesToString: converting using charset: " + aCharset);
+try {
+converter.charset = aCharset;
+return converter.convertFromByteArray(aBytes, aBytes.length);
+} catch (ex) {}
+return null;
+}
+/**
+* Converts an array of bytes representing a Sherlock file into an array of
+* lines representing the useful data from the file.
+*
+* @param aBytes
+*        The array of bytes representing the Sherlock file.
+* @param aCharsetCode
+*        An integer value representing a character set code to be passed to
+*        fileCharsetFromCode, or null for the default Sherlock encoding.
+*/
+function sherlockBytesToLines(aBytes, aCharsetCode) {
+// fileCharsetFromCode returns the default encoding if aCharsetCode is null
+var charset = fileCharsetFromCode(aCharsetCode);
+var dataString = bytesToString(aBytes, charset);
+if (!dataString)
+FAIL("sherlockBytesToLines: Couldn't convert byte array!", Cr.NS_ERROR_FAILURE);
+// Split the string into lines, and filter out comments and
+// whitespace-only lines
+return dataString.split(NEW_LINES).filter(isUsefulLine);
+}
+/**
+* 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() {
+const localePref = "general.useragent.locale";
+var locale = getLocalizedPref(localePref);
+if (locale)
+return locale;
+// Not localized
+return Services.prefs.getCharPref(localePref);
+}
+/**
+* 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) {
+try {
+return Services.prefs.getBoolPref(aName);
+} catch (ex) {
+return aDefault;
+}
+}
+/**
+* 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, 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)
+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
+*/
+let 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;
+},
+reevalMozParams: function(engine) {
+for (let param of this.params) {
+let mozparam = this.mozparams[param.name];
+if (mozparam && mozparam.positionDependent) {
+// the condition is a string in the form of "topN", extract N as int
+let positionStr = mozparam.condition.slice("top".length);
+let position = parseInt(positionStr, 10);
+let engines;
+try {
+// This will throw if we're not initialized yet (which shouldn't happen), just
+// ignore and move on with the false Value (checking isInitialized also throws)
+// XXX
+engines = Services.search.getVisibleEngines({});
+} catch (ex) {
+LOG("reevalMozParams called before search service initialization!?");
+break;
+}
+let index = engines.map((e) => e.wrappedJSObject).indexOf(engine.wrappedJSObject);
+let isTopN = index > -1 && (index + 1) <= position;
+param.value = isTopN ? mozparam.trueValue : mozparam.falseValue;
+}
+}
+},
+getSubmission: function SRCH_EURL_getSubmission(aSearchTerms, aEngine, aPurpose) {
+this.reevalMozParams(aEngine);
+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 || "";
+// 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);
+},
+_hasRelation: function SRC_EURL__hasRelation(aRel)
+this.rels.some(function(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 == "defaultEngine") {
+if (aEngine._isDefaultEngine())
+this.addParam(param.name, param.trueValue);
+else
+this.addParam(param.name, param.falseValue);
+} else 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.
+**/
+_serializeToJSON: function SRCH_EURL__serializeToJSON() {
+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)
+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 aSourceDataType
+*        The data type of the file used to describe the engine. Must be either
+*        DATA_XML or DATA_TEXT.
+* @param aIsReadOnly
+*        Boolean indicating whether the engine should be treated as read-only.
+*        Read only engines cannot be serialized to file.
+*/
+function Engine(aLocation, aSourceDataType, aIsReadOnly) {
+this._dataType = aSourceDataType;
+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. Is either an array of bytes, for Sherlock
+// files, or an XML document element, for XML plugins.
+_data: null,
+// The engine's data type. See data types (DATA_) defined above.
+_dataType: 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,
+// Whether the engine is hidden from the user.
+_hidden: null,
+// The engine's name.
+_name: null,
+// The engine type. See engine types (TYPE_) defined above.
+_type: 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,
+/**
+* Retrieves the data from the engine's file. If the engine's dataType is
+* XML, the document element is placed in the engine's data field. For text
+* engines, the data is just read directly from file and placed as an array
+* of lines 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, PERMS_FILE, false);
+if (this._dataType == SEARCH_DATA_XML) {
+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;
+} else {
+ERROR("Unsuppored engine _dataType in _initFromFile: \"" +
+this._dataType + "\"",
+Cr.NS_ERROR_UNEXPECTED);
+}
+fileInStream.close();
+// Now that the data is loaded, initialize the engine object
+this._initFromData();
+},
+/**
+* Retrieves the data from the engine's file asynchronously. If the engine's
+* dataType is XML, 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 TaskUtils.spawn(function() {
+if (!this._file || !(yield OS.File.exists(this._file.path)))
+FAIL("File must exist before calling initFromFile!", Cr.NS_ERROR_UNEXPECTED);
+if (this._dataType == SEARCH_DATA_XML) {
+let fileURI = NetUtil.ioService.newFileURI(this._file);
+yield this._retrieveSearchXMLData(fileURI.spec);
+} else {
+ERROR("Unsuppored engine _dataType in _initFromFile: \"" +
+this._dataType + "\"",
+Cr.NS_ERROR_UNEXPECTED);
+}
+// 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.newChannelFromURI(this._uri);
+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 TaskUtils.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("chrome"), "_initFromURISync called for non-chrome URI",
+Cr.NS_ERROR_FAILURE);
+LOG("_initFromURISync: Loading engine from: \"" + this._uri.spec + "\".");
+var chan = NetUtil.ioService.newChannelFromURI(this._uri);
+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;
+}
+switch (aEngine._dataType) {
+case SEARCH_DATA_XML:
+var parser = Cc["@mozilla.org/xmlextras/domparser;1"].
+createInstance(Ci.nsIDOMParser);
+var doc = parser.parseFromBuffer(aBytes, aBytes.length, "text/xml");
+aEngine._data = doc.documentElement;
+break;
+case SEARCH_DATA_TEXT:
+aEngine._data = aBytes;
+break;
+default:
+promptError();
+LOG("_onLoad: Bogus engine _dataType: \"" + this._dataType + "\"");
+return;
+}
+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
+if (!this._readOnly ||
+getBoolPref(BROWSER_SEARCH_PREF + "cache.enabled", true)) {
+LOG("_setIcon: Downloading icon: \"" + uri.spec +
+"\" for engine: \"" + this.name + "\"");
+var chan = NetUtil.ioService.newChannelFromURI(uri);
+function iconLoadCallback(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);
+// Find out what type of engine we are
+switch (this._dataType) {
+case SEARCH_DATA_XML:
+if (checkNameSpace(this._data, [MOZSEARCH_LOCALNAME],
+[MOZSEARCH_NS_10])) {
+LOG("_init: Initing MozSearch plugin from " + this._location);
+this._type = SEARCH_TYPE_MOZSEARCH;
+this._parseAsMozSearch();
+} else if (checkNameSpace(this._data, [OPENSEARCH_LOCALNAME],
+OPENSEARCH_NAMESPACES)) {
+LOG("_init: Initing OpenSearch plugin from " + this._location);
+this._type = SEARCH_TYPE_OPENSEARCH;
+this._parseAsOpenSearch();
+} else
+FAIL(this._location + " is not a valid search plugin.", Cr.NS_ERROR_FAILURE);
+break;
+case SEARCH_DATA_TEXT:
+LOG("_init: Initing Sherlock plugin from " + this._location);
+// the only text-based format we support is Sherlock
+this._type = SEARCH_TYPE_SHERLOCK;
+this._parseAsSherlock();
+}
+// 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) {
+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._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 "defaultEngine":
+// If this engine was the default search engine, use the true value
+if (this._isDefaultEngine())
+value = param.getAttribute("trueValue");
+else
+value = param.getAttribute("falseValue");
+url.addParam(param.getAttribute("name"), value);
+url._addMozParam({"name": param.getAttribute("name"),
+"falseValue": param.getAttribute("falseValue"),
+"trueValue": param.getAttribute("trueValue"),
+"condition": "defaultEngine"});
+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:
+if (condition && condition.startsWith("top")) {
+url.addParam(param.getAttribute("name"), param.getAttribute("falseValue"));
+let mozparam = {"name": param.getAttribute("name"),
+"falseValue": param.getAttribute("falseValue"),
+"trueValue": param.getAttribute("trueValue"),
+"condition": condition,
+"positionDependent": true};
+url._addMozParam(mozparam);
+}
+break;
+}
+}
+}
+this._urls.push(url);
+},
+_isDefaultEngine: function SRCH_ENG__isDefaultEngine() {
+let defaultPrefB = Services.prefs.getDefaultBranch(BROWSER_SEARCH_PREF);
+let nsIPLS = Ci.nsIPrefLocalizedString;
+let defaultEngine;
+try {
+defaultEngine = defaultPrefB.getComplexValue("defaultenginename", nsIPLS).data;
+} catch (ex) {}
+return this.name == defaultEngine;
+},
+/**
+* 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);
+},
+_parseAsMozSearch: function SRCH_ENG_parseAsMoz() {
+//forward to the OpenSearch parser
+this._parseAsOpenSearch();
+},
+/**
+* Extract search engine information from the collected data to initialize
+* the engine object.
+*/
+_parseAsOpenSearch: function SRCH_ENG_parseAsOS() {
+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("_parseAsOpenSearch: 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;
+}
+}
+if (!this.name || (this._urls.length == 0))
+FAIL("_parseAsOpenSearch: No name, or missing URL!", Cr.NS_ERROR_FAILURE);
+if (!this.supportsResponseType(URLTYPE_SEARCH_HTML))
+FAIL("_parseAsOpenSearch: No text/html result type!", Cr.NS_ERROR_FAILURE);
+},
+/**
+* Extract search engine information from the collected data to initialize
+* the engine object.
+*/
+_parseAsSherlock: function SRCH_ENG_parseAsSherlock() {
+/**
+* Extracts one Sherlock "section" from aSource. A section is essentially
+* an HTML element with attributes, but each attribute must be on a new
+* line, by definition.
+*
+* @param aLines
+*        An array of lines from the sherlock file.
+* @param aSection
+*        The name of the section (e.g. "search" or "browser"). This value
+*        is not case sensitive.
+* @returns an object whose properties correspond to the section's
+*          attributes.
+*/
+function getSection(aLines, aSection) {
+LOG("_parseAsSherlock::getSection: Sherlock lines:\n" +
+aLines.join("\n"));
+var lines = aLines;
+var startMark = new RegExp("^\\s*<" + aSection.toLowerCase() + "\\s*",
+"gi");
+var endMark   = /\s*>\s*$/gi;
+var foundStart = false;
+var startLine, numberOfLines;
+// Find the beginning and end of the section
+for (var i = 0; i < lines.length; i++) {
+if (foundStart) {
+if (endMark.test(lines[i])) {
+numberOfLines = i - startLine;
+// Remove the end marker
+lines[i] = lines[i].replace(endMark, "");
+// If the endmarker was not the only thing on the line, include
+// this line in the results
+if (lines[i])
+numberOfLines++;
+break;
+}
+} else {
+if (startMark.test(lines[i])) {
+foundStart = true;
+// Remove the start marker
+lines[i] = lines[i].replace(startMark, "");
+startLine = i;
+// If the line is empty, don't include it in the result
+if (!lines[i])
+startLine++;
+}
+}
+}
+LOG("_parseAsSherlock::getSection: Start index: " + startLine +
+"\nNumber of lines: " + numberOfLines);
+lines = lines.splice(startLine, numberOfLines);
+LOG("_parseAsSherlock::getSection: Section lines:\n" +
+lines.join("\n"));
+var section = {};
+for (var i = 0; i < lines.length; i++) {
+var line = lines[i].trim();
+var els = line.split("=");
+var name = els.shift().trim().toLowerCase();
+var value = els.join("=").trim();
+if (!name || !value)
+continue;
+// Strip leading and trailing whitespace, remove quotes from the
+// value, and remove any trailing slashes or ">" characters
+value = value.replace(/^["']/, "")
+.replace(/["']\s*[\\\/]?>?\s*$/, "") || "";
+value = value.trim();
+// Don't clobber existing attributes
+if (!(name in section))
+section[name] = value;
+}
+return section;
+}
+/**
+* Returns an array of name-value pair arrays representing the Sherlock
+* file's input elements. User defined inputs return USER_DEFINED
+* as the value. Elements are returned in the order they appear in the
+* source file.
+*
+*   Example:
+*      <input name="foo" value="bar">
+*      <input name="foopy" user>
+*   Returns:
+*      [["foo", "bar"], ["foopy", "{searchTerms}"]]
+*
+* @param aLines
+*        An array of lines from the source file.
+*/
+function getInputs(aLines) {
+/**
+* Extracts an attribute value from a given a line of text.
+*    Example: <input value="foo" name="bar">
+*      Extracts the string |foo| or |bar| given an input aAttr of
+*      |value| or |name|.
+* Attributes may be quoted or unquoted. If unquoted, any whitespace
+* indicates the end of the attribute value.
+*    Example: < value=22 33 name=44\334 >
+*      Returns |22| for "value" and |44\334| for "name".
+*
+* @param aAttr
+*        The name of the attribute for which to obtain the value. This
+*        value is not case sensitive.
+* @param aLine
+*        The line containing the attribute.
+*
+* @returns the attribute value, or an empty string if the attribute
+*          doesn't exist.
+*/
+function getAttr(aAttr, aLine) {
+// Used to determine whether an "input" line from a Sherlock file is a
+// "user defined" input.
+const userInput = /(\s|["'=])user(\s|[>="'\/\\+]|$)/i;
+LOG("_parseAsSherlock::getAttr: Getting attr: \"" +
+aAttr + "\" for line: \"" + aLine + "\"");
+// We're not case sensitive, but we want to return the attribute value
+// in its original case, so create a copy of the source
+var lLine = aLine.toLowerCase();
+var attr = aAttr.toLowerCase();
+var attrStart = lLine.search(new RegExp("\\s" + attr, "i"));
+if (attrStart == -1) {
+// If this is the "user defined input" (i.e. contains the empty
+// "user" attribute), return our special keyword
+if (userInput.test(lLine) && attr == "value") {
+LOG("_parseAsSherlock::getAttr: Found user input!\nLine:\"" + lLine
++ "\"");
+return USER_DEFINED;
+}
+// The attribute doesn't exist - ignore
+LOG("_parseAsSherlock::getAttr: Failed to find attribute:\nLine:\""
++ lLine + "\"\nAttr:\"" + attr + "\"");
+return "";
+}
+var valueStart = lLine.indexOf("=", attrStart) + "=".length;
+if (valueStart == -1)
+return "";
+var quoteStart = lLine.indexOf("\"", valueStart);
+if (quoteStart == -1) {
+// Unquoted attribute, get the rest of the line, trimmed at the first
+// sign of whitespace. If the rest of the line is only whitespace,
+// returns a blank string.
+return lLine.substr(valueStart).replace(/\s.*$/, "");
+} else {
+// Make sure that there's only whitespace between the start of the
+// value and the first quote. If there is, end the attribute value at
+// the first sign of whitespace. This prevents us from falling into
+// the next attribute if this is an unquoted attribute followed by a
+// quoted attribute.
+var betweenEqualAndQuote = lLine.substring(valueStart, quoteStart);
+if (/\S/.test(betweenEqualAndQuote))
+return lLine.substr(valueStart).replace(/\s.*$/, "");
+// Adjust the start index to account for the opening quote
+valueStart = quoteStart + "\"".length;
+// Find the closing quote
+var valueEnd = lLine.indexOf("\"", valueStart);
+// If there is no closing quote, just go to the end of the line
+if (valueEnd == -1)
+valueEnd = aLine.length;
+}
+return aLine.substring(valueStart, valueEnd);
+}
+var inputs = [];
+LOG("_parseAsSherlock::getInputs: Lines:\n" + aLines);
+// Filter out everything but non-inputs
+let lines = aLines.filter(function (line) {
+return /^\s*<input/i.test(line);
+});
+LOG("_parseAsSherlock::getInputs: Filtered lines:\n" + lines);
+lines.forEach(function (line) {
+// Strip leading/trailing whitespace and remove the surrounding markup
+// ("<input" and ">")
+line = line.trim().replace(/^<input/i, "").replace(/>$/, "");
+// If this is one of the "directional" inputs (<inputnext>/<inputprev>)
+const directionalInput = /^(prev|next)/i;
+if (directionalInput.test(line)) {
+// Make it look like a normal input by removing "prev" or "next"
+line = line.replace(directionalInput, "");
+// If it has a name, give it a dummy value to match previous
+// nsInternetSearchService behavior
+if (/name\s*=/i.test(line)) {
+line += " value=\"0\"";
+} else
+return; // Line has no name, skip it
+}
+var attrName = getAttr("name", line);
+var attrValue = getAttr("value", line);
+LOG("_parseAsSherlock::getInputs: Got input:\nName:\"" + attrName +
+"\"\nValue:\"" + attrValue + "\"");
+if (attrValue)
+inputs.push([attrName, attrValue]);
+});
+return inputs;
+}
+function err(aErr) {
+FAIL("_parseAsSherlock::err: Sherlock param error:\n" + aErr,
+Cr.NS_ERROR_FAILURE);
+}
+// First try converting our byte array using the default Sherlock encoding.
+// If this fails, or if we find a sourceTextEncoding attribute, we need to
+// reconvert the byte array using the specified encoding.
+var sherlockLines, searchSection, sourceTextEncoding, browserSection;
+try {
+sherlockLines = sherlockBytesToLines(this._data);
+searchSection = getSection(sherlockLines, "search");
+browserSection = getSection(sherlockLines, "browser");
+sourceTextEncoding = parseInt(searchSection["sourcetextencoding"]);
+if (sourceTextEncoding) {
+// Re-convert the bytes using the found sourceTextEncoding
+sherlockLines = sherlockBytesToLines(this._data, sourceTextEncoding);
+searchSection = getSection(sherlockLines, "search");
+browserSection = getSection(sherlockLines, "browser");
+}
+} catch (ex) {
+// The conversion using the default charset failed. Remove any non-ascii
+// bytes and try to find a sourceTextEncoding.
+var asciiBytes = this._data.filter(function (n) {return !(0x80 & n);});
+var asciiString = String.fromCharCode.apply(null, asciiBytes);
+sherlockLines = asciiString.split(NEW_LINES).filter(isUsefulLine);
+searchSection = getSection(sherlockLines, "search");
+sourceTextEncoding = parseInt(searchSection["sourcetextencoding"]);
+if (sourceTextEncoding) {
+sherlockLines = sherlockBytesToLines(this._data, sourceTextEncoding);
+searchSection = getSection(sherlockLines, "search");
+browserSection = getSection(sherlockLines, "browser");
+} else
+ERROR("Couldn't find a working charset", Cr.NS_ERROR_FAILURE);
+}
+LOG("_parseAsSherlock: Search section:\n" + searchSection.toSource());
+this._name = searchSection["name"] || err("Missing name!");
+this._description = searchSection["description"] || "";
+this._queryCharset = searchSection["querycharset"] ||
+queryCharsetFromCode(searchSection["queryencoding"]);
+this._searchForm = searchSection["searchform"];
+this._updateInterval = parseInt(browserSection["updatecheckdays"]);
+this._updateURL = browserSection["update"];
+this._iconUpdateURL = browserSection["updateicon"];
+var method = (searchSection["method"] || "GET").toUpperCase();
+var template = searchSection["action"] || err("Missing action!");
+var inputs = getInputs(sherlockLines);
+LOG("_parseAsSherlock: Inputs:\n" + inputs.toSource());
+var url = null;
+if (method == "GET") {
+// Here's how we construct the input string:
+// <input> is first:  Name Attr:  Prefix      Data           Example:
+// YES                EMPTY       None        <value>        TEMPLATE<value>
+// YES                NON-EMPTY   ?           <name>=<value> TEMPLATE?<name>=<value>
+// NO                 EMPTY       ------------- <ignored> --------------
+// NO                 NON-EMPTY   &           <name>=<value> TEMPLATE?<n1>=<v1>&<n2>=<v2>
+for (var i = 0; i < inputs.length; i++) {
+var name  = inputs[i][0];
+var value = inputs[i][1];
+if (i==0) {
+if (name == "")
+template += USER_DEFINED;
+else
+template += "?" + name + "=" + value;
+} else if (name != "")
+template += "&" + name + "=" + value;
+}
+url = new EngineURL(URLTYPE_SEARCH_HTML, method, template);
+} else if (method == "POST") {
+// Create the URL object and just add the parameters directly
+url = new EngineURL(URLTYPE_SEARCH_HTML, method, template);
+for (var i = 0; i < inputs.length; i++) {
+var name  = inputs[i][0];
+var value = inputs[i][1];
+if (name)
+url.addParam(name, value);
+}
+} else
+err("Invalid method!");
+this._urls.push(url);
+},
+/**
+* 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._hidden = aJson._hidden;
+this._type = aJson.type || SEARCH_TYPE_MOZSEARCH;
+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;
+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.
+* @param aFilter
+*        Whether or not to filter out common default values. Recommended for
+*        use with _initWithJSON().
+* @returns An object suitable for serialization as JSON.
+**/
+_serializeToJSON: function SRCH_ENG__serializeToJSON(aFilter) {
+var json = {
+_id: this._id,
+_name: this._name,
+_hidden: this.hidden,
+description: this.description,
+__searchForm: this.__searchForm,
+_iconURL: this._iconURL,
+_iconMapObj: this._iconMapObj,
+_urls: [url._serializeToJSON() for each(url in 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 || !aFilter)
+json._installLocation = this._installLocation;
+if (this._updateInterval || !aFilter)
+json._updateInterval = this._updateInterval;
+if (this._updateURL || !aFilter)
+json._updateURL = this._updateURL;
+if (this._iconUpdateURL || !aFilter)
+json._iconUpdateURL = this._iconUpdateURL;
+if (!this._hasPreferredIcon || !aFilter)
+json._hasPreferredIcon = this._hasPreferredIcon;
+if (this.type != SEARCH_TYPE_MOZSEARCH || !aFilter)
+json.type = this.type;
+if (this.queryCharset != DEFAULT_QUERY_CHARSET || !aFilter)
+json.queryCharset = this.queryCharset;
+if (this._dataType != SEARCH_DATA_XML || !aFilter)
+json._dataType = this._dataType;
+if (!this._readOnly || !aFilter)
+json._readOnly = this._readOnly;
+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);
+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), 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() {
+if (this._hidden === null)
+this._hidden = engineMetadataService.getAttr(this, "hidden") || false;
+return this._hidden;
+},
+set hidden(val) {
+var value = !!val;
+if (value != this._hidden) {
+this._hidden = value;
+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;
+},
+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 type() {
+return this._type;
+},
+get searchForm() {
+// First look for a <Url rel="searchform">
+var searchFormURL = this._getURLOfType(URLTYPE_SEARCH_HTML, "searchform");
+if (searchFormURL) {
+let submission = searchFormURL.getSubmission("", this);
+// 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 = queryCharsetFromCode(/* get 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.searchForm), null);
+}
+LOG("getSubmission: In data: \"" + aData + "\"; Purpose: \"" + aPurpose + "\"");
+var textToSubURI = Cc["@mozilla.org/intl/texttosuburi;1"].
+getService(Ci.nsITextToSubURI);
+var data = "";
+try {
+data = textToSubURI.ConvertAndEscape(this.queryCharset, aData);
+} catch (ex) {
+LOG("getSubmission: Falling back to default queryCharset!");
+data = textToSubURI.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 "";
+},
+// 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;
+}
+};
+// 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;
+}
+}
+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.";
+// Bug 785487 - Disable warning until our own callers are fixed.
+//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;
+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() {
+return TaskUtils.spawn(function() {
+LOG("_asyncInit start");
+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,
+get _sortedEngines() {
+if (!this.__sortedEngines)
+return this._buildSortedEngineList();
+return this.__sortedEngines;
+},
+// Get the original Engine object that belongs to the defaultenginename pref
+// of the default branch.
+get _originalDefaultEngine() {
+let defaultPrefB = Services.prefs.getDefaultBranch(BROWSER_SEARCH_PREF);
+let nsIPLS = Ci.nsIPrefLocalizedString;
+let defaultEngine;
+try {
+defaultEngine = defaultPrefB.getComplexValue("defaultenginename", 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);
+},
+_buildCache: function SRCH_SVC__buildCache() {
+if (!getBoolPref(BROWSER_SEARCH_PREF + "cache.enabled", true))
+return;
+TelemetryStopwatch.start("SEARCH_SERVICE_BUILD_CACHE_MS");
+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 = {};
+function getParent(engine) {
+if (engine._file)
+return engine._file.parent;
+let uri = engine._uri;
+if (!uri.schemeIs("chrome")) {
+LOG("getParent: engine URI must be a chrome URI if it has no file");
+return null;
+}
+// use the underlying JAR file, for chrome URIs
+try {
+uri = gChromeReg.convertChromeURL(uri);
+if (uri instanceof Ci.nsINestedURI)
+uri = uri.innermostURI;
+uri.QueryInterface(Ci.nsIFileURL)
+return uri.file;
+} catch (ex) {
+LOG("getParent: couldn't map chrome:// URI to a file: " + ex)
+}
+return null;
+}
+for each (let engine in this._engines) {
+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._serializeToJSON(true));
+}
+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);
+}
+TelemetryStopwatch.finish("SEARCH_SERVICE_BUILD_CACHE_MS");
+},
+_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 cacheEnabled = getBoolPref(BROWSER_SEARCH_PREF + "cache.enabled", true);
+if (cacheEnabled) {
+let cacheFile = getDir(NS_APP_USER_PROFILE_50_DIR);
+cacheFile.append("search.json");
+if (cacheFile.exists())
+cache = this._readCacheFile(cacheFile);
+}
+let loadDirs = [];
+let locations = getDir(NS_APP_SEARCH_DIR_LIST, Ci.nsISimpleEnumerator);
+while (locations.hasMoreElements()) {
+let dir = locations.getNext().QueryInterface(Ci.nsIFile);
+if (dir.directoryEntries.hasMoreElements())
+loadDirs.push(dir);
+}
+let loadFromJARs = getBoolPref(BROWSER_SEARCH_PREF + "loadFromJars", false);
+let chromeURIs = [];
+let chromeFiles = [];
+if (loadFromJARs)
+[chromeFiles, chromeURIs] = this._findJAREngines();
+let toLoad = chromeFiles.concat(loadDirs);
+function modifiedDir(aDir) {
+return (!cache.directories || !cache.directories[aDir.path] ||
+cache.directories[aDir.path].lastModifiedTime != aDir.lastModifiedTime);
+}
+function notInCachePath(aPathToLoad)
+cachePaths.indexOf(aPathToLoad.path) == -1;
+let buildID = Services.appinfo.platformBuildID;
+let cachePaths = [path for (path in cache.directories)];
+let rebuildCache = !cache.directories ||
+cache.version != CACHE_VERSION ||
+cache.locale != getLocale() ||
+cache.buildID != buildID ||
+cachePaths.length != toLoad.length ||
+toLoad.some(notInCachePath) ||
+toLoad.some(modifiedDir);
+if (!cacheEnabled || rebuildCache) {
+LOG("_loadEngines: Absent or outdated cache. Loading engines from disk.");
+loadDirs.forEach(this._loadEnginesFromDir, this);
+this._loadFromChromeURLs(chromeURIs);
+if (cacheEnabled)
+this._buildCache();
+return;
+}
+LOG("_loadEngines: loading from cache directories");
+for each (let dir in cache.directories)
+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 TaskUtils.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 cacheEnabled = getBoolPref(BROWSER_SEARCH_PREF + "cache.enabled", true);
+if (cacheEnabled) {
+let cacheFilePath = OS.Path.join(OS.Constants.Path.profileDir, "search.json");
+cache = yield checkForSyncCompletion(this._asyncReadCacheFile(cacheFilePath));
+}
+// Add all the non-empty directories of NS_APP_SEARCH_DIR_LIST to
+// loadDirs.
+let loadDirs = [];
+let 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 loadDirs if it contains any files.
+yield checkForSyncCompletion(iterator.next());
+loadDirs.push(dir);
+} catch (ex if ex.result != Cr.NS_ERROR_ALREADY_INITIALIZED) {
+// Catch for StopIteration exception.
+} finally {
+iterator.close();
+}
+}
+let loadFromJARs = getBoolPref(BROWSER_SEARCH_PREF + "loadFromJars", false);
+let chromeURIs = [];
+let chromeFiles = [];
+if (loadFromJARs) {
+Services.obs.notifyObservers(null, SEARCH_SERVICE_TOPIC, "find-jar-engines");
+[chromeFiles, chromeURIs] =
+yield checkForSyncCompletion(this._asyncFindJAREngines());
+}
+let toLoad = chromeFiles.concat(loadDirs);
+function hasModifiedDir(aList) {
+return TaskUtils.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)
+cachePaths.indexOf(aPathToLoad.path) == -1;
+let buildID = Services.appinfo.platformBuildID;
+let cachePaths = [path for (path in cache.directories)];
+let rebuildCache = !cache.directories ||
+cache.version != CACHE_VERSION ||
+cache.locale != getLocale() ||
+cache.buildID != buildID ||
+cachePaths.length != toLoad.length ||
+toLoad.some(notInCachePath) ||
+(yield checkForSyncCompletion(hasModifiedDir(toLoad)));
+if (!cacheEnabled || rebuildCache) {
+LOG("_asyncLoadEngines: Absent or outdated cache. Loading engines from disk.");
+let engines = [];
+for (let loadDir of loadDirs) {
+let enginesFromDir =
+yield checkForSyncCompletion(this._asyncLoadEnginesFromDir(loadDir));
+engines = engines.concat(enginesFromDir);
+}
+let enginesFromURLs =
+yield checkForSyncCompletion(this._asyncLoadFromChromeURLs(chromeURIs));
+engines = engines.concat(enginesFromURLs);
+for (let engine of engines) {
+this._addEngineToStore(engine);
+}
+if (cacheEnabled)
+this._buildCache();
+return;
+}
+LOG("_asyncLoadEngines: loading from cache directories");
+for each (let dir in cache.directories)
+this._loadEnginesFromCache(dir);
+LOG("_asyncLoadEngines: done");
+}.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, 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 TaskUtils.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);
+// We need to save the engine's _dataType, if this is the first time the
+// engine is added to the dataStore, since ._dataType isn't persisted
+// and will change on the next startup (since the engine will then be
+// XML). We need this so that we know how to load any future updates from
+// this engine.
+if (!engineMetadataService.getAttr(aEngine, "updatedatatype"))
+engineMetadataService.setAttr(aEngine, "updatedatatype",
+aEngine._dataType);
+}
+},
+_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._dataType,
+json._readOnly);
+else if (json._url)
+engine = new Engine({type: "uri", value: json._url}, json._dataType, 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, SEARCH_DATA_XML, !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 TaskUtils.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, SEARCH_DATA_XML, !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), SEARCH_DATA_XML, 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 TaskUtils.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), SEARCH_DATA_XML, 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));
+},
+_findJAREngines: function SRCH_SVC_findJAREngines() {
+LOG("_findJAREngines: looking for engines in JARs")
+let rootURIPref = ""
+try {
+rootURIPref = Services.prefs.getCharPref(BROWSER_SEARCH_PREF + "jarURIs");
+} catch (ex) {}
+if (!rootURIPref) {
+LOG("_findJAREngines: no JAR URIs were specified");
+return [[], []];
+}
+let rootURIs = rootURIPref.split(",");
+let uris = [];
+let chromeFiles = [];
+rootURIs.forEach(function (root) {
+// Find the underlying JAR file for this chrome package (_loadEngines uses
+// it to determine whether it needs to invalidate the cache)
+let chromeFile;
+try {
+let chromeURI = gChromeReg.convertChromeURL(makeURI(root));
+let fileURI = chromeURI; // flat packaging
+while (fileURI instanceof Ci.nsIJARURI)
+fileURI = fileURI.JARFile; // JAR packaging
+fileURI.QueryInterface(Ci.nsIFileURL);
+chromeFile = fileURI.file;
+} catch (ex) {
+LOG("_findJAREngines: failed to get chromeFile for " + root + ": " + ex);
+}
+if (!chromeFile)
+return;
+chromeFiles.push(chromeFile);
+// Read list.txt from the chrome package to find the engines we need to
+// load
+let listURL = root + "list.txt";
+let names = [];
+try {
+let chan = NetUtil.ioService.newChannelFromURI(makeURI(listURL));
+let sis = Cc["@mozilla.org/scriptableinputstream;1"].
+createInstance(Ci.nsIScriptableInputStream);
+sis.init(chan.open());
+let list = sis.read(sis.available());
+names = list.split("\n").filter(function (n) !!n);
+} catch (ex) {
+LOG("_findJAREngines: failed to retrieve list.txt from " + listURL + ": " + ex);
+return;
+}
+names.forEach(function (n) uris.push(root + n + ".xml"));
+});
+return [chromeFiles, uris];
+},
+/**
+* Loads jar engines asynchronously.
+*
+* @returns {Promise} A promise, resolved successfully if finding jar engines
+* succeeds.
+*/
+_asyncFindJAREngines: function SRCH_SVC__asyncFindJAREngines() {
+return TaskUtils.spawn(function() {
+LOG("_asyncFindJAREngines: looking for engines in JARs")
+let rootURIPref = "";
+try {
+rootURIPref = Services.prefs.getCharPref(BROWSER_SEARCH_PREF + "jarURIs");
+} catch (ex) {}
+if (!rootURIPref) {
+LOG("_asyncFindJAREngines: no JAR URIs were specified");
+throw new Task.Result([[], []]);
+}
+let rootURIs = rootURIPref.split(",");
+let uris = [];
+let chromeFiles = [];
+for (let root of rootURIs) {
+// Find the underlying JAR file for this chrome package (_loadEngines uses
+// it to determine whether it needs to invalidate the cache)
+let chromeFile;
+try {
+let chromeURI = gChromeReg.convertChromeURL(makeURI(root));
+let fileURI = chromeURI; // flat packaging
+while (fileURI instanceof Ci.nsIJARURI)
+fileURI = fileURI.JARFile; // JAR packaging
+fileURI.QueryInterface(Ci.nsIFileURL);
+chromeFile = fileURI.file;
+} catch (ex) {
+LOG("_asyncFindJAREngines: failed to get chromeFile for " + root + ": " + ex);
+}
+if (!chromeFile) {
+return;
+}
+chromeFiles.push(chromeFile);
+// Read list.txt from the chrome package to find the engines we need to
+// load
+let listURL = root + "list.txt";
+let deferred = Promise.defer();
+let request = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].
+createInstance(Ci.nsIXMLHttpRequest);
+request.onload = function(aEvent) {
+deferred.resolve(aEvent.target.responseText);
+};
+request.onerror = function(aEvent) {
+LOG("_asyncFindJAREngines: failed to retrieve list.txt from " + listURL);
+deferred.resolve("");
+};
+request.open("GET", NetUtil.newURI(listURL).spec, true);
+request.send();
+let list = yield deferred.promise;
+let names = [];
+names = list.split("\n").filter(function (n) !!n);
+names.forEach(function (n) uris.push(root + n + ".xml"));
+}
+throw new Task.Result([chromeFiles, uris]);
+});
+},
+_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 each (engine in this._engines) {
+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 each (prefName in 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) { }
+while (true) {
+engineName = getLocalizedPref(BROWSER_SEARCH_PREF + "order." + (++i));
+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
+var alphaEngines = [];
+for each (engine in this._engines) {
+if (!(engine.name in addedEngines))
+alphaEngines.push(this._engines[engine.name]);
+}
+alphaEngines = alphaEngines.sort(function (a, b) {
+return a.name.localeCompare(b.name);
+});
+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;
+});
+},
+_setEngineByPref: function SRCH_SVC_setEngineByPref(aEngineType, aPref) {
+this._ensureInitialized();
+let newEngine = this.getEngineByName(getLocalizedPref(aPref, ""));
+if (!newEngine)
+FAIL("Can't find engine in store!", Cr.NS_ERROR_UNEXPECTED);
+this[aEngineType] = newEngine;
+},
+// nsIBrowserSearchService
+init: function SRCH_SVC_init(observer) {
+LOG("SearchService.init");
+let self = this;
+if (!this._initStarted) {
+TelemetryStopwatch.start("SEARCH_SERVICE_INIT_MS");
+this._initStarted = true;
+TaskUtils.spawn(function task() {
+try {
+yield checkForSyncCompletion(engineMetadataService.init());
+// Complete initialization by calling asynchronous initializer.
+yield self._asyncInit();
+TelemetryStopwatch.finish("SEARCH_SERVICE_INIT_MS");
+} catch (ex if ex.result == Cr.NS_ERROR_ALREADY_INITIALIZED) {
+// No need to pursue asynchronous because synchronous fallback was
+// called and has finished.
+TelemetryStopwatch.finish("SEARCH_SERVICE_INIT_MS");
+} catch (ex) {
+self._initObservers.reject(ex);
+TelemetryStopwatch.cancel("SEARCH_SERVICE_INIT_MS");
+}
+});
+}
+if (observer) {
+TaskUtils.captureErrors(this._initObservers.promise.then(
+function onSuccess() {
+observer.onInitComplete(self._initRV);
+},
+function onError(aReason) {
+Components.utils.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 each (var prefName in 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.
+for (var j = 1; ; j++) {
+engineName = getLocalizedPref(BROWSER_SEARCH_PREF + "order." + j);
+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) {
+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), SEARCH_DATA_XML, false);
+engine._initFromMetadata(aName, aIconURL, aAlias, aDescription,
+aMethod, aTemplate);
+this._addEngineToStore(engine);
+this.batchTask.disarm();
+this.batchTask.arm();
+},
+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, aDataType, 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 each (var e in this._engines) {
+// Unhide all default engines
+if (e.hidden && e._isDefault)
+e.hidden = false;
+}
+},
+get defaultEngine() {
+this._ensureInitialized();
+if (!this._defaultEngine) {
+let defPref = 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;
+// Set a flag to keep track that this setter was called properly, not by
+// setting the pref alone.
+this._changingDefaultEngine = true;
+let defPref = 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);
+}
+this._changingDefaultEngine = false;
+notifyAction(this._defaultEngine, SEARCH_ENGINE_DEFAULT);
+},
+get currentEngine() {
+this._ensureInitialized();
+if (!this._currentEngine) {
+let selectedEngine = getLocalizedPref(BROWSER_SEARCH_PREF +
+"selectedEngine");
+this._currentEngine = this.getEngineByName(selectedEngine);
+}
+if (!this._currentEngine || this._currentEngine.hidden)
+this._currentEngine = this.defaultEngine;
+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;
+var currentEnginePref = BROWSER_SEARCH_PREF + "selectedEngine";
+// Set a flag to keep track that this setter was called properly, not by
+// setting the pref alone.
+this._changingCurrentEngine = true;
+// 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.
+if (this._currentEngine == this._originalDefaultEngine) {
+Services.prefs.clearUserPref(currentEnginePref);
+}
+else {
+setLocalizedPref(currentEnginePref, this._currentEngine.name);
+}
+this._changingCurrentEngine = false;
+notifyAction(this._currentEngine, SEARCH_ENGINE_CURRENT);
+},
+// 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;
+}
+this.batchTask.disarm();
+this.batchTask.arm();
+break;
+case SEARCH_ENGINE_CHANGED:
+case SEARCH_ENGINE_REMOVED:
+this.batchTask.disarm();
+this.batchTask.arm();
+break;
+}
+break;
+case QUIT_APPLICATION_TOPIC:
+this._removeObservers();
+break;
+case "nsPref:changed":
+let currPref = BROWSER_SEARCH_PREF + "selectedEngine";
+let defPref = BROWSER_SEARCH_PREF + "defaultenginename";
+if (aVerb == currPref && !this._changingCurrentEngine) {
+this._setEngineByPref("currentEngine", currPref);
+} else if (aVerb == defPref && !this._changingDefaultEngine) {
+this._setEngineByPref("defaultEngine", defPref);
+}
+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 each (engine in this._engines) {
+engine = engine.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);
+Services.prefs.addObserver(BROWSER_SEARCH_PREF + "defaultenginename", this, false);
+Services.prefs.addObserver(BROWSER_SEARCH_PREF + "selectedEngine", this, false);
+AsyncShutdown.profileBeforeChange.addBlocker(
+"Search service: shutting down",
+() => Task.spawn(function () {
+if (this._batchTask) {
+yield this._batchTask.finalize().then(null, Cu.reportError);
+}
+yield engineMetadataService.finalize();
+}.bind(this))
+);
+},
+_removeObservers: function SRCH_SVC_removeObservers() {
+Services.obs.removeObserver(this, SEARCH_ENGINE_TOPIC);
+Services.obs.removeObserver(this, QUIT_APPLICATION_TOPIC);
+Services.prefs.removeObserver(BROWSER_SEARCH_PREF + "defaultenginename", this);
+Services.prefs.removeObserver(BROWSER_SEARCH_PREF + "selectedEngine", this);
+},
+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"),
+/**
+* Possible values for |_initState|.
+*
+* We have two paths to perform initialization: a default asynchronous
+* path and a fallback synchronous path that can interrupt the async
+* path. For this reason, initialization is actually something of a
+* finite state machine, represented with the following states:
+*
+* @enum
+*/
+_InitStates: {
+NOT_STARTED: "NOT_STARTED"
+/**Initialization has not started*/,
+FINISHED_SUCCESS: "FINISHED_SUCCESS"
+/**Setup complete, with a success*/
+},
+/**
+* The latest step completed by initialization. One of |InitStates|
+*
+* @type {engineMetadataService._InitStates}
+*/
+_initState: null,
+// 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();
+TaskUtils.spawn((function task_init() {
+LOG("metadata init: starting");
+switch (this._initState) {
+case engineMetadataService._InitStates.NOT_STARTED:
+// 1. Load json file if it exists
+try {
+let contents = yield OS.File.read(this._jsonFile);
+if (this._initState == engineMetadataService._InitStates.FINISHED_SUCCESS) {
+// 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._initState == engineMetadataService._InitStates.FINISHED_SUCCESS) {
+// 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 = {};
+}
+break;
+default:
+throw new Error("metadata init: invalid state " + this._initState);
+}
+this._initState = this._InitStates.FINISHED_SUCCESS;
+LOG("metadata init: complete");
+}).bind(this)).then(
+// 3. Inform any observers
+function onSuccess() {
+initializer.resolve();
+},
+function onError() {
+initializer.reject();
+}
+);
+}
+return TaskUtils.captureErrors(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._initState == engineMetadataService._InitStates.FINISHED_SUCCESS) {
+return;
+}
+switch (this._initState) {
+case engineMetadataService._InitStates.NOT_STARTED:
+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.newChannelFromURI(uri).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._initState = this._InitStates.FINISHED_SUCCESS;
+break;
+default:
+throw new Error("metadata syncInit: invalid state " + this._initState);
+}
+// 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];
+},
+_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();
+}
+},
+/**
+* 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 () 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.
+*
+* @param aStore is an optional parameter specifying the object to serialize.
+*               If not specified, this._store is used.
+*/
+_commit: function epsCommit(aStore) {
+LOG("metadata _commit: start");
+let store = aStore || this._store;
+if (!store) {
+LOG("metadata _commit: nothing to do");
+return;
+}
+if (!this._lazyWriter) {
+LOG("metadata _commit: initializing lazy writer");
+function writeCommit() {
+LOG("metadata writeCommit: start");
+let data = gEncoder.encode(JSON.stringify(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");
+}
+);
+// Use our error logging instead of the default one.
+return TaskUtils.captureErrors(promise).then(null, () => {});
+}
+this._lazyWriter = new DeferredTask(writeCommit, LAZY_SERIALIZE_DELAY);
+}
+LOG("metadata _commit: (re)setting timer");
+this._lazyWriter.disarm();
+this._lazyWriter.arm();
+},
+_lazyWriter: null
+};
+engineMetadataService._initState = engineMetadataService._InitStates.NOT_STARTED;
+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;
+// We use the cache to store updated app engines, so refuse to update if the
+// cache is disabled.
+if (engine._readOnly &&
+!getBoolPref(BROWSER_SEARCH_PREF + "cache.enabled", true))
+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;
+}
+let dataType = engineMetadataService.getAttr(engine, "updatedatatype");
+if (!dataType) {
+ULOG("No loadtype to update engine!");
+return;
+}
+ULOG("updating " + engine.name + " from " + updateURI.spec);
+testEngine = new Engine(updateURI, dataType, 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