[Android WebView] Call shouldInterceptRequest on a background thread

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

 // Copyright 2012 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.android_webview.test;
 
 import android.os.Build;
 import android.test.suitebuilder.annotation.SmallTest;
 import android.util.Pair;
 
@@ skipping 19 matching lines @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 
 /**
  * Tests for the WebViewClient.shouldInterceptRequest() method.
  */
 @MinAndroidSdkLevel(Build.VERSION_CODES.KITKAT)
 public class AwContentsClientShouldInterceptRequestTest extends AwTestBase {
 
-    private static class TestAwContentsClient
-            extends org.chromium.android_webview.test.TestAwContentsClient {
+    private static class ShouldInterceptRequestClient extends TestAwContentsClient {
 
         public static class ShouldInterceptRequestHelper extends CallbackHelper {
             private List<String> mShouldInterceptRequestUrls = new ArrayList<String>();
             private ConcurrentHashMap<String, AwWebResourceResponse> mReturnValuesByUrls =
                     new ConcurrentHashMap<String, AwWebResourceResponse>();
             private ConcurrentHashMap<String, AwWebResourceRequest> mRequestsByUrls =
                     new ConcurrentHashMap<String, AwWebResourceRequest>();
-            // This is read from the IO thread, so needs to be marked volatile.
+            // This is read on another thread, so needs to be marked volatile.
             private volatile AwWebResourceResponse mShouldInterceptRequestReturnValue = null;
             void setReturnValue(AwWebResourceResponse value) {
                 mShouldInterceptRequestReturnValue = value;
             }
             void setReturnValueForUrl(String url, AwWebResourceResponse value) {
                 mReturnValuesByUrls.put(url, value);
             }
             public List<String> getUrls() {
                 assert getCallCount() > 0;
                 return mShouldInterceptRequestUrls;
@@ skipping 39 matching lines @@
 
         @Override
         public void onLoadResource(String url) {
             super.onLoadResource(url);
             mOnLoadResourceHelper.notifyCalled(url);
         }
 
         private ShouldInterceptRequestHelper mShouldInterceptRequestHelper;
         private OnLoadResourceHelper mOnLoadResourceHelper;
 
-        public TestAwContentsClient() {
+        public ShouldInterceptRequestClient() {
             mShouldInterceptRequestHelper = new ShouldInterceptRequestHelper();
             mOnLoadResourceHelper = new OnLoadResourceHelper();
         }
 
         public ShouldInterceptRequestHelper getShouldInterceptRequestHelper() {
             return mShouldInterceptRequestHelper;
         }
 
         public OnLoadResourceHelper getOnLoadResourceHelper() {
             return mOnLoadResourceHelper;
@@ skipping 17 matching lines @@
 
     private AwWebResourceResponse stringToAwWebResourceResponse(String input) throws Throwable {
         final String mimeType = "text/html";
         final String encoding = "UTF-8";
 
         return new AwWebResourceResponse(
                 mimeType, encoding, new ByteArrayInputStream(input.getBytes(encoding)));
     }
 
     private TestWebServer mWebServer;
-    private TestAwContentsClient mContentsClient;
+    private ShouldInterceptRequestClient mContentsClient;
     private AwTestContainerView mTestContainerView;
     private AwContents mAwContents;
-    private TestAwContentsClient.ShouldInterceptRequestHelper mShouldInterceptRequestHelper;
+    private ShouldInterceptRequestClient.ShouldInterceptRequestHelper mShouldInterceptRequestHelper;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
 
-        mContentsClient = new TestAwContentsClient();
+        mContentsClient = new ShouldInterceptRequestClient();
         mTestContainerView = createAwTestContainerViewOnMainSync(mContentsClient);
         mAwContents = mTestContainerView.getAwContents();
         mShouldInterceptRequestHelper = mContentsClient.getShouldInterceptRequestHelper();
 
         mWebServer = TestWebServer.start();
     }
 
     @Override
     protected void tearDown() throws Exception {
         mWebServer.shutdown();
@@ skipping 133 matching lines @@
         Map<String, String> headers =
                 mShouldInterceptRequestHelper.getRequestsForUrl(syncGetUrl).requestHeaders;
         assertTrue(headers.containsKey(headerName));
         assertEquals(headerValue, headers.get(headerName));
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testOnLoadResourceCalledWithCorrectUrl() throws Throwable {
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
-        final TestAwContentsClient.OnLoadResourceHelper onLoadResourceHelper =
+        final ShouldInterceptRequestClient.OnLoadResourceHelper onLoadResourceHelper =
                 mContentsClient.getOnLoadResourceHelper();
 
         int callCount = onLoadResourceHelper.getCallCount();
 
         loadUrlAsync(mAwContents, aboutPageUrl);
 
         onLoadResourceHelper.waitForCallback(callCount);
         assertEquals(aboutPageUrl, onLoadResourceHelper.getUrl());
     }
 
@@ skipping 508 matching lines @@
         int callCount = mShouldInterceptRequestHelper.getCallCount();
         loadDataWithBaseUrlAsync(mAwContents, pageHtml, "text/html", false, baseUrl, null);
         mShouldInterceptRequestHelper.waitForCallback(callCount, 1);
         assertEquals(1, mShouldInterceptRequestHelper.getUrls().size());
         assertEquals(imageUrl, mShouldInterceptRequestHelper.getUrls().get(0));
         Map<String, String> headers =
                 mShouldInterceptRequestHelper.getRequestsForUrl(imageUrl).requestHeaders;
         assertTrue(headers.containsKey(refererHeaderName));
         assertEquals(baseUrl, headers.get(refererHeaderName));
     }
+
+    private static class DeadlockingAwContentsClient extends TestAwContentsClient {
+        public DeadlockingAwContentsClient(CountDownLatch ready, CountDownLatch wait) {
+            mReady = ready;
+            mWait = wait;
+        }
+
+        @Override
+        public AwWebResourceResponse shouldInterceptRequest(AwWebResourceRequest request) {
+            mReady.countDown();
+            try {
+                mWait.await();
+            } catch (InterruptedException e) {
+                // ignore
+            }
+            return null;
+        }
+
+        private CountDownLatch mReady;
+        private CountDownLatch mWait;
+    }
+
+    @SmallTest
+    @Feature({"AndroidWebView"})
+    public void testDeadlock() throws Throwable {
+        // The client will lock shouldInterceptRequest to wait for the UI thread.
+        // On the UI thread, we will try engaging the IO thread by executing
+        // an action that causes IPC message sending. If the client callback
+        // is executed on the IO thread, this will cause a deadlock.
+        CountDownLatch waitForShouldInterceptRequest = new CountDownLatch(1);
+        CountDownLatch signalAfterSendingIpc = new CountDownLatch(1);
+        DeadlockingAwContentsClient client = new DeadlockingAwContentsClient(
+                waitForShouldInterceptRequest, signalAfterSendingIpc);
+        mTestContainerView = createAwTestContainerViewOnMainSync(client);
+        mAwContents = mTestContainerView.getAwContents();
+        loadUrlAsync(mAwContents, "http://www.example.com");
+        waitForShouldInterceptRequest.await();
+        // The following call will try to send an IPC and wait for a reply from renderer.
+        // We do not check the actual result, because it can be bogus. The important
+        // thing is that the call does not cause a deadlock.
+        executeJavaScriptAndWaitForResult(mAwContents, client, "1+1");
+        signalAfterSendingIpc.countDown();
+    }
 }