src/android_webview/javatests/src/org/chromium/android_webview/test/ClientOnPageFinishedTest.java

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 package org.chromium.android_webview.test;
   6
   7 import android.test.suitebuilder.annotation.MediumTest;
   8
   9 import org.chromium.android_webview.AwContents;
  10 import org.chromium.android_webview.test.util.CommonResources;
  11 import org.chromium.android_webview.test.util.JSUtils;
  12 import org.chromium.base.test.util.Feature;
  13 import org.chromium.content.browser.test.util.TestCallbackHelperContainer;
  14 import org.chromium.net.test.util.TestWebServer;
  15
  16 /**
  17  * Tests for the ContentViewClient.onPageFinished() method.
  18  */
  19 public class ClientOnPageFinishedTest extends AwTestBase {
  20
  21     private TestAwContentsClient mContentsClient;
  22     private AwContents mAwContents;
  23
  24     @Override
  25     public void setUp() throws Exception {
  26         super.setUp();
  27         setTestAwContentsClient(new TestAwContentsClient());
  28     }
  29
  30     private void setTestAwContentsClient(TestAwContentsClient contentsClient) throws Exception {
  31         mContentsClient = contentsClient;
  32         final AwTestContainerView testContainerView =
  33                 createAwTestContainerViewOnMainSync(mContentsClient);
  34         mAwContents = testContainerView.getAwContents();
  35     }
  36
  37     @MediumTest
  38     @Feature({"AndroidWebView"})
  39     public void testOnPageFinishedPassesCorrectUrl() throws Throwable {
  40         TestCallbackHelperContainer.OnPageFinishedHelper onPageFinishedHelper =
  41                 mContentsClient.getOnPageFinishedHelper();
  42
  43         String html = "<html><body>Simple page.</body></html>";
  44         int currentCallCount = onPageFinishedHelper.getCallCount();
  45         loadDataAsync(mAwContents, html, "text/html", false);
  46
  47         onPageFinishedHelper.waitForCallback(currentCallCount);
  48         assertEquals("data:text/html," + html, onPageFinishedHelper.getUrl());
  49     }
  50
  51     @MediumTest
  52     @Feature({"AndroidWebView"})
  53     public void testOnPageFinishedCalledAfterError() throws Throwable {
  54         class LocalTestClient extends TestAwContentsClient {
  55             private boolean mIsOnReceivedErrorCalled = false;
  56             private boolean mIsOnPageFinishedCalled = false;
  57             private boolean mAllowAboutBlank = false;
  58
  59             @Override
  60             public void onReceivedError(int errorCode, String description, String failingUrl) {
  61                 assertEquals("onReceivedError called twice for " + failingUrl,
  62                         false, mIsOnReceivedErrorCalled);
  63                 mIsOnReceivedErrorCalled = true;
  64                 assertEquals("onPageFinished called before onReceivedError for " + failingUrl,
  65                         false, mIsOnPageFinishedCalled);
  66                 super.onReceivedError(errorCode, description, failingUrl);
  67             }
  68
  69             @Override
  70             public void onPageFinished(String url) {
  71                 if (mAllowAboutBlank && "about:blank".equals(url)) {
  72                     super.onPageFinished(url);
  73                     return;
  74                 }
  75                 assertEquals("onPageFinished called twice for " + url,
  76                         false, mIsOnPageFinishedCalled);
  77                 mIsOnPageFinishedCalled = true;
  78                 assertEquals("onReceivedError not called before onPageFinished for " + url,
  79                         true, mIsOnReceivedErrorCalled);
  80                 super.onPageFinished(url);
  81             }
  82
  83             void setAllowAboutBlank() {
  84                 mAllowAboutBlank = true;
  85             }
  86         };
  87         LocalTestClient testContentsClient = new LocalTestClient();
  88         setTestAwContentsClient(testContentsClient);
  89
  90         TestCallbackHelperContainer.OnReceivedErrorHelper onReceivedErrorHelper =
  91                 mContentsClient.getOnReceivedErrorHelper();
  92         TestCallbackHelperContainer.OnPageFinishedHelper onPageFinishedHelper =
  93                 mContentsClient.getOnPageFinishedHelper();
  94
  95         String invalidUrl = "http://localhost:7/non_existent";
  96         loadUrlSync(mAwContents, onPageFinishedHelper, invalidUrl);
  97
  98         assertEquals(invalidUrl, onReceivedErrorHelper.getFailingUrl());
  99         assertEquals(invalidUrl, onPageFinishedHelper.getUrl());
 100
 101         // Rather than wait a fixed time to see that another onPageFinished callback isn't issued
 102         // we load a valid page. Since callbacks arrive sequentially, this will ensure that
 103         // any extra calls of onPageFinished / onReceivedError will arrive to our client.
 104         testContentsClient.setAllowAboutBlank();
 105         loadUrlSync(mAwContents, onPageFinishedHelper, "about:blank");
 106     }
 107
 108     @MediumTest
 109     @Feature({"AndroidWebView"})
 110     public void testOnPageFinishedCalledAfterRedirectedUrlIsOverridden() throws Throwable {
 111         /*
 112          * If url1 is redirected url2, and url2 load is overridden, onPageFinished should still be
 113          * called for url2.
 114          * Steps:
 115          * 1. load url1. url1 onPageStarted
 116          * 2. server redirects url1 to url2. url2 onPageStarted
 117          * 3. shouldOverridedUrlLoading called for url2 and returns true
 118          * 4. url2 onPageFinishedCalled
 119          */
 120
 121         TestWebServer webServer = null;
 122         try {
 123             webServer = new TestWebServer(false);
 124             final String redirectTargetPath = "/redirect_target.html";
 125             final String redirectTargetUrl = webServer.setResponse(redirectTargetPath,
 126                     "<html><body>hello world</body></html>", null);
 127             final String redirectUrl = webServer.setRedirect("/302.html", redirectTargetUrl);
 128
 129             final TestAwContentsClient.ShouldOverrideUrlLoadingHelper urlOverrideHelper =
 130                     mContentsClient.getShouldOverrideUrlLoadingHelper();
 131             // Override the load of redirectTargetUrl
 132             urlOverrideHelper.setShouldOverrideUrlLoadingReturnValue(true);
 133
 134             TestCallbackHelperContainer.OnPageFinishedHelper onPageFinishedHelper =
 135                 mContentsClient.getOnPageFinishedHelper();
 136
 137             final int currentOnPageFinishedCallCount = onPageFinishedHelper.getCallCount();
 138             loadUrlAsync(mAwContents, redirectUrl);
 139
 140             onPageFinishedHelper.waitForCallback(currentOnPageFinishedCallCount);
 141             // onPageFinished needs to be called for redirectTargetUrl, but not for redirectUrl
 142             assertEquals(redirectTargetUrl, onPageFinishedHelper.getUrl());
 143         } finally {
 144             if (webServer != null) webServer.shutdown();
 145         }
 146     }
 147
 148     @MediumTest
 149     @Feature({"AndroidWebView"})
 150     public void testOnPageFinishedNotCalledForValidSubresources() throws Throwable {
 151         TestCallbackHelperContainer.OnPageFinishedHelper onPageFinishedHelper =
 152                 mContentsClient.getOnPageFinishedHelper();
 153
 154         TestWebServer webServer = null;
 155         try {
 156             webServer = new TestWebServer(false);
 157
 158             final String testHtml = "<html><head>Header</head><body>Body</body></html>";
 159             final String testPath = "/test.html";
 160             final String syncPath = "/sync.html";
 161
 162             final String testUrl = webServer.setResponse(testPath, testHtml, null);
 163             final String syncUrl = webServer.setResponse(syncPath, testHtml, null);
 164
 165             assertEquals(0, onPageFinishedHelper.getCallCount());
 166             final int pageWithSubresourcesCallCount = onPageFinishedHelper.getCallCount();
 167             loadDataAsync(mAwContents,
 168                           "<html><iframe src=\"" + testUrl + "\" /></html>",
 169                           "text/html",
 170                           false);
 171
 172             onPageFinishedHelper.waitForCallback(pageWithSubresourcesCallCount);
 173
 174             // Rather than wait a fixed time to see that an onPageFinished callback isn't issued
 175             // we load another valid page. Since callbacks arrive sequentially if the next callback
 176             // we get is for the synchronizationUrl we know that the previous load did not schedule
 177             // a callback for the iframe.
 178             final int synchronizationPageCallCount = onPageFinishedHelper.getCallCount();
 179             loadUrlAsync(mAwContents, syncUrl);
 180
 181             onPageFinishedHelper.waitForCallback(synchronizationPageCallCount);
 182             assertEquals(syncUrl, onPageFinishedHelper.getUrl());
 183             assertEquals(2, onPageFinishedHelper.getCallCount());
 184
 185         } finally {
 186             if (webServer != null) webServer.shutdown();
 187         }
 188     }
 189
 190     @MediumTest
 191     @Feature({"AndroidWebView"})
 192     public void testOnPageFinishedNotCalledForHistoryApi() throws Throwable {
 193         TestCallbackHelperContainer.OnPageFinishedHelper onPageFinishedHelper =
 194                 mContentsClient.getOnPageFinishedHelper();
 195         enableJavaScriptOnUiThread(mAwContents);
 196
 197         TestWebServer webServer = null;
 198         try {
 199             webServer = new TestWebServer(false);
 200
 201             final String testHtml = "<html><head>Header</head><body>Body</body></html>";
 202             final String testPath = "/test.html";
 203             final String historyPath = "/history.html";
 204             final String syncPath = "/sync.html";
 205
 206             final String testUrl = webServer.setResponse(testPath, testHtml, null);
 207             final String historyUrl = webServer.getResponseUrl(historyPath);
 208             final String syncUrl = webServer.setResponse(syncPath, testHtml, null);
 209
 210             assertEquals(0, onPageFinishedHelper.getCallCount());
 211             loadUrlSync(mAwContents, onPageFinishedHelper, testUrl);
 212
 213             executeJavaScriptAndWaitForResult(mAwContents, mContentsClient,
 214                     "history.pushState(null, null, '" + historyUrl + "');");
 215
 216             // Rather than wait a fixed time to see that an onPageFinished callback isn't issued
 217             // we load another valid page. Since callbacks arrive sequentially if the next callback
 218             // we get is for the synchronizationUrl we know that the previous load did not schedule
 219             // a callback for the iframe.
 220             final int synchronizationPageCallCount = onPageFinishedHelper.getCallCount();
 221             loadUrlAsync(mAwContents, syncUrl);
 222
 223             onPageFinishedHelper.waitForCallback(synchronizationPageCallCount);
 224             assertEquals(syncUrl, onPageFinishedHelper.getUrl());
 225             assertEquals(2, onPageFinishedHelper.getCallCount());
 226
 227         } finally {
 228             if (webServer != null) webServer.shutdown();
 229         }
 230     }
 231
 232     @MediumTest
 233     @Feature({"AndroidWebView"})
 234     public void testOnPageFinishedCalledForHrefNavigations() throws Throwable {
 235         doTestOnPageFinishedCalledForHrefNavigations(false);
 236     }
 237
 238     @MediumTest
 239     @Feature({"AndroidWebView"})
 240     public void testOnPageFinishedCalledForHrefNavigationsWithBaseUrl() throws Throwable {
 241         doTestOnPageFinishedCalledForHrefNavigations(true);
 242     }
 243
 244     private void doTestOnPageFinishedCalledForHrefNavigations(boolean useBaseUrl) throws Throwable {
 245         TestCallbackHelperContainer.OnPageFinishedHelper onPageFinishedHelper =
 246                 mContentsClient.getOnPageFinishedHelper();
 247         TestCallbackHelperContainer.OnPageStartedHelper onPageStartedHelper =
 248                 mContentsClient.getOnPageStartedHelper();
 249         enableJavaScriptOnUiThread(mAwContents);
 250
 251         TestWebServer webServer = null;
 252         try {
 253             webServer = new TestWebServer(false);
 254
 255             final String testHtml = CommonResources.makeHtmlPageFrom("",
 256                     "<a href=\"#anchor\" id=\"link\">anchor</a>");
 257             final String testPath = "/test.html";
 258             final String testUrl = webServer.setResponse(testPath, testHtml, null);
 259
 260             if (useBaseUrl) {
 261                 loadDataWithBaseUrlSync(mAwContents, onPageFinishedHelper,
 262                         testHtml, "text/html", false, webServer.getBaseUrl(), null);
 263             } else {
 264                 loadUrlSync(mAwContents, onPageFinishedHelper, testUrl);
 265             }
 266
 267             int onPageFinishedCallCount = onPageFinishedHelper.getCallCount();
 268             int onPageStartedCallCount = onPageStartedHelper.getCallCount();
 269
 270             JSUtils.clickOnLinkUsingJs(this, mAwContents,
 271                     mContentsClient.getOnEvaluateJavaScriptResultHelper(), "link");
 272
 273             onPageFinishedHelper.waitForCallback(onPageFinishedCallCount);
 274             assertEquals(onPageStartedCallCount, onPageStartedHelper.getCallCount());
 275
 276             onPageFinishedCallCount = onPageFinishedHelper.getCallCount();
 277             onPageStartedCallCount = onPageStartedHelper.getCallCount();
 278
 279             executeJavaScriptAndWaitForResult(mAwContents, mContentsClient,
 280                     "window.history.go(-1)");
 281
 282             onPageFinishedHelper.waitForCallback(onPageFinishedCallCount);
 283             assertEquals(onPageStartedCallCount, onPageStartedHelper.getCallCount());
 284         } finally {
 285             if (webServer != null) webServer.shutdown();
 286         }
 287     }
 288 }