[Android] Allow setting recently visited search engines as default search engine

chrome/android/java/src/org/chromium/chrome/browser/search_engines/TemplateUrlService.java

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.search_engines;
 
+import android.support.annotation.IntDef;
 import android.text.TextUtils;
 
 import org.chromium.base.ObserverList;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.annotations.CalledByNative;
 
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
  * Android wrapper of the TemplateUrlService which provides access from the Java
  * layer.
  *
  * Only usable from the UI thread as it's primary purpose is for supporting the Android
  * preferences UI.
  *
  * See components/search_engines/template_url_service.h for more details.
  */
@@ skipping 10 matching lines @@
      * Observer to be notified whenever the set of TemplateURLs are modified.
      */
     public interface TemplateUrlServiceObserver {
         /**
          * Notification that the template url model has changed in some way.
          */
         void onTemplateURLServiceChanged();
     }
 
     /**
+     * Type for default search engine which is not prepopulated. This is needed because
+     * if a custom search engine is set as default, it will be moved to the prepopulated list.
+     */
+    public static final int TYPE_DEFAULT = 0;
+    public static final int TYPE_PREPOPULATED = 1;
+    public static final int TYPE_RECENT = 2;
+
+    @IntDef({TYPE_DEFAULT, TYPE_PREPOPULATED, TYPE_RECENT})
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface TemplateUrlType {}

[gone, 2016/11/28 21:37:02]

I'd stick the public static final int TYPE_DEFAULT, etc fields underneath, like
how ChromeTabbedActivity and SearchEnginePromoDialog do it.

[ltian, 2016/11/29 02:44:02]

Done.

+
+    /**
      * Represents search engine with its index.
      */
     public static class TemplateUrl {
         private final int mIndex;
         private final String mShortName;
-        private boolean mIsPrepopulated;
+        private final String mUrl;
+        private final boolean mIsPrepopulated;
+        private final String mKeyword;
+        @TemplateUrlType
+        private int mTemplateUrlType;

[gone, 2016/11/28 21:37:02]

Maybe just inline it to make this look a little cleaner?

@TemplateUrlType private int mTemplateUrlType

[ltian, 2016/11/29 02:44:02]

Done.

 
         @CalledByNative("TemplateUrl")
-        public static TemplateUrl create(int id, String shortName, boolean isPrepopulated) {
-            return new TemplateUrl(id, shortName, isPrepopulated);
+        public static TemplateUrl create(
+                int id, String shortName, String url, boolean isPrepopulated, String keyword) {
+            return new TemplateUrl(id, shortName, url, isPrepopulated, keyword);
         }
 
-        public TemplateUrl(int index, String shortName, boolean isPrepopulated) {
+        public TemplateUrl(
+                int index, String shortName, String url, boolean isPrepopulated, String keyword) {
             mIndex = index;
             mShortName = shortName;
+            Pattern pattern = Pattern.compile("[^/]+.com");
+            Matcher m = pattern.matcher(url);
+            mUrl = m.find() ? m.group(0) : "";
             mIsPrepopulated = isPrepopulated;
+            mKeyword = keyword;
         }
 
         public int getIndex() {
             return mIndex;
         }
 
         public String getShortName() {
             return mShortName;
         }
 
+        public String getUrl() {
+            return mUrl;
+        }
+
+        public boolean getIsPrepopulated() {
+            return mIsPrepopulated;
+        }
+
+        public String getKeyword() {
+            return mKeyword;
+        }
+
+        public void setType(@TemplateUrlType int templateUrlType) {
+            mTemplateUrlType = templateUrlType;
+        }
+
+        @TemplateUrlType
+        public int getType() {
+            return mTemplateUrlType;
+        }
+
         @Override
         public int hashCode() {
             final int prime = 31;
             int result = 1;
             result = prime * result + mIndex;
             result = prime * result + ((mShortName == null) ? 0 : mShortName.hashCode());
             return result;
         }
 
         @Override
@@ skipping 36 matching lines @@
         nativeLoad(mNativeTemplateUrlServiceAndroid);
     }
 
     /**
      * Returns a list of the prepopulated search engines.
      *
      * Warning: TemplateUrl.getIndex() is *not* an index into this list, since this list contains
      * only prepopulated search engines. E.g. getLocalizedSearchEngines().get(0).getIndex() could
      * return 3.
      */
-    public List<TemplateUrl> getLocalizedSearchEngines() {
+    public List<TemplateUrl> getSearchEngines() {
         ThreadUtils.assertOnUiThread();
+        int defaultSearchEngineIndex = getDefaultSearchEngineIndex();
         int templateUrlCount = nativeGetTemplateUrlCount(mNativeTemplateUrlServiceAndroid);
         List<TemplateUrl> templateUrls = new ArrayList<TemplateUrl>(templateUrlCount);
         for (int i = 0; i < templateUrlCount; i++) {
             TemplateUrl templateUrl = nativeGetTemplateUrlAt(mNativeTemplateUrlServiceAndroid, i);
-            if (templateUrl != null && templateUrl.mIsPrepopulated) {
+            if (templateUrl != null) {
+                setSearchEngineType(templateUrl, defaultSearchEngineIndex);
                 templateUrls.add(templateUrl);
             }
         }
         return templateUrls;
     }
 
+    private void setSearchEngineType(TemplateUrl templateUrl, int defaultSearchEngineIndex) {
+        if (templateUrl.getIsPrepopulated()) {
+            templateUrl.setType(TYPE_PREPOPULATED);
+        } else if (templateUrl.getIndex() == defaultSearchEngineIndex) {
+            templateUrl.setType(TYPE_DEFAULT);
+        } else {
+            templateUrl.setType(TYPE_RECENT);
+        }
+    }
+
     /**
      * Called from native when template URL service is done loading.
      */
     @CalledByNative
     private void templateUrlServiceLoaded() {
         ThreadUtils.assertOnUiThread();
         for (LoadListener listener : mLoadListeners) {
             listener.onTemplateUrlServiceLoaded();
         }
     }
 
     @CalledByNative
     private void onTemplateURLServiceChanged() {
         for (TemplateUrlServiceObserver observer : mObservers) {
             observer.onTemplateURLServiceChanged();
         }
     }
 
     /**
      * @return The default search engine index (e.g., 0, 1, 2,...).
      */
     public int getDefaultSearchEngineIndex() {
         ThreadUtils.assertOnUiThread();
-        return nativeGetDefaultSearchProvider(mNativeTemplateUrlServiceAndroid);
+        return nativeGetDefaultSearchProviderIndex(mNativeTemplateUrlServiceAndroid);
     }
 
     /**
      * @return {@link TemplateUrlService.TemplateUrl} for the default search engine.
      */
     public TemplateUrl getDefaultSearchEngineTemplateUrl() {
         if (!isLoaded()) return null;
 
         int defaultSearchEngineIndex = getDefaultSearchEngineIndex();
         if (defaultSearchEngineIndex == -1) return null;
 
         assert defaultSearchEngineIndex >= 0;
         assert defaultSearchEngineIndex < nativeGetTemplateUrlCount(
                 mNativeTemplateUrlServiceAndroid);
 
         return nativeGetTemplateUrlAt(mNativeTemplateUrlServiceAndroid, defaultSearchEngineIndex);
     }
 
-    public void setSearchEngine(int selectedIndex) {
+    public void setSearchEngine(String selectedKeyword) {
         ThreadUtils.assertOnUiThread();
-        nativeSetUserSelectedDefaultSearchProvider(mNativeTemplateUrlServiceAndroid, selectedIndex);
+        nativeSetUserSelectedDefaultSearchProvider(
+                mNativeTemplateUrlServiceAndroid, selectedKeyword);
     }
 
     public boolean isSearchProviderManaged() {
         return nativeIsSearchProviderManaged(mNativeTemplateUrlServiceAndroid);
     }
 
     /**
      * @return Whether or not the default search engine has search by image support.
      */
     public boolean isSearchByImageAvailable() {
@@ skipping 108 matching lines @@
             String query, String alternateTerm, boolean shouldPrefetch, String protocolVersion) {
         return nativeGetUrlForContextualSearchQuery(mNativeTemplateUrlServiceAndroid, query,
                 alternateTerm, shouldPrefetch, protocolVersion);
     }
 
     /**
      * Finds the URL for the search engine at the given index.
      * @param index The templateUrl index to look up.
      * @return      A {@link String} that contains the url of the specified search engine.
      */
-    public String getSearchEngineUrlFromTemplateUrl(int index) {
-        return nativeGetSearchEngineUrlFromTemplateUrl(mNativeTemplateUrlServiceAndroid, index);
+    public String getSearchEngineUrlFromTemplateUrl(String keyword) {
+        return nativeGetSearchEngineUrlFromTemplateUrl(mNativeTemplateUrlServiceAndroid, keyword);
     }
 
     private native long nativeInit();
     private native void nativeLoad(long nativeTemplateUrlServiceAndroid);
     private native boolean nativeIsLoaded(long nativeTemplateUrlServiceAndroid);
     private native int nativeGetTemplateUrlCount(long nativeTemplateUrlServiceAndroid);
     private native TemplateUrl nativeGetTemplateUrlAt(long nativeTemplateUrlServiceAndroid, int i);
     private native void nativeSetUserSelectedDefaultSearchProvider(
-            long nativeTemplateUrlServiceAndroid, int selectedIndex);
-    private native int nativeGetDefaultSearchProvider(long nativeTemplateUrlServiceAndroid);
+            long nativeTemplateUrlServiceAndroid, String selectedKeyword);
+    private native int nativeGetDefaultSearchProviderIndex(long nativeTemplateUrlServiceAndroid);
     private native boolean nativeIsSearchProviderManaged(long nativeTemplateUrlServiceAndroid);
     private native boolean nativeIsSearchByImageAvailable(long nativeTemplateUrlServiceAndroid);
     private native boolean nativeIsDefaultSearchEngineGoogle(long nativeTemplateUrlServiceAndroid);
     private native String nativeGetUrlForSearchQuery(long nativeTemplateUrlServiceAndroid,
             String query);
     private native String nativeGetUrlForVoiceSearchQuery(long nativeTemplateUrlServiceAndroid,
             String query);
     private native String nativeReplaceSearchTermsInUrl(long nativeTemplateUrlServiceAndroid,
             String query, String currentUrl);
     private native String nativeGetUrlForContextualSearchQuery(long nativeTemplateUrlServiceAndroid,
             String query, String alternateTerm, boolean shouldPrefetch, String protocolVersion);
     private native String nativeGetSearchEngineUrlFromTemplateUrl(
-            long nativeTemplateUrlServiceAndroid, int index);
+            long nativeTemplateUrlServiceAndroid, String keyword);
 }