CustomTabs: Base version for prerender switch

chrome/android/javatests/src/org/chromium/chrome/browser/customtabs/CustomTabActivityTest.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 static org.chromium.base.test.util.Restriction.RESTRICTION_TYPE_NON_LOW_END_DEVICE;
 
 import android.app.Activity;
 import android.app.Application;
@@ skipping 1348 matching lines @@
     @SmallTest
     @RetryOnFailure
     @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
     public void testPostMessageThroughPrerenderWithRequestAfterIntent()
             throws InterruptedException {
         sendPostMessageDuringPrerenderTransition(AFTER_INTENT);
     }
 
     private void sendPostMessageDuringPrerenderTransition(int requestTime)
             throws InterruptedException {
+        sendPostMessageDuringSpeculationTransition(
+                requestTime, CustomTabsConnection.SpeculationParams.PRERENDER);
+    }
+
+    private void sendPostMessageDuringSpeculationTransition(int requestTime, int speculationMode)
+            throws InterruptedException {
         final CallbackHelper messageChannelHelper = new CallbackHelper();
         final String url =
                 mWebServer.setResponse("/test.html", TITLE_FROM_POSTMESSAGE_TO_CHANNEL, null);
-        warmUpAndWait();
+        final CustomTabsConnection connection = warmUpAndWait();
+
         final CustomTabsSession session = bindWithCallback(new CustomTabsCallback() {
             @Override
             public void onMessageChannelReady(Bundle extras) {
                 messageChannelHelper.notifyCalled();
             }
         });
+
+        Intent intent = new CustomTabsIntent.Builder(session).build().intent;
+        intent.setData(Uri.parse(url));
+        intent.setComponent(new ComponentName(
+                getInstrumentation().getTargetContext(), ChromeLauncherActivity.class));
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        CustomTabsSessionToken token = CustomTabsSessionToken.getSessionTokenFromIntent(intent);
+
         boolean channelRequested = false;
         String titleString = "";
         String currentMessage = "";
 
         if (requestTime == BEFORE_MAY_LAUNCH_URL) {
             channelRequested = session.requestPostMessageChannel(null);
             assertTrue(channelRequested);
         }
 
+        connection.setSpeculationModeForSession(token, speculationMode);
         session.mayLaunchUrl(Uri.parse(url), null, null);
         try {
-            ensureCompletedPrerenderForUrl(
-                    CustomTabsConnection.getInstance((Application)
-                            getInstrumentation().getTargetContext().getApplicationContext()), url);
+            ensureCompletedSpeculationForUrl(connection, url, speculationMode);
         } catch (Exception e) {
             fail();
         }
 
         if (requestTime == BEFORE_INTENT) {
             channelRequested = session.requestPostMessageChannel(null);
             assertTrue(channelRequested);
         }
 
         if (channelRequested) {
             try {
                 messageChannelHelper.waitForCallback(0);
             } catch (TimeoutException e) {
                 fail();
             }
             currentMessage = "Prerendering ";
             // Initial title update during prerender.
             assertTrue(session.postMessage(currentMessage, null)
                     == CustomTabsService.RESULT_SUCCESS);
             titleString = currentMessage;
         }
 
-        Intent intent = new CustomTabsIntent.Builder(session).build().intent;
-        intent.setData(Uri.parse(url));
-        intent.setComponent(new ComponentName(
-                getInstrumentation().getTargetContext(), ChromeLauncherActivity.class));
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
         try {
             startCustomTabActivityWithIntent(intent);
         } catch (InterruptedException e) {
             fail();
         }
 
         CriteriaHelper.pollInstrumentationThread(new Criteria() {
             @Override
             public boolean isSatisfied() {
                 final Tab currentTab = getActivity().getActivityTab();
@@ skipping 47 matching lines @@
      */
     @SmallTest
     @RetryOnFailure
     public void testPrecreatedRenderer() throws InterruptedException {
         CustomTabsConnection connection = warmUpAndWait();
         Context context = getInstrumentation().getTargetContext();
         Intent intent = CustomTabsTestUtils.createMinimalCustomTabIntent(context, mTestPage);
         CustomTabsSessionToken token = CustomTabsSessionToken.getSessionTokenFromIntent(intent);
         assertTrue(connection.newSession(token));
         Bundle extras = new Bundle();
+        // Forcing no prerendering implies falling back to simply creating a spare WebContents.
         extras.putInt(
                 CustomTabsConnection.DEBUG_OVERRIDE_KEY, CustomTabsConnection.NO_PRERENDERING);
         assertTrue(connection.mayLaunchUrl(token, Uri.parse(mTestPage), extras, null));
         try {
             startCustomTabActivityWithIntent(intent);
         } catch (InterruptedException e) {
             fail();
         }
         CriteriaHelper.pollInstrumentationThread(new Criteria() {
             @Override
             public boolean isSatisfied() {
                 final Tab currentTab = getActivity().getActivityTab();
                 return mTestPage.equals(currentTab.getUrl());
             }
         });
         assertFalse(getActivity().getActivityTab().canGoBack());
     }
 
+    /** Tests that calling warmup() is optional without prerendering. */
+    @SmallTest
+    @RetryOnFailure
+    public void testMayLaunchUrlWithoutWarmupNoSpeculation() {
+        mayLaunchUrlWithoutWarmup(CustomTabsConnection.SpeculationParams.NO_SPECULATION);
+    }
+
     /** Tests that calling mayLaunchUrl() without warmup() succeeds. */
     @SmallTest
     @RetryOnFailure
-    public void testMayLaunchUrlWithoutWarmup() {
-        mayLaunchUrlWithoutWarmup(false);
-    }
-
-    /** Tests that calling warmup() is optional without prerendering. */
-    @SmallTest
-    @RetryOnFailure
-    public void testMayLaunchUrlWithoutWarmupNoPrerendering() {
-        mayLaunchUrlWithoutWarmup(true);
+    public void testMayLaunchUrlWithoutWarmupPrerender() {
+        mayLaunchUrlWithoutWarmup(CustomTabsConnection.SpeculationParams.PRERENDER);
     }
 
     /**
      * Tests that launching a regular Chrome tab after warmup() gives the right layout.
      *
      * About the restrictions and switches: No FRE and no document mode to get a
      * ChromeTabbedActivity, and no tablets to have the tab switcher button.
      *
      * Non-regression test for crbug.com/547121.
      * @SmallTest
@@ skipping 80 matching lines @@
      * - loadUrl("http://example.com/page.html#other-fragment")
      *
      * There are two parameters changing the bahavior:
      * @param ignoreFragments Whether the prerender should be kept.
      * @param wait Whether to wait for the prerender to load.
      *
      * The prerender state is assessed through monitoring the properties of the test page.
      */
     private void prerenderAndChangeFragment(boolean ignoreFragments, boolean wait)
             throws Exception {
+        speculateAndChangeFragment(
+                ignoreFragments, wait, CustomTabsConnection.SpeculationParams.PRERENDER);
+    }
+
+    private void speculateAndChangeFragment(
+            boolean ignoreFragments, boolean wait, int speculationMode) throws Exception {
         String testUrl = mTestServer.getURL(FRAGMENT_TEST_PAGE);
         String initialFragment = "#test";
         String initialUrl = testUrl + initialFragment;
         String fragment = "#yeah";
         String urlWithFragment = testUrl + fragment;
 
         Context context = getInstrumentation().getTargetContext().getApplicationContext();
         CustomTabsConnection connection = warmUpAndWait();
         Intent intent = CustomTabsTestUtils.createMinimalCustomTabIntent(context, urlWithFragment);
         CustomTabsSessionToken token = CustomTabsSessionToken.getSessionTokenFromIntent(intent);
         connection.newSession(token);
         connection.setIgnoreUrlFragmentsForSession(token, ignoreFragments);
+        connection.setSpeculationModeForSession(token, speculationMode);
         assertTrue(connection.mayLaunchUrl(token, Uri.parse(initialUrl), null, null));
 
-        if (wait) ensureCompletedPrerenderForUrl(connection, initialUrl);
+        if (wait) ensureCompletedSpeculationForUrl(connection, initialUrl, speculationMode);
 
         try {
             startCustomTabActivityWithIntent(intent);
         } catch (InterruptedException e) {
             fail();
         }
         final Tab tab = mActivity.getActivityTab();
-        ElementContentCriteria initialVisibilityCriteria = new ElementContentCriteria(
-                tab, "visibility", ignoreFragments ? "prerender" : "visible");
-        ElementContentCriteria initialFragmentCriteria = new ElementContentCriteria(
-                tab, "initial-fragment", ignoreFragments ? initialFragment : fragment);
-        ElementContentCriteria fragmentCriteria = new ElementContentCriteria(
-                tab, "fragment", fragment);
 
         if (wait) {
+            ElementContentCriteria initialVisibilityCriteria = new ElementContentCriteria(tab,
+                    "visibility",
+                    ignoreFragments ? getExpectedVisibilityForSpeculationMode(speculationMode)
+                                    : "visible");
+            ElementContentCriteria initialFragmentCriteria = new ElementContentCriteria(
+                    tab, "initial-fragment", ignoreFragments ? initialFragment : fragment);
+            ElementContentCriteria fragmentCriteria =
+                    new ElementContentCriteria(tab, "fragment", fragment);
             // The tab hasn't been reloaded.
             CriteriaHelper.pollInstrumentationThread(initialVisibilityCriteria, 2000, 200);
             // No reload (initial fragment is correct).
             CriteriaHelper.pollInstrumentationThread(initialFragmentCriteria, 2000, 200);
             if (ignoreFragments) {
                 CriteriaHelper.pollInstrumentationThread(fragmentCriteria, 2000, 200);
             }
         } else {
             CriteriaHelper.pollInstrumentationThread(new ElementContentCriteria(
                     tab, "initial-fragment", fragment), 2000, 200);
         }
         assertFalse(tab.canGoForward());
         assertFalse(tab.canGoBack());
     }
 
     /**
      * Test whether the url shown on prerender gets updated from about:blank when the prerender
      * completes in the background.
      * Non-regression test for crbug.com/554236.
      */
     @SmallTest
     @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
     @RetryOnFailure
     public void testPrerenderingCorrectUrl() throws Exception {
+        testSpeculateCorrectUrl(CustomTabsConnection.SpeculationParams.PRERENDER);
+    }
+
+    private void testSpeculateCorrectUrl(int speculationMode) throws Exception {
         Context context = getInstrumentation().getTargetContext().getApplicationContext();
         final CustomTabsConnection connection = warmUpAndWait();
         CustomTabsSessionToken token = CustomTabsSessionToken.createDummySessionTokenForTesting();
         connection.newSession(token);
+        connection.setSpeculationModeForSession(token, speculationMode);
         assertTrue(connection.mayLaunchUrl(token, Uri.parse(mTestPage), null, null));
-        ensureCompletedPrerenderForUrl(connection, mTestPage);
+        ensureCompletedSpeculationForUrl(connection, mTestPage, speculationMode);
 
         try {
             startCustomTabActivityWithIntent(CustomTabsTestUtils.createMinimalCustomTabIntent(
                     context, mTestPage));
         } catch (InterruptedException e) {
             fail();
         }
         assertEquals(Uri.parse(mTestPage).getHost() + ":" + Uri.parse(mTestPage).getPort(),
                 ((EditText) mActivity.findViewById(R.id.url_bar)).getText()
                         .toString());
     }
 
     /**
      * Test whether invalid urls are avoided for prerendering.
      */
     @SmallTest
     @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
     @RetryOnFailure
     public void testPrerenderingInvalidUrl() throws Exception {
+        testSpeculateInvalidUrl(CustomTabsConnection.SpeculationParams.PRERENDER);
+    }
+
+    private void testSpeculateInvalidUrl(int speculationMode) throws Exception {
         final CustomTabsConnection connection = warmUpAndWait();
         CustomTabsSessionToken token = CustomTabsSessionToken.createDummySessionTokenForTesting();
         connection.newSession(token);
+        connection.setSpeculationModeForSession(token, speculationMode);
         assertFalse(connection.mayLaunchUrl(token, Uri.parse("chrome://version"), null, null));
     }
 
     /**
      * Tests that the activity knows there is already a child process when warmup() has been called.
      */
     @SmallTest
     @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
     @RetryOnFailure
     public void testAllocateChildConnectionWithWarmup() throws Exception {
@@ skipping 44 matching lines @@
         });
     }
 
     /**
      * Tests that the activity knows there is already a child process when prerendering.
      */
     @SmallTest
     @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
     @RetryOnFailure
     public void testAllocateChildConnectionWithPrerender() throws Exception {
+        testAllocateChildConnectionWithSpeculation(
+                CustomTabsConnection.SpeculationParams.PRERENDER);
+    }
+
+    private void testAllocateChildConnectionWithSpeculation(int speculationMode) throws Exception {
         Context context = getInstrumentation().getTargetContext().getApplicationContext();
         final CustomTabsConnection connection = warmUpAndWait();
         CustomTabsSessionToken token = CustomTabsSessionToken.createDummySessionTokenForTesting();
         connection.newSession(token);
+        connection.setSpeculationModeForSession(token, speculationMode);
         assertTrue(connection.mayLaunchUrl(token, Uri.parse(mTestPage), null, null));
         try {
             startCustomTabActivityWithIntent(
                     CustomTabsTestUtils.createMinimalCustomTabIntent(context, mTestPage));
         } catch (InterruptedException e) {
             fail();
         }
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
@@ skipping 33 matching lines @@
     }
 
     /**
      * Tests that prerendering accepts a referrer, and that this is not lost when launching the
      * Custom Tab.
      */
     @SmallTest
     @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
     @RetryOnFailure
     public void testPrerenderingWithReferrer() throws Exception {
+        testSpeculatingWithReferrer(CustomTabsConnection.SpeculationParams.PRERENDER);
+    }
+
+    private void testSpeculatingWithReferrer(int speculationMode) throws Exception {
         String referrer = "android-app://com.foo.me/";
-        maybePrerenderAndLaunchWithReferrers(
-                mTestServer.getURL(FRAGMENT_TEST_PAGE), true, referrer, referrer);
+        maybeSpeculateAndLaunchWithReferrers(
+                mTestServer.getURL(FRAGMENT_TEST_PAGE), speculationMode, referrer, referrer);
 
         Tab tab = mActivity.getActivityTab();
         // The tab hasn't been reloaded.
         CriteriaHelper.pollInstrumentationThread(
-                new ElementContentCriteria(tab, "visibility", "prerender"), 2000, 200);
+                new ElementContentCriteria(tab, "visibility",
+                        getExpectedVisibilityForSpeculationMode(speculationMode)),
+                2000, 200);
         // The Referrer is correctly set.
         CriteriaHelper.pollInstrumentationThread(
                 new TabsOpenedFromExternalAppTest.ReferrerCriteria(tab, referrer), 2000, 200);
     }
 
     /**
      * Tests that prerendering accepts a referrer, and that the prerender is dropped when the tab
      * is launched with a mismatched referrer.
      */
     @SmallTest
     @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
     @RetryOnFailure
     public void testPrerenderingWithMismatchedReferrers() throws Exception {
+        testSpeculatingWithMismatchedReferrers(CustomTabsConnection.SpeculationParams.PRERENDER);
+    }
+
+    private void testSpeculatingWithMismatchedReferrers(int speculationMode) throws Exception {
         String prerenderReferrer = "android-app://com.foo.me/";
         String launchReferrer = "android-app://com.foo.me.i.changed.my.mind/";
-        maybePrerenderAndLaunchWithReferrers(
-                mTestServer.getURL(FRAGMENT_TEST_PAGE), true, prerenderReferrer, launchReferrer);
+        maybeSpeculateAndLaunchWithReferrers(mTestServer.getURL(FRAGMENT_TEST_PAGE),
+                speculationMode, prerenderReferrer, launchReferrer);
 
         Tab tab = mActivity.getActivityTab();
         // Prerender has been dropped.
         CriteriaHelper.pollInstrumentationThread(
                 new ElementContentCriteria(tab, "visibility", "visible"), 2000, 200);
         // The Referrer is correctly set.
         CriteriaHelper.pollInstrumentationThread(
                 new TabsOpenedFromExternalAppTest.ReferrerCriteria(tab, launchReferrer), 2000, 200);
     }
 
-    /** Tests that a client can set a referrer, without prerendering. */
+    /** Tests that a client can set a referrer, without speculating. */
     @SmallTest
     @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
     @RetryOnFailure
     public void testClientCanSetReferrer() throws Exception {
         String referrerUrl = "android-app://com.foo.me/";
-        maybePrerenderAndLaunchWithReferrers(mTestPage, false, null, referrerUrl);
+        maybeSpeculateAndLaunchWithReferrers(mTestPage,
+                CustomTabsConnection.SpeculationParams.NO_SPECULATION, null, referrerUrl);
 
         Tab tab = mActivity.getActivityTab();
         // The Referrer is correctly set.
         CriteriaHelper.pollInstrumentationThread(
                 new TabsOpenedFromExternalAppTest.ReferrerCriteria(tab, referrerUrl), 2000, 200);
     }
 
     /**
      * Tests that a Weblite URL from an external app uses the lite_url param when Data Reduction
      * Proxy previews are being used.
@@ skipping 82 matching lines @@
     @RetryOnFailure
     public void testLaunchNonWebLiteURL() throws Exception {
         final String testUrl = mTestPage2 + "/?lite_url=" + mTestPage;
         startCustomTabActivityWithIntent(CustomTabsTestUtils.createMinimalCustomTabIntent(
                 getInstrumentation().getTargetContext(), testUrl));
         Tab tab = getActivity().getActivityTab();
         assertEquals(testUrl, tab.getUrl());
     }
 
     /** Maybe prerenders a URL with a referrer, then launch it with another one. */
-    private void maybePrerenderAndLaunchWithReferrers(String url, boolean prerender,
-            String prerenderReferrer, String launchReferrer) throws Exception {
+    private void maybeSpeculateAndLaunchWithReferrers(String url, int speculationMode,
+            String speculationReferrer, String launchReferrer) throws Exception {
         Context context = getInstrumentation().getTargetContext().getApplicationContext();
         CustomTabsConnection connection = null;
         CustomTabsSessionToken token = null;
         Intent intent = CustomTabsTestUtils.createMinimalCustomTabIntent(context, url);
-        if (prerender) {
+        if (speculationMode != CustomTabsConnection.SpeculationParams.NO_SPECULATION) {
             connection = warmUpAndWait();
             token = CustomTabsSessionToken.getSessionTokenFromIntent(intent);
             connection.newSession(token);
+            connection.setSpeculationModeForSession(token, speculationMode);
             Bundle extras = null;
-            if (prerenderReferrer != null) {
+            if (speculationReferrer != null) {
                 extras = new Bundle();
-                extras.putParcelable(Intent.EXTRA_REFERRER, Uri.parse(prerenderReferrer));
+                extras.putParcelable(Intent.EXTRA_REFERRER, Uri.parse(speculationReferrer));
             }
             assertTrue(connection.mayLaunchUrl(token, Uri.parse(url), extras, null));
-            ensureCompletedPrerenderForUrl(connection, url);
+            ensureCompletedSpeculationForUrl(connection, url, speculationMode);
         }
 
         if (launchReferrer != null) {
             intent.putExtra(Intent.EXTRA_REFERRER, Uri.parse(launchReferrer));
         }
         try {
             startCustomTabActivityWithIntent(intent);
         } catch (InterruptedException e) {
             fail();
         }
     }
 
-    private void mayLaunchUrlWithoutWarmup(boolean noPrerendering) {
+    private void mayLaunchUrlWithoutWarmup(int speculationMode) {
         Context context = getInstrumentation().getTargetContext().getApplicationContext();
         CustomTabsConnection connection =
                 CustomTabsTestUtils.setUpConnection((Application) context);
         CustomTabsSessionToken token = CustomTabsSessionToken.createDummySessionTokenForTesting();
         connection.newSession(token);
         Bundle extras = null;
-        if (noPrerendering) {
+        if (speculationMode == CustomTabsConnection.SpeculationParams.NO_SPECULATION) {
             extras = new Bundle();
             extras.putInt(
                     CustomTabsConnection.DEBUG_OVERRIDE_KEY, CustomTabsConnection.NO_PRERENDERING);
         }
+        connection.setSpeculationModeForSession(token, speculationMode);
         assertTrue(connection.mayLaunchUrl(token, Uri.parse(mTestPage), extras, null));
         try {
             startCustomTabActivityWithIntent(CustomTabsTestUtils.createMinimalCustomTabIntent(
                     context, mTestPage));
         } catch (InterruptedException e) {
             fail();
         }
         Tab tab = getActivity().getActivityTab();
         assertEquals(mTestPage, tab.getUrl());
     }
@@ skipping 89 matching lines @@
         startCustomTabActivityWithIntent(intentWithSession);
         return token;
     }
 
     private CustomTabsSessionToken warmUpAndLaunchUrlWithSession() throws InterruptedException {
         return warmUpAndLaunchUrlWithSession(
                 CustomTabsTestUtils.createMinimalCustomTabIntent(
                         getInstrumentation().getTargetContext(), mTestPage));
     }
 
-    private static void ensureCompletedPrerenderForUrl(
-            final CustomTabsConnection connection, final String url) throws Exception {
-        CriteriaHelper.pollUiThread(new Criteria("No Prerender") {
-            @Override
-            public boolean isSatisfied() {
-                return connection.mSpeculation != null
-                        && connection.mSpeculation.webContents != null
-                        && ExternalPrerenderHandler.hasPrerenderedAndFinishedLoadingUrl(
-                                   Profile.getLastUsedProfile(), url,
-                                   connection.mSpeculation.webContents);
-            }
-        }, LONG_TIMEOUT_MS, CriteriaHelper.DEFAULT_POLLING_INTERVAL);
+    private static void ensureCompletedSpeculationForUrl(final CustomTabsConnection connection,
+            final String url, int speculationMode) throws Exception {
+        if (speculationMode == CustomTabsConnection.SpeculationParams.PRERENDER) {
+            CriteriaHelper.pollUiThread(new Criteria("No Prerender") {
+                @Override
+                public boolean isSatisfied() {
+                    return connection.mSpeculation != null
+                            && connection.mSpeculation.webContents != null
+                            && ExternalPrerenderHandler.hasPrerenderedAndFinishedLoadingUrl(
+                                       Profile.getLastUsedProfile(), url,
+                                       connection.mSpeculation.webContents);
+                }
+            }, LONG_TIMEOUT_MS, CriteriaHelper.DEFAULT_POLLING_INTERVAL);
+        }
     }
 
     private CustomTabsSession bindWithCallback(final CustomTabsCallback callback) {
         final AtomicReference<CustomTabsSession> sessionReference = new AtomicReference<>(null);
         CustomTabsClient.bindCustomTabsService(getInstrumentation().getContext(),
                 getInstrumentation().getTargetContext().getPackageName(),
                 new CustomTabsServiceConnection() {
                     @Override
                     public void onServiceDisconnected(ComponentName name) {}
 
@@ skipping 67 matching lines @@
                         mTab.getWebContents(), mJsFunction);
                 if (jsonText.equalsIgnoreCase("null")) jsonText = "";
                 value = jsonText;
             } catch (InterruptedException | TimeoutException e) {
                 e.printStackTrace();
                 return false;
             }
             return TextUtils.equals(mExpected, value);
         }
     }
+
+    private static String getExpectedVisibilityForSpeculationMode(int speculationMode) {
+        switch (speculationMode) {
+            case CustomTabsConnection.SpeculationParams.PRERENDER:
+                return "prerender";
+            default:
+                return "visible";
+        }
+    }
 }