src/xwalk/test/android/core/javatests/src/org/xwalk/core/xwview/test/SetAppCacheEnabledTest.java

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Copyright (c) 2013 Intel Corporation. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5
   6 package org.xwalk.core.xwview.test;
   7
   8 import android.graphics.Bitmap;
   9 import android.test.suitebuilder.annotation.SmallTest;
  10 import android.util.Pair;
  11 import android.webkit.ValueCallback;
  12 import android.webkit.WebResourceResponse;
  13
  14 import java.util.concurrent.atomic.AtomicReference;
  15 import java.util.concurrent.Callable;
  16
  17 import org.chromium.base.test.util.DisabledTest;
  18 import org.chromium.base.test.util.Feature;
  19 import org.chromium.content.browser.test.util.CallbackHelper;
  20 import org.chromium.content.browser.test.util.Criteria;
  21 import org.chromium.content.browser.test.util.CriteriaHelper;
  22 import org.chromium.net.test.util.TestWebServer;
  23 import org.xwalk.core.XWalkView;
  24 import org.xwalk.core.internal.XWalkClient;
  25 import org.xwalk.core.internal.XWalkSettings;
  26 import org.xwalk.core.internal.XWalkWebChromeClient;
  27 import org.xwalk.core.xwview.test.util.CommonResources;
  28
  29 /**
  30  * Test suite for setAppCacheEnabled().
  31  */
  32 public class SetAppCacheEnabledTest extends XWalkViewTestBase {
  33     private static final long TEST_TIMEOUT = 20000L;
  34     private static final int CHECK_INTERVAL = 100;
  35     private TestHelperBridge mContentClient;
  36     private XWalkSettings mSettings;
  37
  38     static class ManifestTestHelper {
  39         private final TestWebServer mWebServer;
  40         private final String mHtmlPath;
  41         private final String mHtmlUrl;
  42         private final String mManifestPath;
  43
  44         ManifestTestHelper(TestWebServer webServer, String htmlPageName, String manifestName) {
  45             mWebServer = webServer;
  46             mHtmlPath = "/" + htmlPageName;
  47             mHtmlUrl = webServer.setResponse(
  48                     mHtmlPath, "<html manifest=\"" + manifestName + "\"></html>", null);
  49             mManifestPath = "/" + manifestName;
  50             webServer.setResponse(
  51                     mManifestPath,
  52                     "CACHE MANIFEST",
  53                     CommonResources.getContentTypeAndCacheHeaders("text/cache-manifest", false));
  54         }
  55
  56         String getHtmlPath() {
  57             return mHtmlPath;
  58         }
  59
  60         String getHtmlUrl() {
  61             return mHtmlUrl;
  62         }
  63
  64         String getManifestPath() {
  65             return mManifestPath;
  66         }
  67
  68         int waitUntilHtmlIsRequested(final int initialRequestCount) throws InterruptedException {
  69             return waitUntilResourceIsRequested(mHtmlPath, initialRequestCount);
  70         }
  71
  72         int waitUntilManifestIsRequested(final int initialRequestCount)
  73                 throws InterruptedException {
  74             return waitUntilResourceIsRequested(mManifestPath, initialRequestCount);
  75         }
  76
  77         private int waitUntilResourceIsRequested(
  78                 final String path, final int initialRequestCount) throws InterruptedException {
  79             boolean result = CriteriaHelper.pollForCriteria(new Criteria() {
  80                 @Override
  81                 public boolean isSatisfied() {
  82                     return mWebServer.getRequestCount(path) > initialRequestCount;
  83                 }
  84             }, TEST_TIMEOUT, CHECK_INTERVAL);
  85             assertTrue(result);
  86             return mWebServer.getRequestCount(path);
  87         }
  88     }
  89
  90     private XWalkSettings getXWalkSettings(final XWalkView view) {
  91         getInstrumentation().runOnMainSync(new Runnable() {
  92             @Override
  93             public void run() {
  94                 mSettings = view.getSettings();
  95             }
  96         });
  97         return mSettings;
  98     }
  99
 100     @SmallTest
 101     @Feature({"XWalkView", "Preferences", "AppCache"})
 102     public void testAppCache() throws Throwable {
 103         final TestHelperBridge helperBridge =
 104                 new TestHelperBridge();
 105         mContentClient = helperBridge;
 106         final XWalkViewTestBase.TestXWalkClientBase client =
 107                 new XWalkViewTestBase.TestXWalkClientBase(helperBridge);
 108         final XWalkViewTestBase.TestXWalkResourceClientBase resourceClient =
 109                 new XWalkViewTestBase.TestXWalkResourceClientBase(helperBridge);
 110         final XWalkViewTestBase.TestXWalkWebChromeClientBase chromeClient =
 111                 new XWalkViewTestBase.TestXWalkWebChromeClientBase(helperBridge);
 112         final XWalkView xWalkView =
 113                 createXWalkViewContainerOnMainSync(getActivity(), client,
 114                         resourceClient, chromeClient);
 115
 116         final XWalkSettings settings = getXWalkSettings(xWalkView);
 117         settings.setJavaScriptEnabled(true);
 118         settings.setAppCacheEnabled(false);
 119
 120         TestWebServer webServer = null;
 121         try {
 122             webServer = new TestWebServer(false);
 123             ManifestTestHelper helper = new ManifestTestHelper(
 124                     webServer, "testAppCache.html", "appcache.manifest");
 125             loadUrlSyncByContent(
 126                     xWalkView,
 127                     mContentClient,
 128                     helper.getHtmlUrl());
 129             helper.waitUntilHtmlIsRequested(0);
 130             // Unfortunately, there is no other good way of verifying that AppCache is
 131             // disabled, other than checking that it didn't try to fetch the manifest.
 132             Thread.sleep(1000);
 133             assertEquals(0, webServer.getRequestCount(helper.getManifestPath()));
 134             // Enables AppCache. Use the default path if app cache path isn't set.
 135             settings.setAppCacheEnabled(true);
 136             loadUrlSyncByContent(
 137                     xWalkView,
 138                     mContentClient,
 139                     helper.getHtmlUrl());
 140             helper.waitUntilManifestIsRequested(0);
 141         } finally {
 142             if (webServer != null) webServer.shutdown();
 143         }
 144     }
 145
 146     /*
 147      * @SmallTest
 148      * @Feature({"XWalkView", "Preferences", "AppCache"})
 149      * This test is flaky but the root cause is not found yet. See crbug.com/171765.
 150      */
 151     @DisabledTest
 152     public void testAppCacheWithTwoViews() throws Throwable {
 153         // We don't use the test helper here, because making sure that AppCache
 154         // is disabled takes a lot of time, so running through the usual drill
 155         // will take about 20 seconds.
 156         ViewPair views = createViews();
 157
 158         XWalkSettings settings0 = getXWalkSettingsOnUiThreadByContent(
 159                 views.getContent0());
 160         settings0.setJavaScriptEnabled(true);
 161         settings0.setAppCachePath("whatever");
 162         settings0.setAppCacheEnabled(true);
 163         XWalkSettings settings1 = getXWalkSettingsOnUiThreadByContent(
 164                 views.getContent1());
 165         settings1.setJavaScriptEnabled(true);
 166         // AppCachePath setting is global, no need to set it for the second view.
 167         settings1.setAppCacheEnabled(true);
 168
 169         TestWebServer webServer = null;
 170         try {
 171             webServer = new TestWebServer(false);
 172             ManifestTestHelper helper0 = new ManifestTestHelper(
 173                     webServer, "testAppCache_0.html", "appcache.manifest_0");
 174             mContentClient = views.getClient0();
 175             loadUrlSyncByContent(
 176                     views.getContent0(),
 177                     mContentClient,
 178                     helper0.getHtmlUrl());
 179             int manifestRequests0 = helper0.waitUntilManifestIsRequested(0);
 180             ManifestTestHelper helper1 = new ManifestTestHelper(
 181                     webServer, "testAppCache_1.html", "appcache.manifest_1");
 182             mContentClient = views.getClient1();
 183             loadUrlSyncByContent(
 184                     views.getContent1(),
 185                     mContentClient,
 186                     helper1.getHtmlUrl());
 187             helper1.waitUntilManifestIsRequested(0);
 188             settings1.setAppCacheEnabled(false);
 189             mContentClient = views.getClient0();
 190             loadUrlSyncByContent(
 191                     views.getContent0(),
 192                     mContentClient,
 193                     helper0.getHtmlUrl());
 194             helper0.waitUntilManifestIsRequested(manifestRequests0);
 195             final int prevManifestRequestCount =
 196                     webServer.getRequestCount(helper1.getManifestPath());
 197             int htmlRequests1 = webServer.getRequestCount(helper1.getHtmlPath());
 198             mContentClient = views.getClient1();
 199             loadUrlSyncByContent(
 200                     views.getContent1(),
 201                     mContentClient,
 202                     helper1.getHtmlUrl());
 203             helper1.waitUntilHtmlIsRequested(htmlRequests1);
 204             // Unfortunately, there is no other good way of verifying that AppCache is
 205             // disabled, other than checking that it didn't try to fetch the manifest.
 206             Thread.sleep(1000);
 207             assertEquals(
 208                     prevManifestRequestCount, webServer.getRequestCount(helper1.getManifestPath()));
 209         } finally {
 210             if (webServer != null) webServer.shutdown();
 211         }
 212     }
 213 }