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

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Copyright (c) 2013-2014 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.internal.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.internal.XWalkViewInternal;
  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.internal.xwview.test.util.CommonResources;
  28
  29 /**
  30  * Test suite for setAppCacheEnabled().
  31  */
  32 public class SetAppCacheEnabledTest extends XWalkViewInternalTestBase {
  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 XWalkViewInternal 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({"XWalkViewInternal", "Preferences", "AppCache"})
 102     public void testAppCache() throws Throwable {
 103         final TestHelperBridge helperBridge =
 104                 new TestHelperBridge();
 105         mContentClient = helperBridge;
 106         final XWalkViewInternalTestBase.TestXWalkUIClientInternalBase uiClient =
 107                 new XWalkViewInternalTestBase.TestXWalkUIClientInternalBase(helperBridge);
 108         final XWalkViewInternalTestBase.TestXWalkResourceClientBase resourceClient =
 109                 new XWalkViewInternalTestBase.TestXWalkResourceClientBase(helperBridge);
 110         final XWalkViewInternal xWalkViewInternal =
 111                 createXWalkViewContainerOnMainSync(getActivity(), uiClient,
 112                         resourceClient);
 113
 114         final XWalkSettings settings = getXWalkSettings(xWalkViewInternal);
 115         settings.setJavaScriptEnabled(true);
 116         settings.setAppCacheEnabled(false);
 117
 118         TestWebServer webServer = TestWebServer.start();
 119         try {
 120             ManifestTestHelper helper = new ManifestTestHelper(
 121                     webServer, "testAppCache.html", "appcache.manifest");
 122             loadUrlSyncByContent(
 123                     xWalkViewInternal,
 124                     mContentClient,
 125                     helper.getHtmlUrl());
 126             helper.waitUntilHtmlIsRequested(0);
 127             // Unfortunately, there is no other good way of verifying that AppCache is
 128             // disabled, other than checking that it didn't try to fetch the manifest.
 129             Thread.sleep(1000);
 130             assertEquals(0, webServer.getRequestCount(helper.getManifestPath()));
 131             // Enables AppCache. Use the default path if app cache path isn't set.
 132             settings.setAppCacheEnabled(true);
 133             loadUrlSyncByContent(
 134                     xWalkViewInternal,
 135                     mContentClient,
 136                     helper.getHtmlUrl());
 137             helper.waitUntilManifestIsRequested(0);
 138         } finally {
 139             webServer.shutdown();
 140         }
 141     }
 142
 143     /*
 144      * @SmallTest
 145      * @Feature({"XWalkViewInternal", "Preferences", "AppCache"})
 146      * This test is flaky but the root cause is not found yet. See crbug.com/171765.
 147      */
 148     @DisabledTest
 149     public void testAppCacheWithTwoViews() throws Throwable {
 150         // We don't use the test helper here, because making sure that AppCache
 151         // is disabled takes a lot of time, so running through the usual drill
 152         // will take about 20 seconds.
 153         ViewPair views = createViews();
 154
 155         XWalkSettings settings0 = getXWalkSettingsOnUiThreadByContent(
 156                 views.getView0());
 157         settings0.setJavaScriptEnabled(true);
 158         settings0.setAppCachePath("whatever");
 159         settings0.setAppCacheEnabled(true);
 160         XWalkSettings settings1 = getXWalkSettingsOnUiThreadByContent(
 161                 views.getView1());
 162         settings1.setJavaScriptEnabled(true);
 163         // AppCachePath setting is global, no need to set it for the second view.
 164         settings1.setAppCacheEnabled(true);
 165
 166         TestWebServer webServer = TestWebServer.start();
 167         try {
 168             ManifestTestHelper helper0 = new ManifestTestHelper(
 169                     webServer, "testAppCache_0.html", "appcache.manifest_0");
 170             mContentClient = views.getClient0();
 171             loadUrlSyncByContent(
 172                     views.getView0(),
 173                     mContentClient,
 174                     helper0.getHtmlUrl());
 175             int manifestRequests0 = helper0.waitUntilManifestIsRequested(0);
 176             ManifestTestHelper helper1 = new ManifestTestHelper(
 177                     webServer, "testAppCache_1.html", "appcache.manifest_1");
 178             mContentClient = views.getClient1();
 179             loadUrlSyncByContent(
 180                     views.getView1(),
 181                     mContentClient,
 182                     helper1.getHtmlUrl());
 183             helper1.waitUntilManifestIsRequested(0);
 184             settings1.setAppCacheEnabled(false);
 185             mContentClient = views.getClient0();
 186             loadUrlSyncByContent(
 187                     views.getView0(),
 188                     mContentClient,
 189                     helper0.getHtmlUrl());
 190             helper0.waitUntilManifestIsRequested(manifestRequests0);
 191             final int prevManifestRequestCount =
 192                     webServer.getRequestCount(helper1.getManifestPath());
 193             int htmlRequests1 = webServer.getRequestCount(helper1.getHtmlPath());
 194             mContentClient = views.getClient1();
 195             loadUrlSyncByContent(
 196                     views.getView1(),
 197                     mContentClient,
 198                     helper1.getHtmlUrl());
 199             helper1.waitUntilHtmlIsRequested(htmlRequests1);
 200             // Unfortunately, there is no other good way of verifying that AppCache is
 201             // disabled, other than checking that it didn't try to fetch the manifest.
 202             Thread.sleep(1000);
 203             assertEquals(
 204                     prevManifestRequestCount, webServer.getRequestCount(helper1.getManifestPath()));
 205         } finally {
 206             webServer.shutdown();
 207         }
 208     }
 209 }