Hard-code tap resolve and prefetch limits.

chrome/android/java/src/org/chromium/chrome/browser/contextualsearch/ContextualSearchPolicy.java

 // Copyright 2015 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.contextualsearch;
 
 import android.content.Context;
 import android.text.TextUtils;
 
 import org.chromium.base.VisibleForTesting;
@@ skipping 12 matching lines @@
 import javax.annotation.Nullable;
 
 
 /**
  * Handles policy decisions for the {@code ContextualSearchManager}.
  */
 class ContextualSearchPolicy {
     private static final Pattern CONTAINS_WHITESPACE_PATTERN = Pattern.compile("\\s");
     private static final int REMAINING_NOT_APPLICABLE = -1;
     private static final int ONE_DAY_IN_MILLIS = 24 * 60 * 60 * 1000;
+    private static final int TAP_RESOLVE_LIMIT_FOR_DECIDED = 50;
+    private static final int TAP_PREFETCH_LIMIT_FOR_DECIDED = 50;
+    private static final int TAP_RESOLVE_LIMIT_FOR_UNDECIDED = 20;
+    private static final int TAP_PREFETCH_LIMIT_FOR_UNDECIDED = 20;
 
     private static ContextualSearchPolicy sInstance;
 
     private final ChromePreferenceManager mPreferenceManager;
 
     // Members used only for testing purposes.
     private boolean mDidOverrideDecidedStateForTesting;
     private boolean mDecidedStateForTesting;
     private boolean mDidResetCounters;
+    private Integer mTapResolveLimitForDecided;
+    private Integer mTapPrefetchLimitForDecided;
+    private Integer mTapResolveLimitForUndecided;
+    private Integer mTapPrefetchLimitForUndecided;
 
     public static ContextualSearchPolicy getInstance(Context context) {
         if (sInstance == null) {
             sInstance = new ContextualSearchPolicy(context);
         }
         return sInstance;
     }
 
     /**
      * Private constructor -- use {@link #getInstance} to get the singleton instance.
@@ skipping 370 matching lines @@
         }
     }
 
     /**
      * @return Whether translation should be enabled or not.
      */
     boolean isTranslationEnabled() {
         return ContextualSearchFieldTrial.isTranslationOneboxEnabled();
     }
 
+    @VisibleForTesting
+    void setTapResolveLimitForDecidedForTesting(int limit) {
+        mTapResolveLimitForDecided = limit;
+    }
+
+    @VisibleForTesting
+    void setTapPrefetchLimitForDecidedForTesting(int limit) {
+        mTapPrefetchLimitForDecided = limit;
+    }
+
+    @VisibleForTesting
+    void setTapPrefetchLimitForUndecidedForTesting(int limit) {
+        mTapPrefetchLimitForUndecided = limit;
+    }
+
+    @VisibleForTesting
+    void setTapResolveLimitForUndecidedForTesting(int limit) {
+        mTapResolveLimitForUndecided = limit;
+    }
+
     // --------------------------------------------------------------------------------------------
     // Private helpers.
     // --------------------------------------------------------------------------------------------
 
     /**
      * @return Whether a promo is needed because the user is still undecided
      *         on enabling or disabling the feature.
      */
     private boolean isUserUndecided() {
         // TODO(donnd) use dependency injection for the PrefServiceBridge instead!
         if (mDidOverrideDecidedStateForTesting) return !mDecidedStateForTesting;
 
         return PrefServiceBridge.getInstance().isContextualSearchUninitialized();
     }
 
     /**
      * @param url The URL of the base page.
      * @return Whether the given content view is for an HTTP page.
      */
     private boolean isBasePageHTTP(@Nullable URL url) {
         return url != null && "http".equals(url.getProtocol());
     }
 
     /**
      * @return Whether the tap resolve limit has been exceeded.
      */
     private boolean isTapResolveBeyondTheLimit() {
-        return isTapResolveLimited() && getTapCount() > getTapResolveLimit();
+        return getTapCount() > getTapResolveLimit();
     }
 
     /**
      * @return Whether the tap resolve limit has been exceeded.
      */
     private boolean isTapPrefetchBeyondTheLimit() {
-        return isTapPrefetchLimited() && getTapCount() > getTapPrefetchLimit();
+        return getTapCount() > getTapPrefetchLimit();
     }
 
     /**
-     * @return Whether a tap gesture is resolve-limited.
-     */
-    private boolean isTapResolveLimited() {
-        return isUserUndecided()
-                ? ContextualSearchFieldTrial.isTapResolveLimitedForUndecided()
-                : ContextualSearchFieldTrial.isTapResolveLimitedForDecided();
-    }
-
-    /**
-     * @return Whether a tap gesture is resolve-limited.
-     */
-    private boolean isTapPrefetchLimited() {
-        return isUserUndecided()
-                ? ContextualSearchFieldTrial.isTapPrefetchLimitedForUndecided()
-                : ContextualSearchFieldTrial.isTapPrefetchLimitedForDecided();
-    }
-
-    /**
      * @return The limit of the number of taps to prefetch.
      */
     private int getTapPrefetchLimit() {
         return isUserUndecided()
-                ? ContextualSearchFieldTrial.getTapPrefetchLimitForUndecided()
-                : ContextualSearchFieldTrial.getTapPrefetchLimitForDecided();
+                ? getTapPrefetchLimitForUndecided()
+                : getTapPrefetchLimitForDecided();
     }
 
     /**
      * @return The limit of the number of taps to resolve using search term resolution.
      */
     private int getTapResolveLimit() {
         return isUserUndecided()
-                ? ContextualSearchFieldTrial.getTapResolveLimitForUndecided()
-                : ContextualSearchFieldTrial.getTapResolveLimitForDecided();
+                ? getTapResolveLimitForUndecided()
+                : getTapResolveLimitForDecided();
+    }
+
+    private int getTapPrefetchLimitForDecided() {
+        if (mTapPrefetchLimitForDecided != null) return mTapPrefetchLimitForDecided.intValue();
+        return TAP_PREFETCH_LIMIT_FOR_DECIDED;
+    }
+
+    private int getTapResolveLimitForDecided() {
+        if (mTapResolveLimitForDecided != null) return mTapResolveLimitForDecided.intValue();
+        return TAP_RESOLVE_LIMIT_FOR_DECIDED;
+    }
+
+    private int getTapPrefetchLimitForUndecided() {
+        if (mTapPrefetchLimitForUndecided != null) return mTapPrefetchLimitForUndecided.intValue();
+        return TAP_PREFETCH_LIMIT_FOR_UNDECIDED;
+    }
+
+    private int getTapResolveLimitForUndecided() {
+        if (mTapResolveLimitForUndecided != null) return mTapResolveLimitForUndecided.intValue();
+        return TAP_RESOLVE_LIMIT_FOR_UNDECIDED;
     }
 }