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 70 matching lines @@
 import org.chromium.content.browser.test.util.Criteria;
 import org.chromium.content.browser.test.util.CriteriaHelper;
 import org.chromium.content.browser.test.util.DOMUtils;
 import org.chromium.content.browser.test.util.JavaScriptUtils;
 import org.chromium.content_public.browser.LoadUrlParams;
 import org.chromium.content_public.browser.WebContentsObserver;
 import org.chromium.net.test.EmbeddedTestServer;
 import org.chromium.net.test.util.TestWebServer;
 
 import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.Callable;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * Instrumentation tests for app menu, context menu, and toolbar of a {@link CustomTabActivity}.
  */
 public class CustomTabActivityTest extends CustomTabActivityTestBase {
     private static final int MAX_MENU_CUSTOM_ITEMS = 5;
@@ skipping 32 matching lines @@
             + "   </script>"
             + "</body></html>";
 
     private static int sIdToIncrement = 1;
 
     private CustomTabActivity mActivity;
     private String mTestPage;
     private String mTestPage2;
     private EmbeddedTestServer mTestServer;
     private TestWebServer mWebServer;
+    private int mDefaultDebugOverrideValue;
+    private int mLatestDebugOverrideValue;

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

This is some sort of state that we use here only. We need this because we
sometimes need to have information about the speculation even after the
speculationParams have been destroyed. In particular, even when visible, a
prerendered document has a prerender visibility property in javascript.

 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
 
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 FirstRunStatus.setFirstRunFlowComplete(true);
             }
         });
 
         Context appContext = getInstrumentation().getTargetContext().getApplicationContext();
         mTestServer = EmbeddedTestServer.createAndStartServer(appContext);
         mTestPage = mTestServer.getURL(TEST_PAGE);
         mTestPage2 = mTestServer.getURL(TEST_PAGE_2);
         PathUtils.setPrivateDataDirectorySuffix(PRIVATE_DATA_DIRECTORY_SUFFIX);
         LibraryLoader.get(LibraryProcessType.PROCESS_BROWSER).ensureInitialized();
         mWebServer = TestWebServer.start();
 
         CustomTabsConnection connection =
                 CustomTabsConnection.getInstance((Application) appContext);
         connection.setForcePrerender(true);
+        mDefaultDebugOverrideValue = CustomTabsConnection.NO_OVERRIDE;

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

The switch that can be acted upon to modify the entire test suite.

     }
 
     @Override
     protected void tearDown() throws Exception {
         Context appContext = getInstrumentation().getTargetContext().getApplicationContext();
         CustomTabsConnection connection =
                 CustomTabsConnection.getInstance((Application) appContext);
         connection.setForcePrerender(false);
 
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
@@ skipping 1202 matching lines @@
         });
         boolean channelRequested = false;
         String titleString = "";
         String currentMessage = "";
 
         if (requestTime == BEFORE_MAY_LAUNCH_URL) {
             channelRequested = session.requestPostMessageChannel(null);
             assertTrue(channelRequested);
         }
 
-        session.mayLaunchUrl(Uri.parse(url), null, null);
+        mayLaunchUrlForTesting(null, session, null, Uri.parse(url), null, null);
         try {
             ensureCompletedPrerenderForUrl(
                     CustomTabsConnection.getInstance((Application)
                             getInstrumentation().getTargetContext().getApplicationContext()), url);
         } catch (Exception e) {
             fail();
         }
 
         if (requestTime == BEFORE_INTENT) {
             channelRequested = session.requestPostMessageChannel(null);
@@ skipping 78 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 WebContent
         extras.putInt(
                 CustomTabsConnection.DEBUG_OVERRIDE_KEY, CustomTabsConnection.NO_PRERENDERING);
-        assertTrue(connection.mayLaunchUrl(token, Uri.parse(mTestPage), extras, null));
+        assertTrue(mayLaunchUrlForTesting(
+                connection, null, 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());
@@ skipping 119 matching lines @@
         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);
-        assertTrue(connection.mayLaunchUrl(token, Uri.parse(initialUrl), null, null));
+        assertTrue(
+                mayLaunchUrlForTesting(connection, null, token, Uri.parse(initialUrl), null, null));
 
         if (wait) ensureCompletedPrerenderForUrl(connection, initialUrl);
 
         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,

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

Unrelated change but used only inside the wait scope.

+                    "visibility",
+                    ignoreFragments ? getExpectedVisibilityForOverride(mLatestDebugOverrideValue)
+                                    : "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 {
         Context context = getInstrumentation().getTargetContext().getApplicationContext();
         final CustomTabsConnection connection = warmUpAndWait();
         CustomTabsSessionToken token = CustomTabsSessionToken.createDummySessionTokenForTesting();
         connection.newSession(token);
-        assertTrue(connection.mayLaunchUrl(token, Uri.parse(mTestPage), null, null));
+        assertTrue(
+                mayLaunchUrlForTesting(connection, null, token, Uri.parse(mTestPage), null, null));
         ensureCompletedPrerenderForUrl(connection, mTestPage);
 
         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 {
         final CustomTabsConnection connection = warmUpAndWait();
         CustomTabsSessionToken token = CustomTabsSessionToken.createDummySessionTokenForTesting();
         connection.newSession(token);
-        assertFalse(connection.mayLaunchUrl(token, Uri.parse("chrome://version"), null, null));
+        assertFalse(mayLaunchUrlForTesting(
+                connection, null, 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 {
         Context context = getInstrumentation().getTargetContext().getApplicationContext();
@@ skipping 47 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 {
         Context context = getInstrumentation().getTargetContext().getApplicationContext();
         final CustomTabsConnection connection = warmUpAndWait();
         CustomTabsSessionToken token = CustomTabsSessionToken.createDummySessionTokenForTesting();
         connection.newSession(token);
-        assertTrue(connection.mayLaunchUrl(token, Uri.parse(mTestPage), null, null));
+        assertTrue(
+                mayLaunchUrlForTesting(connection, null, token, Uri.parse(mTestPage), null, null));
         try {
             startCustomTabActivityWithIntent(
                     CustomTabsTestUtils.createMinimalCustomTabIntent(context, mTestPage));
         } catch (InterruptedException e) {
             fail();
         }
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 assertFalse("Prerendering should have allocated a child connection",
@@ skipping 39 matching lines @@
     @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
     @RetryOnFailure
     public void testPrerenderingWithReferrer() throws Exception {
         String referrer = "android-app://com.foo.me/";
         maybePrerenderAndLaunchWithReferrers(
                 mTestServer.getURL(FRAGMENT_TEST_PAGE), true, 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",
+                        getExpectedVisibilityForOverride(mLatestDebugOverrideValue)),
+                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
@@ skipping 131 matching lines @@
         Intent intent = CustomTabsTestUtils.createMinimalCustomTabIntent(context, url);
         if (prerender) {
             connection = warmUpAndWait();
             token = CustomTabsSessionToken.getSessionTokenFromIntent(intent);
             connection.newSession(token);
             Bundle extras = null;
             if (prerenderReferrer != null) {
                 extras = new Bundle();
                 extras.putParcelable(Intent.EXTRA_REFERRER, Uri.parse(prerenderReferrer));
             }
-            assertTrue(connection.mayLaunchUrl(token, Uri.parse(url), extras, null));
+            assertTrue(
+                    mayLaunchUrlForTesting(connection, null, token, Uri.parse(url), extras, null));
             ensureCompletedPrerenderForUrl(connection, url);
         }
 
         if (launchReferrer != null) {
             intent.putExtra(Intent.EXTRA_REFERRER, Uri.parse(launchReferrer));
         }
         try {
             startCustomTabActivityWithIntent(intent);
         } catch (InterruptedException e) {
             fail();
         }
     }
 
     private void mayLaunchUrlWithoutWarmup(boolean noPrerendering) {
         Context context = getInstrumentation().getTargetContext().getApplicationContext();
         CustomTabsConnection connection =
                 CustomTabsTestUtils.setUpConnection((Application) context);
         CustomTabsSessionToken token = CustomTabsSessionToken.createDummySessionTokenForTesting();
         connection.newSession(token);
         Bundle extras = null;
         if (noPrerendering) {
             extras = new Bundle();
             extras.putInt(
                     CustomTabsConnection.DEBUG_OVERRIDE_KEY, CustomTabsConnection.NO_PRERENDERING);
         }
-        assertTrue(connection.mayLaunchUrl(token, Uri.parse(mTestPage), extras, null));
+        assertTrue(mayLaunchUrlForTesting(
+                connection, null, 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 90 matching lines @@
     }
 
     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") {
+        // We wait until we have a speculation to pull information from first.
+        CriteriaHelper.pollInstrumentationThread(new Criteria("No Speculation") {
             @Override
             public boolean isSatisfied() {
-                return connection.mSpeculation != null
-                        && connection.mSpeculation.webContents != null
-                        && ExternalPrerenderHandler.hasPrerenderedAndFinishedLoadingUrl(
-                                   Profile.getLastUsedProfile(), url,
-                                   connection.mSpeculation.webContents);
+                return connection.mSpeculation != null;
             }
         }, LONG_TIMEOUT_MS, CriteriaHelper.DEFAULT_POLLING_INTERVAL);
+
+        // Then do the specific depending on debug override.
+        if (connection.mSpeculation.debugOverrideValue == CustomTabsConnection.NO_OVERRIDE) {

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

We are sure this exist so we can use this value here.

+            CriteriaHelper.pollUiThread(new Criteria("No Prerender") {
+                @Override
+                public boolean isSatisfied() {
+                    return 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 boolean mayLaunchUrlForTesting(CustomTabsConnection connection,

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

A wrapper that allows us to do some additional instrumentation / routing when
there will be the hidden tab path (the test version needs instrumentation to
record completion, etc.)

+            CustomTabsSession session, CustomTabsSessionToken token, Uri url, Bundle extras,
+            List<Bundle> otherLikelyBundles) {
+        instrumentExtrasForTesting(extras);
+        if (connection != null) {
+            return connection.mayLaunchUrl(token, url, extras, otherLikelyBundles);
+        }
+        if (session != null) {
+            return session.mayLaunchUrl(url, extras, otherLikelyBundles);
+        }
+        return false;
+    }
+
+    /*
+     * Does the following modifications to the extras bundle :
+     * - Uses the default debug override if none is specified.
+     */
+    private void instrumentExtrasForTesting(Bundle extras) {
+        if (extras == null) extras = new Bundle();
+        int debugOverrideValue =
+                extras.getInt(CustomTabsConnection.DEBUG_OVERRIDE_KEY, mDefaultDebugOverrideValue);
+        extras.putInt(CustomTabsConnection.DEBUG_OVERRIDE_KEY, debugOverrideValue);
+        mLatestDebugOverrideValue = debugOverrideValue;
+    }
+
+    private static String getExpectedVisibilityForOverride(int mode) {
+        switch (mode) {
+            case CustomTabsConnection.NO_OVERRIDE:
+                return "prerender";
+            default:
+                return "visible";
+        }
+    }
 }