CustomTabs: Base version for prerender switch

chrome/android/java/src/org/chromium/chrome/browser/customtabs/CustomTabsConnection.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.customtabs;
 
 import android.app.ActivityManager;
 import android.app.Application;
 import android.app.PendingIntent;
 import android.content.Context;
@@ skipping 65 matching lines @@
     private static final String TAG = "ChromeConnection";
     private static final String LOG_SERVICE_REQUESTS = "custom-tabs-log-service-requests";
 
     @VisibleForTesting
     static final String PAGE_LOAD_METRICS_CALLBACK = "NavigationMetrics";
 
     // For testing only, DO NOT USE.
     @VisibleForTesting
     static final String DEBUG_OVERRIDE_KEY =
             "android.support.customtabs.maylaunchurl.DEBUG_OVERRIDE";
-    private static final int NO_OVERRIDE = 0;
+    @VisibleForTesting
+    static final int NO_OVERRIDE = 0;
     @VisibleForTesting
     static final int NO_PRERENDERING = 1;
     @VisibleForTesting
     static final int PREFETCH_ONLY = 2;
 
     private static AtomicReference<CustomTabsConnection> sInstance = new AtomicReference<>();
 
     /** Holds the parameters for the current speculation. */
     @VisibleForTesting
     static final class SpeculationParams {
         public final CustomTabsSessionToken session;
         public final String url;
+        public final int debugOverrideValue;

[ahemery1, 2017/03/21 15:15:57]

Replaces prefetchOnly to have a record of what the speculation was in a more
general sense.

[Benoit L, 2017/03/21 15:56:41]

I would prefer a name like "mode", or something along these lines. Could take
the values of PRERENDER, PREFETCH_ONLY, and more soon.

PREFETCH_ONLY would be controlled by the value of DEBUG_OVERRIDE, and hidden tab
by the per-session setting, or when Chrome calls itself (from the tests).

 
         // Only for prerender.
         public final WebContents webContents;
         public final String referrer;
         public final Bundle extras;
 
-        public final boolean prefetchOnly;
+        static SpeculationParams forPrefetch(CustomTabsSessionToken session, String url) {

[ahemery1, 2017/03/21 15:15:58]

Just reordered.

[Benoit L, 2017/03/21 15:56:41]

why?
Not an issue, but why reordering code?

+            return new SpeculationParams(session, url, PREFETCH_ONLY, null, null, null);
+        }
 
         static SpeculationParams forPrerender(CustomTabsSessionToken session, String url,
                 WebContents webcontents, String referrer, Bundle extras) {
-            return new SpeculationParams(session, url, webcontents, referrer, extras, false);
-        }
-
-        static SpeculationParams forPrefetch(CustomTabsSessionToken session, String url) {
-            return new SpeculationParams(session, url, null, null, null, true);
+            return new SpeculationParams(session, url, NO_OVERRIDE, webcontents, referrer, extras);
         }
 
         private SpeculationParams(CustomTabsSessionToken session, String url,
-                WebContents webContents, String referrer, Bundle extras, boolean prefetchOnly) {
+                int debugOverrideValue, WebContents webContents, String referrer, Bundle extras) {
             this.session = session;
             this.url = url;
+            this.debugOverrideValue = debugOverrideValue;
             this.webContents = webContents;
             this.referrer = referrer;
             this.extras = extras;
-            this.prefetchOnly = prefetchOnly;
         }
     }
 
     @VisibleForTesting
     SpeculationParams mSpeculation;
     protected final Application mApplication;
     protected final ClientManager mClientManager;
     private final boolean mLogRequests;
     private final AtomicBoolean mWarmupHasBeenCalled = new AtomicBoolean();
     private final AtomicBoolean mWarmupHasBeenFinished = new AtomicBoolean();
@@ skipping 192 matching lines @@
         int debugOverrideValue = NO_OVERRIDE;
         if (extras != null) debugOverrideValue = extras.getInt(DEBUG_OVERRIDE_KEY, NO_OVERRIDE);
 
         boolean didStartPrerender = false, didStartPrefetch = false;
         boolean mayPrerender = mayPrerender(session);
         if (mayPrerender) {
             if (debugOverrideValue == PREFETCH_ONLY) {
                 didStartPrefetch = new ResourcePrefetchPredictor(profile).startPrefetching(url);
                 if (didStartPrefetch) mSpeculation = SpeculationParams.forPrefetch(session, url);
             } else if (debugOverrideValue != NO_PRERENDERING) {
+                // Last one wins and cancels the previous prerender.

[ahemery1, 2017/03/21 15:15:57]

This was moved from inside the prerenderUrl() function. It is private so we are
in control of where this is used and we should have no problem. Factoring
behavior common for both prerender and hidden tab.

[Benoit L, 2017/03/21 15:56:41]

nit: Is it possible to isolate the changes between the various CLs? Makes it
easier to review and understand.
Not a big issue here.

+                cancelPrerender(null);
                 didStartPrerender = prerenderUrl(session, url, extras, uid);
             }
         }
         preconnectUrls(otherLikelyBundles);
         if (!didStartPrefetch) warmupManager.maybePreconnectUrlAndSubResources(profile, url);
         if (!didStartPrerender) warmupManager.createSpareWebContents();
     }
 
     /**
      * Low confidence mayLaunchUrl() call, that is:
@@ skipping 234 matching lines @@
      * @param url The URL the WebContents is for.
      * @param referrer The referrer to use for |url|.
      * @return The prerendered WebContents, or null.
      */
     WebContents takePrerenderedUrl(CustomTabsSessionToken session, String url, String referrer) {
         ThreadUtils.assertOnUiThread();
         if (mSpeculation == null || session == null || !session.equals(mSpeculation.session)) {
             return null;
         }
 
-        if (mSpeculation.prefetchOnly) {
+        if (mSpeculation.debugOverrideValue == PREFETCH_ONLY) {
             Profile profile = Profile.getLastUsedProfile();
             new ResourcePrefetchPredictor(profile).stopPrefetching(mSpeculation.url);
             mSpeculation = null;
             return null;
         }
 
         WebContents webContents = mSpeculation.webContents;
         String prerenderedUrl = mSpeculation.url;
         String prerenderReferrer = mSpeculation.referrer;
         if (referrer == null) referrer = "";
@@ skipping 293 matching lines @@
         // tabs. Then PrivacyManager should be used to make the below check.
         if (!PrefServiceBridge.getInstance().getNetworkPredictionEnabled()) return false;
         if (DataReductionProxySettings.getInstance().isDataReductionProxyEnabled()) return false;
         ConnectivityManager cm =
                 (ConnectivityManager) mApplication.getApplicationContext().getSystemService(
                         Context.CONNECTIVITY_SERVICE);
         return !cm.isActiveNetworkMetered() || shouldPrerenderOnCellularForSession(session);
     }
 
     /** Cancels a prerender for a given session, or any session if null. */
+    @VisibleForTesting
     void cancelPrerender(CustomTabsSessionToken session) {
+        if (mSpeculation == null) return;
+        if (session != null && !session.equals(mSpeculation.session)) return;
+        switch (mSpeculation.debugOverrideValue) {
+            case NO_OVERRIDE:
+                cancelNoOverridePrerender(session);
+                break;
+            default:
+                return;
+        }
+    }
+
+    private void cancelNoOverridePrerender(CustomTabsSessionToken session) {
         ThreadUtils.assertOnUiThread();
-        if (mSpeculation != null && (session == null || session.equals(mSpeculation.session))
-                && mSpeculation.webContents != null) {
-            mExternalPrerenderHandler.cancelCurrentPrerender();
-            mSpeculation.webContents.destroy();
-            mSpeculation = null;
-        }
+        if (mSpeculation.webContents == null) return;
+        mExternalPrerenderHandler.cancelCurrentPrerender();
+        mSpeculation.webContents.destroy();
+        mSpeculation = null;
     }
 
     /**
      * Tries to request a prerender for a given URL.
      *
      * @param session Session the request comes from.
      * @param url URL to prerender.
      * @param extras extra parameters.
      * @param uid UID of the caller.
      * @return true if a prerender has been initiated.
      */
     private boolean prerenderUrl(
             CustomTabsSessionToken session, String url, Bundle extras, int uid) {
         ThreadUtils.assertOnUiThread();
-        // Ignores mayPrerender() for an empty URL, since it cancels an existing prerender.
-        if (!mayPrerender(session) && !TextUtils.isEmpty(url)) return false;

[ahemery1, 2017/03/21 15:15:57]

Unnecessary duplicate.

         if (!mWarmupHasBeenCalled.get()) return false;
-        // Last one wins and cancels the previous prerender.
-        cancelPrerender(null);
-        if (TextUtils.isEmpty(url)) return false;

[ahemery1, 2017/03/21 15:15:57]

Extracted because behavior is more general than just prerender. See comment line
336 of new version.

+
         boolean throttle = !shouldPrerenderOnCellularForSession(session);
         if (throttle && !mClientManager.isPrerenderingAllowed(uid)) return false;
 
         // A prerender will be requested. Time to destroy the spare WebContents.
         WarmupManager.getInstance().destroySpareWebContents();
 
         Intent extrasIntent = new Intent();
         if (extras != null) extrasIntent.putExtras(extras);
         if (IntentHandler.getExtraHeadersFromIntent(extrasIntent) != null) return false;
         if (mExternalPrerenderHandler == null) {
             mExternalPrerenderHandler = new ExternalPrerenderHandler();
         }
         Rect contentBounds = ExternalPrerenderHandler.estimateContentSize(mApplication, true);
         String referrer = IntentHandler.getReferrerUrlIncludingExtraHeaders(extrasIntent);
         if (referrer == null && getReferrerForSession(session) != null) {
             referrer = getReferrerForSession(session).getUrl();
         }
         if (referrer == null) referrer = "";
-        Pair<WebContents, WebContents> webContentsPair = mExternalPrerenderHandler.addPrerender(
-                Profile.getLastUsedProfile(), url, referrer,
-                contentBounds,
-                shouldPrerenderOnCellularForSession(session));
+        Pair<WebContents, WebContents> webContentsPair =
+                mExternalPrerenderHandler.addPrerender(Profile.getLastUsedProfile(), url, referrer,
+                        contentBounds, shouldPrerenderOnCellularForSession(session));
         if (webContentsPair == null) return false;
         WebContents dummyWebContents = webContentsPair.first;
         if (webContentsPair.second != null) {
             mClientManager.resetPostMessageHandlerForSession(session, webContentsPair.second);
         }
         if (throttle) mClientManager.registerPrerenderRequest(uid, url);
-        mSpeculation = SpeculationParams.forPrerender(
-                session, url, dummyWebContents, referrer, extras);
+        mSpeculation =
+                SpeculationParams.forPrerender(session, url, dummyWebContents, referrer, extras);
 
         RecordHistogram.recordBooleanHistogram("CustomTabs.PrerenderSessionUsesDefaultParameters",
                 mClientManager.usesDefaultSessionParameters(session));
 
         return true;
     }
 
     @VisibleForTesting
     void resetThrottling(Context context, int uid) {
         mClientManager.resetThrottling(uid);
     }
 
     @VisibleForTesting
     void ban(Context context, int uid) {
         mClientManager.ban(uid);
     }
 
     @VisibleForTesting
     void setForcePrerender(boolean force) {
         mForcePrerenderForTesting = force;
     }
 }