Add m-esr52 at 52.6.0

1 files changed, 764 insertions, 0 deletions

diff --git a/mobile/android/base/java/org/mozilla/gecko/search/SearchEngineManager.java b/mobile/android/base/java/org/mozilla/gecko/search/SearchEngineManager.java
new file mode 100644
index 000000000..4b33db40a
--- /dev/null
+++ b/mobile/android/base/java/org/mozilla/gecko/search/SearchEngineManager.java
@@ -0,0 +1,764 @@
+/* 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/. */
+
+package org.mozilla.gecko.search;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.support.annotation.Nullable;
+import android.support.annotation.UiThread;
+import android.support.annotation.WorkerThread;
+import android.text.TextUtils;
+import android.util.Log;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.mozilla.gecko.AppConstants;
+import org.mozilla.gecko.GeckoProfile;
+import org.mozilla.gecko.GeckoSharedPrefs;
+import org.mozilla.gecko.Locales;
+import org.mozilla.gecko.R;
+import org.mozilla.gecko.distribution.Distribution;
+import org.mozilla.gecko.util.FileUtils;
+import org.mozilla.gecko.util.GeckoJarReader;
+import org.mozilla.gecko.util.HardwareUtils;
+import org.mozilla.gecko.util.RawResource;
+import org.mozilla.gecko.util.ThreadUtils;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.lang.ref.WeakReference;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Locale;
+
+/**
+ * This class is not thread-safe, except where otherwise noted.
+ *
+ * This class contains a reference to {@link Context} - DO NOT LEAK!
+ */
+public class SearchEngineManager implements SharedPreferences.OnSharedPreferenceChangeListener {
+    private static final String LOG_TAG = "GeckoSearchEngineManager";
+
+    // Gecko pref that defines the name of the default search engine.
+    private static final String PREF_GECKO_DEFAULT_ENGINE = "browser.search.defaultenginename";
+
+    // Gecko pref that defines the name of the default searchplugin locale.
+    private static final String PREF_GECKO_DEFAULT_LOCALE = "distribution.searchplugins.defaultLocale";
+
+    // Key for shared preference that stores default engine name.
+    private static final String PREF_DEFAULT_ENGINE_KEY = "search.engines.defaultname";
+
+    // Key for shared preference that stores search region.
+    private static final String PREF_REGION_KEY = "search.region";
+
+    // URL for the geo-ip location service. Keep in sync with "browser.search.geoip.url" perference in Gecko.
+    private static final String GEOIP_LOCATION_URL = "https://location.services.mozilla.com/v1/country?key=" + AppConstants.MOZ_MOZILLA_API_KEY;
+
+    // This should go through GeckoInterface to get the UA, but the search activity
+    // doesn't use a GeckoView yet. Until it does, get the UA directly.
+    private static final String USER_AGENT = HardwareUtils.isTablet() ?
+        AppConstants.USER_AGENT_FENNEC_TABLET : AppConstants.USER_AGENT_FENNEC_MOBILE;
+
+    private final Context context;
+    private final Distribution distribution;
+    @Nullable private volatile SearchEngineCallback changeCallback;
+    @Nullable private volatile SearchEngine engine;
+
+    // Cached version of default locale included in Gecko chrome manifest.
+    // This should only be accessed from the background thread.
+    private String fallbackLocale;
+
+    // Cached version of default locale included in Distribution preferences.
+    // This should only be accessed from the background thread.
+    private String distributionLocale;
+
+    public static interface SearchEngineCallback {
+        public void execute(@Nullable SearchEngine engine);
+    }
+
+    public SearchEngineManager(Context context, Distribution distribution) {
+        this.context = context;
+        this.distribution = distribution;
+        GeckoSharedPrefs.forApp(context).registerOnSharedPreferenceChangeListener(this);
+    }
+
+    /**
+     * Sets a callback to be called when the default engine changes. This can be called from any thread.
+     *
+     * @param changeCallback SearchEngineCallback to be called after the search engine
+     *                       changed. This will run on the UI thread.
+     *                       Note: callback may be called with null engine.
+     */
+    public void setChangeCallback(SearchEngineCallback changeCallback) {
+        this.changeCallback = changeCallback;
+    }
+
+    /**
+     * Perform an action with the user's default search engine. This can be called from any thread.
+     *
+     * @param callback The callback to be used with the user's default search engine. The call
+     *                 may be sync or async; if the call is async, it will be called on the
+     *                 ui thread.
+     */
+    public void getEngine(SearchEngineCallback callback) {
+        if (engine != null) {
+            callback.execute(engine);
+        } else {
+            getDefaultEngine(callback);
+        }
+    }
+
+    /**
+     * Should be called when the object goes out of scope.
+     */
+    public void unregisterListeners() {
+        GeckoSharedPrefs.forApp(context).unregisterOnSharedPreferenceChangeListener(this);
+    }
+
+    private volatile int ignorePreferenceChange = 0;
+
+    @UiThread // according to the docs.
+    @Override
+    public void onSharedPreferenceChanged(final SharedPreferences sharedPreferences, final String key) {
+        if (!TextUtils.equals(PREF_DEFAULT_ENGINE_KEY, key)) {
+            return;
+        }
+
+        if (ignorePreferenceChange > 0) {
+            ignorePreferenceChange--;
+            return;
+        }
+
+        getDefaultEngine(changeCallback);
+    }
+
+    /**
+     * Runs a SearchEngineCallback on the main thread.
+     */
+    private void runCallback(final SearchEngine engine, @Nullable final SearchEngineCallback callback) {
+        ThreadUtils.postToUiThread(new RunCallbackUiThreadRunnable(this, engine, callback));
+    }
+
+    // Static is not strictly necessary but the outer class has a reference to Context so we should GC ASAP.
+    private static class RunCallbackUiThreadRunnable implements Runnable {
+        private final WeakReference<SearchEngineManager> searchEngineManagerWeakReference;
+        private final SearchEngine searchEngine;
+        private final SearchEngineCallback callback;
+
+        public RunCallbackUiThreadRunnable(final SearchEngineManager searchEngineManager, final SearchEngine searchEngine,
+                final SearchEngineCallback callback) {
+            this.searchEngineManagerWeakReference = new WeakReference<>(searchEngineManager);
+            this.searchEngine = searchEngine;
+            this.callback = callback;
+        }
+
+        @UiThread
+        @Override
+        public void run() {
+            final SearchEngineManager searchEngineManager = searchEngineManagerWeakReference.get();
+            if (searchEngineManager == null) {
+                return;
+            }
+
+            // Cache engine for future calls to getEngine.
+            searchEngineManager.engine = searchEngine;
+            if (callback != null) {
+                callback.execute(searchEngine);
+            }
+
+        }
+    }
+
+    /**
+     * This method finds and creates the default search engine. It will first look for
+     * the default engine name, then create the engine from that name.
+     *
+     * To find the default engine name, we first look in shared preferences, then
+     * the distribution (if one exists), and finally fall back to the localized default.
+     *
+     * @param callback SearchEngineCallback to be called after successfully looking
+     *                 up the search engine. This will run on the UI thread.
+     *                 Note: callback may be called with null engine.
+     */
+    private void getDefaultEngine(final SearchEngineCallback callback) {
+        // This runnable is posted to the background thread.
+        distribution.addOnDistributionReadyCallback(new GetDefaultEngineDistributionCallbacks(this, callback));
+    }
+
+    // Static is not strictly necessary but the outer class contains a reference to Context so we should GC ASAP.
+    private static class GetDefaultEngineDistributionCallbacks implements Distribution.ReadyCallback {
+        private final WeakReference<SearchEngineManager> searchEngineManagerWeakReference;
+        private final SearchEngineCallback callback;
+
+        public GetDefaultEngineDistributionCallbacks(final SearchEngineManager searchEngineManager,
+                final SearchEngineCallback callback) {
+            this.searchEngineManagerWeakReference = new WeakReference<>(searchEngineManager);
+            this.callback = callback;
+        }
+
+        @Override
+        public void distributionNotFound() {
+            defaultBehavior();
+        }
+
+        @Override
+        public void distributionFound(Distribution distribution) {
+            defaultBehavior();
+        }
+
+        @Override
+        public void distributionArrivedLate(Distribution distribution) {
+            final SearchEngineManager searchEngineManager = searchEngineManagerWeakReference.get();
+            if (searchEngineManager == null) {
+                return;
+            }
+
+            // Let's see if there's a name in the distro.
+            // If so, just this once we'll override the saved value.
+            final String name = searchEngineManager.getDefaultEngineNameFromDistribution();
+
+            if (name == null) {
+                return;
+            }
+
+            // Store the default engine name for the future.
+            // Increment an 'ignore' counter so that this preference change
+            // won't cause getDefaultEngine to be called again.
+            searchEngineManager.ignorePreferenceChange++;
+            GeckoSharedPrefs.forApp(searchEngineManager.context)
+                    .edit()
+                    .putString(PREF_DEFAULT_ENGINE_KEY, name)
+                    .apply();
+
+            final SearchEngine engine = searchEngineManager.createEngineFromName(name);
+            searchEngineManager.runCallback(engine, callback);
+        }
+
+        @WorkerThread // calling methods are @WorkerThread
+        private void defaultBehavior() {
+            final SearchEngineManager searchEngineManager = searchEngineManagerWeakReference.get();
+            if (searchEngineManager == null) {
+                return;
+            }
+
+            // First look for a default name stored in shared preferences.
+            String name = GeckoSharedPrefs.forApp(searchEngineManager.context).getString(PREF_DEFAULT_ENGINE_KEY, null);
+
+            // Check for a region stored in shared preferences. If we don't have a region,
+            // we should force a recheck of the default engine.
+            String region = GeckoSharedPrefs.forApp(searchEngineManager.context).getString(PREF_REGION_KEY, null);
+
+            if (name != null && region != null) {
+                Log.d(LOG_TAG, "Found default engine name in SharedPreferences: " + name);
+            } else {
+                // First, look for the default search engine in a distribution.
+                name = searchEngineManager.getDefaultEngineNameFromDistribution();
+                if (name == null) {
+                    // Otherwise, get the default engine that we ship.
+                    name = searchEngineManager.getDefaultEngineNameFromLocale();
+                }
+
+                // Store the default engine name for the future.
+                // Increment an 'ignore' counter so that this preference change
+                // won't cause getDefaultEngine to be called again.
+                searchEngineManager.ignorePreferenceChange++;
+                GeckoSharedPrefs.forApp(searchEngineManager.context)
+                        .edit()
+                        .putString(PREF_DEFAULT_ENGINE_KEY, name)
+                        .apply();
+            }
+
+            final SearchEngine engine = searchEngineManager.createEngineFromName(name);
+            searchEngineManager.runCallback(engine, callback);
+        }
+    }
+
+    /**
+     * Looks for a default search engine included in a distribution.
+     * This method must be called after the distribution is ready.
+     *
+     * @return search engine name.
+     */
+    private String getDefaultEngineNameFromDistribution() {
+        if (!distribution.exists()) {
+            return null;
+        }
+
+        final File prefFile = distribution.getDistributionFile("preferences.json");
+        if (prefFile == null) {
+            return null;
+        }
+
+        try {
+            final JSONObject all = FileUtils.readJSONObjectFromFile(prefFile);
+
+            // First, look for a default locale specified by the distribution.
+            if (all.has("Preferences")) {
+                final JSONObject prefs = all.getJSONObject("Preferences");
+                if (prefs.has(PREF_GECKO_DEFAULT_LOCALE)) {
+                    Log.d(LOG_TAG, "Found default searchplugin locale in distribution Preferences.");
+                    distributionLocale = prefs.getString(PREF_GECKO_DEFAULT_LOCALE);
+                }
+            }
+
+            // Then, check to see if there's a locale-specific default engine override.
+            final String languageTag = Locales.getLanguageTag(Locale.getDefault());
+            final String overridesKey = "LocalizablePreferences." + languageTag;
+            if (all.has(overridesKey)) {
+                final JSONObject overridePrefs = all.getJSONObject(overridesKey);
+                if (overridePrefs.has(PREF_GECKO_DEFAULT_ENGINE)) {
+                    Log.d(LOG_TAG, "Found default engine name in distribution LocalizablePreferences override.");
+                    return overridePrefs.getString(PREF_GECKO_DEFAULT_ENGINE);
+                }
+            }
+
+            // Next, check to see if there's a non-override default engine pref.
+            if (all.has("LocalizablePreferences")) {
+                final JSONObject localizablePrefs = all.getJSONObject("LocalizablePreferences");
+                if (localizablePrefs.has(PREF_GECKO_DEFAULT_ENGINE)) {
+                    Log.d(LOG_TAG, "Found default engine name in distribution LocalizablePreferences.");
+                    return localizablePrefs.getString(PREF_GECKO_DEFAULT_ENGINE);
+                }
+            }
+        } catch (IOException e) {
+            Log.e(LOG_TAG, "Error getting search engine name from preferences.json", e);
+        } catch (JSONException e) {
+            Log.e(LOG_TAG, "Error parsing preferences.json", e);
+        }
+        return null;
+    }
+
+    /**
+     * Helper function for converting an InputStream to a String.
+     * @param is InputStream you want to convert to a String
+     *
+     * @return String containing the data
+     */
+    private String getHttpResponse(HttpURLConnection conn) {
+        InputStream is = null;
+        try {
+            is = new BufferedInputStream(conn.getInputStream());
+            return new java.util.Scanner(is).useDelimiter("\\A").next();
+        } catch (Exception e) {
+            return "";
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                } catch (IOException e) {
+                    Log.e(LOG_TAG, "Error closing InputStream", e);
+                }
+            }
+        }
+    }
+
+    /**
+     * Gets the country code based on the current IP, using the Mozilla Location Service.
+     * We cache the country code in a shared preference, so we only fetch from the network
+     * once.
+     *
+     * @return String containing the country code
+     */
+    private String fetchCountryCode() {
+        // First, we look to see if we have a cached code.
+        final String region = GeckoSharedPrefs.forApp(context).getString(PREF_REGION_KEY, null);
+        if (region != null) {
+            return region;
+        }
+
+        // Since we didn't have a cached code, we need to fetch a code from the service.
+        try {
+            String responseText = null;
+
+            URL url = new URL(GEOIP_LOCATION_URL);
+            HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
+            try {
+                // POST an empty JSON object.
+                final String message = "{}";
+
+                urlConnection.setDoOutput(true);
+                urlConnection.setConnectTimeout(10000);
+                urlConnection.setReadTimeout(10000);
+                urlConnection.setRequestMethod("POST");
+                urlConnection.setRequestProperty("User-Agent", USER_AGENT);
+                urlConnection.setRequestProperty("Content-Type", "application/json");
+                urlConnection.setFixedLengthStreamingMode(message.getBytes().length);
+
+                final OutputStream out = urlConnection.getOutputStream();
+                out.write(message.getBytes());
+                out.close();
+
+                responseText = getHttpResponse(urlConnection);
+            } finally {
+                urlConnection.disconnect();
+            }
+
+            if (responseText == null) {
+                Log.e(LOG_TAG, "Country code fetch failed");
+                return null;
+            }
+
+            // Extract the country code and save it for later in a cache.
+            final JSONObject response = new JSONObject(responseText);
+            return response.optString("country_code", null);
+        } catch (Exception e) {
+            Log.e(LOG_TAG, "Country code fetch failed", e);
+        }
+
+        return null;
+    }
+
+    /**
+     * Looks for the default search engine shipped in the locale.
+     *
+     * @return search engine name.
+     */
+    private String getDefaultEngineNameFromLocale() {
+        try {
+            final JSONObject browsersearch = new JSONObject(RawResource.getAsString(context, R.raw.browsersearch));
+
+            // Get the region used to fence search engines.
+            String region = fetchCountryCode();
+
+            // Store the result, even if it's empty. If we fail to get a region, we never
+            // try to get it again, and we will always fallback to the non-region engine.
+            GeckoSharedPrefs.forApp(context)
+                            .edit()
+                            .putString(PREF_REGION_KEY, (region == null ? "" : region))
+                            .apply();
+
+            if (region != null) {
+                if (browsersearch.has("regions")) {
+                    final JSONObject regions = browsersearch.getJSONObject("regions");
+                    if (regions.has(region)) {
+                        final JSONObject regionData = regions.getJSONObject(region);
+                        Log.d(LOG_TAG, "Found region-specific default engine name in browsersearch.json.");
+                        return regionData.getString("default");
+                    }
+                }
+            }
+
+            // Either we have no geoip region, or we didn't find the right region and we are falling back to the default.
+            if (browsersearch.has("default")) {
+                Log.d(LOG_TAG, "Found default engine name in browsersearch.json.");
+                return browsersearch.getString("default");
+            }
+        } catch (IOException e) {
+            Log.e(LOG_TAG, "Error getting search engine name from browsersearch.json", e);
+        } catch (JSONException e) {
+            Log.e(LOG_TAG, "Error parsing browsersearch.json", e);
+        }
+        return null;
+    }
+
+    /**
+     * Creates a SearchEngine instance from an engine name.
+     *
+     * To create the engine, we first try to find the search plugin in the distribution
+     * (if one exists), followed by the localized plugins we ship with the browser, and
+     * then finally third-party plugins that are installed in the profile directory.
+     *
+     * This method must be called after the distribution is ready.
+     *
+     * @param name The search engine name (e.g. "Google" or "Amazon.com")
+     * @return SearchEngine instance for name.
+     */
+    private SearchEngine createEngineFromName(String name) {
+        // First, look in the distribution.
+        SearchEngine engine = createEngineFromDistribution(name);
+
+        // Second, look in the jar for plugins shipped with the locale.
+        if (engine == null) {
+            engine = createEngineFromLocale(name);
+        }
+
+        // Finally, look in the profile for third-party plugins.
+        if (engine == null) {
+            engine = createEngineFromProfile(name);
+        }
+
+        if (engine == null) {
+            Log.e(LOG_TAG, "Could not create search engine from name: " + name);
+        }
+
+        return engine;
+    }
+
+    /**
+     * Creates a SearchEngine instance for a distribution search plugin.
+     *
+     * This method iterates through the distribution searchplugins directory,
+     * creating SearchEngine instances until it finds one with the right name.
+     *
+     * This method must be called after the distribution is ready.
+     *
+     * @param name Search engine name.
+     * @return SearchEngine instance for name.
+     */
+    private SearchEngine createEngineFromDistribution(String name) {
+        if (!distribution.exists()) {
+            return null;
+        }
+
+        final File pluginsDir = distribution.getDistributionFile("searchplugins");
+        if (pluginsDir == null) {
+            return null;
+        }
+
+        // Collect an array of files to scan using the same approach as
+        // DirectoryService._appendDistroSearchDirs which states:
+        // Common engines are loaded for all locales. If there is no locale directory for
+        // the current locale, there is a pref: "distribution.searchplugins.defaultLocale",
+        // which specifies a default locale to use.
+        ArrayList<File> files = new ArrayList<>();
+
+        // Load files from the common folder first
+        final File[] commonFiles = (new File(pluginsDir, "common")).listFiles();
+        if (commonFiles != null) {
+            Collections.addAll(files, commonFiles);
+        }
+
+        // Next, check to see if there's a locale-specific override.
+        final File localeDir = new File(pluginsDir, "locale");
+        if (localeDir != null) {
+            final String languageTag = Locales.getLanguageTag(Locale.getDefault());
+            final File[] localeFiles = (new File(localeDir, languageTag)).listFiles();
+            if (localeFiles != null) {
+                Collections.addAll(files, localeFiles);
+            } else {
+                // We didn't append the locale dir - try the default one.
+                if (distributionLocale != null) {
+                    final File[] defaultLocaleFiles = (new File(localeDir, distributionLocale)).listFiles();
+                    if (defaultLocaleFiles != null) {
+                        Collections.addAll(files, defaultLocaleFiles);
+                    }
+                }
+            }
+        }
+
+        if (files.isEmpty()) {
+            Log.e(LOG_TAG, "Could not find search plugin files in distribution directory");
+            return null;
+        }
+
+        return createEngineFromFileList(files.toArray(new File[files.size()]), name);
+    }
+
+    /**
+     * Creates a SearchEngine instance for a search plugin shipped in the locale.
+     *
+     * This method reads the list of search plugin file names from list.txt, then
+     * iterates through the files, creating SearchEngine instances until it finds one
+     * with the right name. Unfortunately, we need to do this because there is no
+     * other way to map the search engine "name" to the file for the search plugin.
+     *
+     * @param name Search engine name.
+     * @return SearchEngine instance for name.
+     */
+    private SearchEngine createEngineFromLocale(String name) {
+        final InputStream in = getInputStreamFromSearchPluginsJar("list.txt");
+        if (in == null) {
+            return null;
+        }
+        final BufferedReader br = getBufferedReader(in);
+
+        try {
+            String identifier;
+            while ((identifier = br.readLine()) != null) {
+                final InputStream pluginIn = getInputStreamFromSearchPluginsJar(identifier + ".xml");
+                // pluginIn can be null if the xml file doesn't exist which
+                // can happen with :hidden plugins
+                if (pluginIn != null) {
+                  final SearchEngine engine = createEngineFromInputStream(identifier, pluginIn);
+                  if (engine != null && engine.getName().equals(name)) {
+                      return engine;
+                  }
+                }
+            }
+        } catch (Exception e) {
+            Log.e(LOG_TAG, "Error creating shipped search engine from name: " + name, e);
+        } finally {
+            try {
+                br.close();
+            } catch (IOException e) {
+                // Ignore.
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Creates a SearchEngine instance for a search plugin in the profile directory.
+     *
+     * This method iterates through the profile searchplugins directory, creating
+     * SearchEngine instances until it finds one with the right name.
+     *
+     * @param name Search engine name.
+     * @return SearchEngine instance for name.
+     */
+    private SearchEngine createEngineFromProfile(String name) {
+        final File pluginsDir = GeckoProfile.get(context).getFile("searchplugins");
+        if (pluginsDir == null) {
+            return null;
+        }
+
+        final File[] files = pluginsDir.listFiles();
+        if (files == null) {
+            Log.e(LOG_TAG, "Could not find search plugin files in profile directory");
+            return null;
+        }
+        return createEngineFromFileList(files, name);
+    }
+
+    /**
+     * This method iterates through an array of search plugin files, creating
+     * SearchEngine instances until it finds one with the right name.
+     *
+     * @param files Array of search plugin files. Should not be null.
+     * @param name Search engine name.
+     * @return SearchEngine instance for name.
+     */
+    private SearchEngine createEngineFromFileList(File[] files, String name) {
+        for (int i = 0; i < files.length; i++) {
+            try {
+                final FileInputStream fis = new FileInputStream(files[i]);
+                final SearchEngine engine = createEngineFromInputStream(null, fis);
+                if (engine != null && engine.getName().equals(name)) {
+                    return engine;
+                }
+            } catch (IOException e) {
+                Log.e(LOG_TAG, "Error creating search engine from name: " + name, e);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Creates a SearchEngine instance from an InputStream.
+     *
+     * This method closes the stream after it is done reading it.
+     *
+     * @param identifier Seach engine identifier. This only exists for search engines that
+     *                   ship with the default set of engines in the locale.
+     * @param in InputStream for search plugin XML file.
+     * @return SearchEngine instance.
+     */
+    private SearchEngine createEngineFromInputStream(String identifier, InputStream in) {
+        try {
+            try {
+                return new SearchEngine(identifier, in);
+            } finally {
+                in.close();
+            }
+        } catch (Exception e) {
+            Log.e(LOG_TAG, "Exception creating search engine", e);
+        }
+
+        return null;
+    }
+
+    /**
+     * Reads a file from the searchplugins directory in the Gecko jar.
+     *
+     * @param fileName name of the file to read.
+     * @return InputStream for file.
+     */
+    private InputStream getInputStreamFromSearchPluginsJar(String fileName) {
+        final Locale locale = Locale.getDefault();
+
+        // First, try a file path for the full locale.
+        final String languageTag = Locales.getLanguageTag(locale);
+        String url = getSearchPluginsJarURL(context, languageTag, fileName);
+
+        InputStream in = GeckoJarReader.getStream(context, url);
+        if (in != null) {
+            return in;
+        }
+
+        // If that doesn't work, try a file path for just the language.
+        final String language = Locales.getLanguage(locale);
+        if (!languageTag.equals(language)) {
+            url = getSearchPluginsJarURL(context, language, fileName);
+            in = GeckoJarReader.getStream(context, url);
+            if (in != null) {
+                return in;
+            }
+        }
+
+        // Finally, fall back to default locale defined in chrome registry.
+        url = getSearchPluginsJarURL(context, getFallbackLocale(), fileName);
+        return GeckoJarReader.getStream(context, url);
+    }
+
+    /**
+     * Finds a fallback locale in the Gecko chrome registry. If a locale is declared
+     * here, we should be guaranteed to find a searchplugins directory for it.
+     *
+     * This method should only be accessed from the background thread.
+     */
+    private String getFallbackLocale() {
+        if (fallbackLocale != null) {
+            return fallbackLocale;
+        }
+
+        final InputStream in = GeckoJarReader.getStream(
+                context, GeckoJarReader.getJarURL(context, "chrome/chrome.manifest"));
+        if (in == null) {
+            return null;
+        }
+        final BufferedReader br = getBufferedReader(in);
+
+        try {
+            String line;
+            while ((line = br.readLine()) != null) {
+                // We're looking for a line like "locale global en-US en-US/locale/en-US/global/"
+                // https://developer.mozilla.org/en/docs/Chrome_Registration#locale
+                if (line.startsWith("locale global ")) {
+                    fallbackLocale = line.split(" ", 4)[2];
+                    break;
+                }
+            }
+        } catch (IOException e) {
+            Log.e(LOG_TAG, "Error reading fallback locale from chrome registry", e);
+        } finally {
+            try {
+                br.close();
+            } catch (IOException e) {
+                // Ignore.
+            }
+        }
+        return fallbackLocale;
+    }
+
+    /**
+     * Gets the jar URL for a file in the searchplugins directory.
+     *
+     * @param locale String representing the Gecko locale (e.g. "en-US").
+     * @param fileName The name of the file to read.
+     * @return URL for jar file.
+     */
+    private static String getSearchPluginsJarURL(Context context, String locale, String fileName) {
+        final String path = "chrome/" + locale + "/locale/" + locale + "/browser/searchplugins/" + fileName;
+        return GeckoJarReader.getJarURL(context, path);
+    }
+
+    private BufferedReader getBufferedReader(InputStream in) {
+        try {
+            return new BufferedReader(new InputStreamReader(in, "UTF-8"));
+        } catch (UnsupportedEncodingException e) {
+            // Cannot happen.
+            return null;
+        }
+    }
+}