(reland) Use stricter checking in UrlOverridingTest

chrome/android/javatests/src/org/chromium/chrome/browser/externalnav/UrlOverridingTest.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.externalnav;
 
 import android.app.Activity;
 import android.app.Instrumentation;
 import android.app.Instrumentation.ActivityMonitor;
 import android.content.Context;
@@ skipping 53 matching lines @@
     private static final String NAVIGATION_WITH_FALLBACK_URL_PARENT_FRAME_PAGE =
             BASE_PATH + "navigation_with_fallback_url_parent_frame.html";
     private static final String FALLBACK_LANDING_PATH = BASE_PATH + "hello.html";
     private static final String OPEN_WINDOW_FROM_USER_GESTURE_PAGE =
             BASE_PATH + "open_window_from_user_gesture.html";
     private static final String NAVIGATION_FROM_JAVA_REDIRECTION_PAGE =
             BASE_PATH + "navigation_from_java_redirection.html";
 
     private static class TestTabObserver extends EmptyTabObserver {
         private final CallbackHelper mFinishCallback;
-        private final CallbackHelper mPageFailCallback;
-        private final CallbackHelper mLoadFailCallback;
+        private final CallbackHelper mFailCallback;
 
-        TestTabObserver(final CallbackHelper finishCallback, final CallbackHelper pageFailCallback,
-                final CallbackHelper loadFailCallback) {
+        TestTabObserver(final CallbackHelper finishCallback, final CallbackHelper failCallback) {
             mFinishCallback = finishCallback;
-            mPageFailCallback = pageFailCallback;
-            mLoadFailCallback = loadFailCallback;
+            mFailCallback = failCallback;
         }
 
         @Override
         public void onDidFinishNavigation(Tab tab, String url, boolean isInMainFrame,
                 boolean isErrorPage, boolean hasCommitted, boolean isSameDocument,
                 boolean isFragmentNavigation, Integer pageTransition, int errorCode,
                 int httpStatusCode) {
-            if (errorCode != 0) {
-                mLoadFailCallback.notifyCalled();
-            }
+            if (errorCode == 0) return;
+            mFailCallback.notifyCalled();
         }
 
         @Override
         public void onPageLoadFinished(Tab tab) {
             mFinishCallback.notifyCalled();
         }
 
         @Override
-        public void onPageLoadFailed(Tab tab, int errorCode) {
-            mPageFailCallback.notifyCalled();
-        }
-
-        @Override
-        public void onDidFailLoad(Tab tab, boolean isMainFrame, int errorCode, String description,
-                String failingUrl) {
-            mLoadFailCallback.notifyCalled();
-        }
-
-        @Override
         public void onDestroyed(Tab tab) {
             // A new tab is destroyed when loading is overridden while opening it.
-            mPageFailCallback.notifyCalled();
+            mFailCallback.notifyCalled();
         }
     }
 
     private ActivityMonitor mActivityMonitor;
     private EmbeddedTestServer mTestServer;
 
     public UrlOverridingTest() {
         super(ChromeActivity.class);
     }
 
@@ skipping 16 matching lines @@
 
     private void loadUrlAndWaitForIntentUrl(final String url, boolean needClick,
             boolean shouldLaunchExternalIntent, boolean isMainFrame) throws InterruptedException {
         loadUrlAndWaitForIntentUrl(url, needClick, 0, shouldLaunchExternalIntent, url, isMainFrame);
     }
 
     private void loadUrlAndWaitForIntentUrl(final String url, boolean needClick,
             int expectedNewTabCount, final boolean shouldLaunchExternalIntent,
             final String expectedFinalUrl, boolean isMainFrame) throws InterruptedException {
         final CallbackHelper finishCallback = new CallbackHelper();
-        final CallbackHelper pageFailCallback = new CallbackHelper();
-        final CallbackHelper loadFailCallback = new CallbackHelper();
+        final CallbackHelper failCallback = new CallbackHelper();
         final CallbackHelper newTabCallback = new CallbackHelper();
 
         final Tab tab = getActivity().getActivityTab();
         final Tab[] latestTabHolder = new Tab[1];
         latestTabHolder[0] = tab;
-        tab.addObserver(new TestTabObserver(finishCallback, pageFailCallback, loadFailCallback));
+        tab.addObserver(new TestTabObserver(finishCallback, failCallback));
         if (expectedNewTabCount > 0) {
             getActivity().getTabModelSelector().addObserver(new EmptyTabModelSelectorObserver() {
                 @Override
                 public void onNewTabCreated(Tab newTab) {
                     newTabCallback.notifyCalled();
-                    newTab.addObserver(new TestTabObserver(
-                            finishCallback, pageFailCallback, loadFailCallback));
+                    newTab.addObserver(new TestTabObserver(finishCallback, failCallback));
                     latestTabHolder[0] = newTab;
                 }
             });
         }
 
         getActivity().onUserInteraction();
         getInstrumentation().runOnMainSync(new Runnable() {
             @Override
             public void run() {
                 tab.loadUrl(new LoadUrlParams(url, PageTransition.LINK));
             }
         });
 
         if (finishCallback.getCallCount() == 0) {
             try {
                 finishCallback.waitForCallback(0, 1, 20, TimeUnit.SECONDS);
             } catch (TimeoutException ex) {
                 fail();
                 return;
             }
         }
 
         SystemClock.sleep(1);
         getActivity().onUserInteraction();
         if (needClick) {
             singleClickView(tab.getView());
         }
 
-        CallbackHelper helper = isMainFrame ? pageFailCallback : loadFailCallback;
-        if (helper.getCallCount() == 0) {
+        if (failCallback.getCallCount() == 0) {
             try {
-                helper.waitForCallback(0, 1, 20, TimeUnit.SECONDS);
+                failCallback.waitForCallback(0, 1, 20, TimeUnit.SECONDS);
             } catch (TimeoutException ex) {
-                fail();
+                fail("Haven't received navigation failure of intents.");
                 return;
             }
         }
 
+        boolean hasFallbackUrl =
+                expectedFinalUrl != null && !TextUtils.equals(url, expectedFinalUrl);
+
+        if (hasFallbackUrl) {
+            if (finishCallback.getCallCount() == 1) {
+                try {
+                    finishCallback.waitForCallback(1, 1, 20, TimeUnit.SECONDS);
+                } catch (TimeoutException ex) {
+                    fail("Fallback URL is not loaded");
+                    return;
+                }
+            }
+        }
+
         assertEquals(expectedNewTabCount, newTabCallback.getCallCount());
         // For sub frames, the |loadFailCallback| run through different threads
         // from the ExternalNavigationHandler. As a result, there is no guarantee
         // when url override result would come.
         CriteriaHelper.pollUiThread(
                 new Criteria() {
                     @Override
                     public boolean isSatisfied() {
                         // Note that we do not distinguish between OVERRIDE_WITH_CLOBBERING_TAB
                         // and NO_OVERRIDE since tab clobbering will eventually lead to NO_OVERRIDE.
                         // in the tab. Rather, we check the final URL to distinguish between
                         // fallback and normal navigation. See crbug.com/487364 for more.
                         Tab tab = latestTabHolder[0];
                         if (shouldLaunchExternalIntent
                                 != (OverrideUrlLoadingResult.OVERRIDE_WITH_EXTERNAL_INTENT
                                         == tab.getInterceptNavigationDelegate()
                                                 .getLastOverrideUrlLoadingResultForTests())) {
                             return false;
                         }
                         updateFailureReason("Expected: " + expectedFinalUrl + " actual: "
                                 + tab.getUrl());
                         return expectedFinalUrl == null
                                 || TextUtils.equals(expectedFinalUrl, tab.getUrl());
                     }
                 });
+
+        CriteriaHelper.pollUiThread(
+                Criteria.equals(shouldLaunchExternalIntent ? 1 : 0, new Callable<Integer>() {
+                    @Override
+                    public Integer call() {
+                        return mActivityMonitor.getHits();
+                    }
+                }));
+        assertEquals(1 + (hasFallbackUrl ? 1 : 0), finishCallback.getCallCount());
+        assertEquals(1, failCallback.getCallCount());
     }
 
     @SmallTest
     @RetryOnFailure
     public void testNavigationFromTimer() throws InterruptedException {
         loadUrlAndWaitForIntentUrl(
                 mTestServer.getURL(NAVIGATION_FROM_TIMEOUT_PAGE), false, false, true);
     }
 
     @SmallTest
@@ skipping 111 matching lines @@
                 return mActivityMonitor.getHits();
             }
         }));
     }
 
     @Override
     public void startMainActivity() throws InterruptedException {
         startMainActivityOnBlankPage();
     }
 }