customtabs: Extract a redirect endpoint, and maybe connect to it.

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 10 matching lines @@
 import android.os.SystemClock;
 import android.support.customtabs.CustomTabsCallback;
 import android.support.customtabs.CustomTabsIntent;
 import android.support.customtabs.CustomTabsService;
 import android.support.customtabs.CustomTabsSessionToken;
 import android.text.TextUtils;
 import android.util.Pair;
 import android.widget.RemoteViews;
 
 import org.chromium.base.CommandLine;
+import org.chromium.base.ContextUtils;
 import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.TimeUtils;
 import org.chromium.base.TraceEvent;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.base.library_loader.ProcessInitException;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.AppHooks;
 import org.chromium.chrome.browser.ChromeApplication;
 import org.chromium.chrome.browser.ChromeFeatureList;
 import org.chromium.chrome.browser.IntentHandler;
 import org.chromium.chrome.browser.WarmupManager;
 import org.chromium.chrome.browser.device.DeviceClassManager;
 import org.chromium.chrome.browser.init.ChromeBrowserInitializer;
 import org.chromium.chrome.browser.metrics.PageLoadMetrics;
 import org.chromium.chrome.browser.net.spdyproxy.DataReductionProxySettings;
 import org.chromium.chrome.browser.preferences.PrefServiceBridge;
 import org.chromium.chrome.browser.prerender.ExternalPrerenderHandler;
 import org.chromium.chrome.browser.profiles.Profile;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.util.IntentUtils;
 import org.chromium.chrome.browser.util.UrlUtilities;
 import org.chromium.content.browser.ChildProcessLauncherHelper;
 import org.chromium.content_public.browser.LoadUrlParams;
 import org.chromium.content_public.browser.WebContents;
 import org.chromium.content_public.common.Referrer;
+import org.chromium.net.GURLUtils;
 
 import java.io.BufferedReader;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.List;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ skipping 40 matching lines @@
     static final String DEBUG_OVERRIDE_KEY =
             "android.support.customtabs.maylaunchurl.DEBUG_OVERRIDE";
     private static final int NO_OVERRIDE = 0;
     @VisibleForTesting
     static final int NO_PRERENDERING = 1;
     @VisibleForTesting
     static final int PREFETCH_ONLY = 2;
     @VisibleForTesting
     static final int HIDDEN_TAB = 3;
 
+    @VisibleForTesting
+    static final String REDIRECT_ENDPOINT_KEY = "android.support.customtabs.REDIRECT_ENDPOINT";

[Yusuf, 2017/07/06 06:34:42]

some todo around moving this to support lib?

[Benoit L, 2017/07/07 11:30:56]

Done.

+
     private static AtomicReference<CustomTabsConnection> sInstance = new AtomicReference<>();
 
     /** Holds the parameters for the current speculation. */
     @VisibleForTesting
     static final class SpeculationParams {
         @VisibleForTesting
         static final int NO_SPECULATION = 0;
         @VisibleForTesting
         static final int PREFETCH = 1;
         @VisibleForTesting
@@ skipping 210 matching lines @@
                     }
                 } finally {
                     TraceEvent.end("CustomTabsConnection.warmupInternal");
                 }
                 mWarmupHasBeenFinished.set(true);
             }
         });
         return true;
     }
 
-    /** @return the URL converted to string, or null if it's invalid. */
-    private static String checkAndConvertUri(Uri uri) {
-        if (uri == null) return null;
+    /** @return the URL or null if it's invalid. */
+    private boolean isValid(Uri uri) {
+        if (uri == null) return false;
         // Don't do anything for unknown schemes. Not having a scheme is allowed, as we allow
         // "www.example.com".
         String scheme = uri.normalizeScheme().getScheme();
         boolean allowedScheme = scheme == null || scheme.equals("http") || scheme.equals("https");
-        if (!allowedScheme) return null;
-        return uri.toString();
+        if (!allowedScheme) return false;
+        return true;
     }
 
     /**
      * High confidence mayLaunchUrl() call, that is:
      * - Tries to prerender if possible.
      * - An empty URL cancels the current prerender if any.
      * - If prerendering is not possible, makes sure that there is a spare renderer.
      */
     private void highConfidenceMayLaunchUrl(CustomTabsSessionToken session,
             int uid, String url, Bundle extras, List<Bundle> otherLikelyBundles) {
@@ skipping 30 matching lines @@
         if (likelyBundles == null) return false;
         WarmupManager warmupManager = WarmupManager.getInstance();
         Profile profile = Profile.getLastUsedProfile();
         for (Bundle bundle : likelyBundles) {
             Uri uri;
             try {
                 uri = IntentUtils.safeGetParcelable(bundle, CustomTabsService.KEY_URL);
             } catch (ClassCastException e) {
                 continue;
             }
-            String url = checkAndConvertUri(uri);
-            if (url != null) {
-                warmupManager.maybePreconnectUrlAndSubResources(profile, url);
+            if (isValid(uri)) {
+                warmupManager.maybePreconnectUrlAndSubResources(profile, uri.toString());
                 atLeastOneUrl = true;
             }
         }
         return atLeastOneUrl;
     }
 
     public boolean mayLaunchUrl(CustomTabsSessionToken session, Uri url, Bundle extras,
             List<Bundle> otherLikelyBundles) {
         try {
             TraceEvent.begin("CustomTabsConnection.mayLaunchUrl");
             boolean success = mayLaunchUrlInternal(session, url, extras, otherLikelyBundles);
             logCall("mayLaunchUrl(" + url + ")", success);
             return success;
         } finally {
             TraceEvent.end("CustomTabsConnection.mayLaunchUrl");
         }
     }
 
     private boolean mayLaunchUrlInternal(final CustomTabsSessionToken session, Uri url,
             final Bundle extras, final List<Bundle> otherLikelyBundles) {
         final boolean lowConfidence =
                 (url == null || TextUtils.isEmpty(url.toString())) && otherLikelyBundles != null;
-        final String urlString = checkAndConvertUri(url);
+        final String urlString = isValid(url) ? url.toString() : null;
         if (url != null && urlString == null && !lowConfidence) return false;
 
         // Things below need the browser process to be initialized.
 
         // Forbids warmup() from creating a spare renderer, as prerendering wouldn't reuse
         // it. Checking whether prerendering is enabled requires the native library to be loaded,
         // which is not necessarily the case yet.
         if (!warmupInternal(false)) return false; // Also does the foreground check.
 
         final int uid = Binder.getCallingUid();
@@ skipping 274 matching lines @@
                             SPECULATION_STATUS_ON_SWAP_BACKGROUND_TAB_NOT_MATCHED);
                     tab.destroy();
                 }
             }
         } finally {
             TraceEvent.end("CustomTabsConnection.takeHiddenTab");
         }
         return null;
     }
 
+    /**
+     * Called when an intent is handled by either an existing or a new CustomTabActivity.
+     *
+     * @param session Session extracted from the intent.
+     * @param url URL extracted from the intent.
+     * @param intent incoming intent.
+     */
+    void onHandledIntent(CustomTabsSessionToken session, String url, Intent intent) {
+        // For the preconnection to not be a no-op, we need more than just the native library.
+        Context context = ContextUtils.getApplicationContext();
+        if (!ChromeBrowserInitializer.getInstance(context).hasNativeInitializationCompleted()) {
+            return;
+        }
+        if (!ChromeFeatureList.isEnabled(ChromeFeatureList.CCT_REDIRECT_PRECONNECT)) return;
+
+        // Conditions:
+        // - There is a valid redirect endpoint.
+        // - The URL's origin is first party with respect to the app.
+        Uri redirectEndpoint = intent.getParcelableExtra(REDIRECT_ENDPOINT_KEY);

[Yusuf, 2017/07/06 06:34:41]

does it make sense to have this logic be in CustomTabIntentDataProvider?

[Benoit L, 2017/07/07 11:30:56]

This talks to ClientManager, and also I find it convenient to keep all the
"optimizations" in the same location.
wdyt?

+        if (redirectEndpoint == null || !isValid(redirectEndpoint)) return;
+
+        String origin = GURLUtils.getOrigin(url);
+        if (origin == null) return;
+        if (!mClientManager.isFirstPartyOriginForSession(session, Uri.parse(origin))) return;

[Yusuf, 2017/07/06 06:34:41]

Going back all the way to how we handle isValidOrigin, since this is independent
of current navigation and best effort, why not try to verify async as well? That
way we dont have to wait for the verifyOrigin support lib part to come to use
this, it would mostly improve and move that network request to earlier. Wdyt?

[Benoit L, 2017/07/07 11:30:55]

That would be a neat solution indeed.

However it would also likely cause complications, as in this case we would issue
the domain verification request at the same time as the navigations, and
essentially have a "race" between walking the redirects and getting the
validation of the origin.

If the two servers as as fast, then we don't gain anything, and end up with an
unused socket. Otherwise we might still see benefits.

I would err on the side of not doing it for now, as this would simplify metrics.
But I'm not firm on that.

+
+        WarmupManager.getInstance().maybePreconnectUrlAndSubResources(
+                Profile.getLastUsedProfile(), redirectEndpoint.toString());

[Yusuf, 2017/07/06 06:34:41]

getLastUsedProfile().getOriginalProfile() to avoid incognito.

[Benoit L, 2017/07/07 11:30:56]

Thanks!

Done.

+    }
+
     /** See {@link ClientManager#getReferrerForSession(CustomTabsSessionToken)} */
     public Referrer getReferrerForSession(CustomTabsSessionToken session) {
         return mClientManager.getReferrerForSession(session);
     }
 
     /** @see ClientManager#shouldHideDomainForSession(CustomTabsSessionToken) */
     public boolean shouldHideDomainForSession(CustomTabsSessionToken session) {
         return mClientManager.shouldHideDomainForSession(session);
     }
 
@@ skipping 496 matching lines @@
     private static void recordSpeculationStatusOnStart(int status) {
         RecordHistogram.recordEnumeratedHistogram(
                 "CustomTabs.SpeculationStatusOnStart", status, SPECULATION_STATUS_ON_START_MAX);
     }
 
     private static void recordSpeculationStatusOnSwap(int status) {
         RecordHistogram.recordEnumeratedHistogram(
                 "CustomTabs.SpeculationStatusOnSwap", status, SPECULATION_STATUS_ON_SWAP_MAX);
     }
 }