Make shouldInterceptRequest thinner in glue

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.graphics.Bitmap;
 import android.graphics.Color;
 import android.os.Build;
 import android.test.suitebuilder.annotation.SmallTest;
 import android.util.Pair;
+import android.webkit.WebResourceResponse;
 
 import org.chromium.android_webview.AwContents;
-import org.chromium.android_webview.AwWebResourceResponse;
 import org.chromium.android_webview.test.util.AwTestTouchUtils;
 import org.chromium.android_webview.test.util.CommonResources;
 import org.chromium.android_webview.test.util.GraphicsTestUtils;
 import org.chromium.android_webview.test.util.JSUtils;
 import org.chromium.base.test.util.Feature;
 import org.chromium.base.test.util.MinAndroidSdkLevel;
 import org.chromium.base.test.util.TestFileUtil;
 import org.chromium.content.browser.test.util.CallbackHelper;
 import org.chromium.content.browser.test.util.TestCallbackHelperContainer.OnReceivedErrorHelper;
 import org.chromium.net.test.util.TestWebServer;
@@ skipping 13 matching lines @@
  * 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 {
 
         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>();
+            private ConcurrentHashMap<String, WebResourceResponse> mReturnValuesByUrls =
+                    new ConcurrentHashMap<String, WebResourceResponse>();
+            private ConcurrentHashMap<String, WebResourceRequestImpl> mRequestsByUrls =
+                    new ConcurrentHashMap<String, WebResourceRequestImpl>();
             // This is read from the IO thread, so needs to be marked volatile.
-            private volatile AwWebResourceResponse mShouldInterceptRequestReturnValue = null;
-            void setReturnValue(AwWebResourceResponse value) {
+            private volatile WebResourceResponse mShouldInterceptRequestReturnValue = null;
+            void setReturnValue(WebResourceResponse value) {
                 mShouldInterceptRequestReturnValue = value;
             }
-            void setReturnValueForUrl(String url, AwWebResourceResponse value) {
+            void setReturnValueForUrl(String url, WebResourceResponse value) {
                 mReturnValuesByUrls.put(url, value);
             }
             public List<String> getUrls() {
                 assert getCallCount() > 0;
                 return mShouldInterceptRequestUrls;
             }
-            public AwWebResourceResponse getReturnValue(String url) {
-                AwWebResourceResponse value = mReturnValuesByUrls.get(url);
+            public WebResourceResponse getReturnValue(String url) {
+                WebResourceResponse value = mReturnValuesByUrls.get(url);
                 if (value != null) return value;
                 return mShouldInterceptRequestReturnValue;
             }
-            public AwWebResourceRequest getRequestsForUrl(String url) {
+            public WebResourceRequestImpl getRequestsForUrl(String url) {
                 assert getCallCount() > 0;
                 assert mRequestsByUrls.containsKey(url);
                 return mRequestsByUrls.get(url);
             }
-            public void notifyCalled(AwWebResourceRequest request) {
-                mShouldInterceptRequestUrls.add(request.url);
-                mRequestsByUrls.put(request.url, request);
+            public void notifyCalled(WebResourceRequestImpl request) {
+                mShouldInterceptRequestUrls.add(request.getUrlString());
+                mRequestsByUrls.put(request.getUrlString(), request);
                 notifyCalled();
             }
         }
 
         public static class OnLoadResourceHelper extends CallbackHelper {
             private String mUrl;
 
             public String getUrl() {
                 assert getCallCount() > 0;
                 return mUrl;
             }
 
             public void notifyCalled(String url) {
                 mUrl = url;
                 notifyCalled();
             }
         }
 
         @Override
-        public AwWebResourceResponse shouldInterceptRequest(AwWebResourceRequest request) {
-            AwWebResourceResponse returnValue =
-                    mShouldInterceptRequestHelper.getReturnValue(request.url);
+        public WebResourceResponse shouldInterceptRequest(WebResourceRequestImpl request) {
+            WebResourceResponse returnValue =
+                    mShouldInterceptRequestHelper.getReturnValue(request.getUrlString());
             mShouldInterceptRequestHelper.notifyCalled(request);
             return returnValue;
         }
 
         @Override
         public void onLoadResource(String url) {
             super.onLoadResource(url);
             mOnLoadResourceHelper.notifyCalled(url);
         }
 
@@ skipping 22 matching lines @@
         headers.add(Pair.create("Content-Type", "text/html"));
         headers.add(Pair.create("Cache-Control", "no-store"));
         return webServer.setResponse(httpPath, html, headers);
     }
 
     private String addAboutPageToTestServer(TestWebServer webServer) {
         return addPageToTestServer(webServer, "/" + CommonResources.ABOUT_FILENAME,
                 CommonResources.ABOUT_HTML);
     }
 
-    private AwWebResourceResponse stringToAwWebResourceResponse(String input) throws Throwable {
+    private WebResourceResponse stringToAwWebResourceResponse(String input) throws Throwable {
         final String mimeType = "text/html";
         final String encoding = "UTF-8";
 
-        return new AwWebResourceResponse(
+        return new WebResourceResponse(
                 mimeType, encoding, new ByteArrayInputStream(input.getBytes(encoding)));
     }
 
     private TestWebServer mWebServer;
     private TestAwContentsClient mContentsClient;
     private AwTestContainerView mTestContainerView;
     private AwContents mAwContents;
     private TestAwContentsClient.ShouldInterceptRequestHelper mShouldInterceptRequestHelper;
 
     @Override
@@ skipping 38 matching lines @@
         final String subframeUrl = addAboutPageToTestServer(mWebServer);
         final String pageWithIframeUrl = addPageToTestServer(mWebServer, "/page_with_iframe.html",
                 CommonResources.makeHtmlPageFrom("",
                     "<iframe src=\"" + subframeUrl + "\"/>"));
 
         int callCount = mShouldInterceptRequestHelper.getCallCount();
         loadUrlAsync(mAwContents, pageWithIframeUrl);
         mShouldInterceptRequestHelper.waitForCallback(callCount, 2);
         assertEquals(2, mShouldInterceptRequestHelper.getUrls().size());
         assertEquals(false,
-                mShouldInterceptRequestHelper.getRequestsForUrl(subframeUrl).isMainFrame);
-        assertEquals(true,
-                mShouldInterceptRequestHelper.getRequestsForUrl(pageWithIframeUrl).isMainFrame);
+                mShouldInterceptRequestHelper.getRequestsForUrl(subframeUrl).isForMainFrame());
+        assertEquals(true, mShouldInterceptRequestHelper.getRequestsForUrl(pageWithIframeUrl)
+                                   .isForMainFrame());
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testCalledWithCorrectMethodParam() throws Throwable {
         final String pageToPostToUrl = addAboutPageToTestServer(mWebServer);
         final String pageWithFormUrl = addPageToTestServer(mWebServer, "/page_with_form.html",
                 CommonResources.makeHtmlPageWithSimplePostFormTo(pageToPostToUrl));
         enableJavaScriptOnUiThread(mAwContents);
 
         int callCount = mShouldInterceptRequestHelper.getCallCount();
         loadUrlAsync(mAwContents, pageWithFormUrl);
         mShouldInterceptRequestHelper.waitForCallback(callCount);
         assertEquals("GET",
-                mShouldInterceptRequestHelper.getRequestsForUrl(pageWithFormUrl).method);
+                mShouldInterceptRequestHelper.getRequestsForUrl(pageWithFormUrl).getMethod());
 
         callCount = mShouldInterceptRequestHelper.getCallCount();
         JSUtils.clickOnLinkUsingJs(this, mAwContents,
                 mContentsClient.getOnEvaluateJavaScriptResultHelper(), "link");
         mShouldInterceptRequestHelper.waitForCallback(callCount);
         assertEquals("POST",
-                mShouldInterceptRequestHelper.getRequestsForUrl(pageToPostToUrl).method);
+                mShouldInterceptRequestHelper.getRequestsForUrl(pageToPostToUrl).getMethod());
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testCalledWithCorrectHasUserGestureParam() throws Throwable {
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
         final String pageWithLinkUrl = addPageToTestServer(mWebServer, "/page_with_link.html",
                 CommonResources.makeHtmlPageWithSimpleLinkTo(aboutPageUrl));
         enableJavaScriptOnUiThread(mAwContents);
 
         int callCount = mShouldInterceptRequestHelper.getCallCount();
         loadUrlAsync(mAwContents, pageWithLinkUrl);
         mShouldInterceptRequestHelper.waitForCallback(callCount);
         assertEquals(false,
-                mShouldInterceptRequestHelper.getRequestsForUrl(pageWithLinkUrl).hasUserGesture);
+                mShouldInterceptRequestHelper.getRequestsForUrl(pageWithLinkUrl).hasGesture());
 
         // TODO(mkosiba): Remove this once we have a real API to wait for the page to load and
         // display.
         // http://crbug.com/364612
         //
         // The code here is waiting for the "link" (which is a full-screen blue div) to appear on
         // screen.
         pollOnUiThread(new Callable<Boolean>() {
             @Override
             public Boolean call() throws Exception {
                 Bitmap bitmap = GraphicsTestUtils.drawAwContents(mAwContents, 2, 2,
                         -(float) mTestContainerView.getWidth() / 2,
                         -(float) mTestContainerView.getHeight() / 2);
                 return bitmap.getPixel(0, 0) == Color.BLUE;
             }
         });
         callCount = mShouldInterceptRequestHelper.getCallCount();
         AwTestTouchUtils.simulateTouchCenterOfView(mTestContainerView);
         mShouldInterceptRequestHelper.waitForCallback(callCount);
-        assertEquals(true,
-                mShouldInterceptRequestHelper.getRequestsForUrl(aboutPageUrl).hasUserGesture);
+        assertEquals(
+                true, mShouldInterceptRequestHelper.getRequestsForUrl(aboutPageUrl).hasGesture());
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testCalledWithCorrectHeadersParam() throws Throwable {
         final String headerName = "X-Test-Header-Name";
         final String headerValue = "TestHeaderValue";
         final String syncGetUrl = addPageToTestServer(mWebServer, "/intercept_me",
                 CommonResources.ABOUT_HTML);
         final String mainPageUrl = addPageToTestServer(mWebServer, "/main",
                 CommonResources.makeHtmlPageFrom("",
                 "<script>"
                 + "  var xhr = new XMLHttpRequest();"
                 + "  xhr.open('GET', '" + syncGetUrl + "', false);"
                 + "  xhr.setRequestHeader('" + headerName + "', '" + headerValue + "'); "
                 + "  xhr.send(null);"
                 + "</script>"));
         enableJavaScriptOnUiThread(mAwContents);
 
         int callCount = mShouldInterceptRequestHelper.getCallCount();
         loadUrlAsync(mAwContents, mainPageUrl);
         mShouldInterceptRequestHelper.waitForCallback(callCount, 2);
 
         Map<String, String> headers =
-                mShouldInterceptRequestHelper.getRequestsForUrl(syncGetUrl).requestHeaders;
+                mShouldInterceptRequestHelper.getRequestsForUrl(syncGetUrl).getRequestHeaders();
         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 =
                 mContentsClient.getOnLoadResourceHelper();
 
         int callCount = onLoadResourceHelper.getCallCount();
 
         loadUrlAsync(mAwContents, aboutPageUrl);
 
         onLoadResourceHelper.waitForCallback(callCount);
         assertEquals(aboutPageUrl, onLoadResourceHelper.getUrl());
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testDoesNotCrashOnInvalidData() throws Throwable {
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
 
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", null));
+                new WebResourceResponse("text/html", "UTF-8", null));
         int callCount = mShouldInterceptRequestHelper.getCallCount();
         loadUrlAsync(mAwContents, aboutPageUrl);
         mShouldInterceptRequestHelper.waitForCallback(callCount);
 
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse(null, null, new ByteArrayInputStream(new byte[0])));
+                new WebResourceResponse(null, null, new ByteArrayInputStream(new byte[0])));
         callCount = mShouldInterceptRequestHelper.getCallCount();
         loadUrlAsync(mAwContents, aboutPageUrl);
         mShouldInterceptRequestHelper.waitForCallback(callCount);
 
-        mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse(null, null, null));
+        mShouldInterceptRequestHelper.setReturnValue(new WebResourceResponse(null, null, null));
         callCount = mShouldInterceptRequestHelper.getCallCount();
         loadUrlAsync(mAwContents, aboutPageUrl);
         mShouldInterceptRequestHelper.waitForCallback(callCount);
     }
 
     private static class EmptyInputStream extends InputStream {
         @Override
         public int available() {
             return 0;
         }
@@ skipping 20 matching lines @@
             return 0;
         }
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testDoesNotCrashOnEmptyStream() throws Throwable {
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
 
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", new EmptyInputStream()));
+                new WebResourceResponse("text/html", "UTF-8", new EmptyInputStream()));
         int shouldInterceptRequestCallCount = mShouldInterceptRequestHelper.getCallCount();
         int onPageFinishedCallCount = mContentsClient.getOnPageFinishedHelper().getCallCount();
 
         loadUrlAsync(mAwContents, aboutPageUrl);
 
         mShouldInterceptRequestHelper.waitForCallback(shouldInterceptRequestCallCount);
         mContentsClient.getOnPageFinishedHelper().waitForCallback(onPageFinishedCallCount);
     }
 
     private static class ThrowingInputStream extends EmptyInputStream {
@@ skipping 22 matching lines @@
             return n;
         }
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testDoesNotCrashOnThrowingStream() throws Throwable {
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
 
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", new ThrowingInputStream()));
+                new WebResourceResponse("text/html", "UTF-8", new ThrowingInputStream()));
         int shouldInterceptRequestCallCount = mShouldInterceptRequestHelper.getCallCount();
         int onPageFinishedCallCount = mContentsClient.getOnPageFinishedHelper().getCallCount();
 
         loadUrlAsync(mAwContents, aboutPageUrl);
 
         mShouldInterceptRequestHelper.waitForCallback(shouldInterceptRequestCallCount);
         mContentsClient.getOnPageFinishedHelper().waitForCallback(onPageFinishedCallCount);
     }
 
-    private static class SlowAwWebResourceResponse extends AwWebResourceResponse {
+    private static class SlowAwWebResourceResponse extends WebResourceResponse {
         private CallbackHelper mReadStartedCallbackHelper = new CallbackHelper();
         private CountDownLatch mLatch = new CountDownLatch(1);
 
         public SlowAwWebResourceResponse(String mimeType, String encoding, InputStream data) {
             super(mimeType, encoding, data);
         }
 
         @Override
         public InputStream getData() {
             mReadStartedCallbackHelper.notifyCalled();
@@ skipping 62 matching lines @@
                 + "  console.info('xhr.status = ' + xhr.status);"
                 + "  console.info('xhr.statusText = ' + xhr.statusText);"
                 + "  return '[' + xhr.status + '][' + xhr.statusText + ']';"
                 + "})();";
         enableJavaScriptOnUiThread(mAwContents);
 
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
         loadUrlSync(mAwContents, mContentsClient.getOnPageFinishedHelper(), aboutPageUrl);
 
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", null));
+                new WebResourceResponse("text/html", "UTF-8", null));
         assertEquals("\"[404][Not Found]\"",
                 executeJavaScriptAndWaitForResult(mAwContents, mContentsClient, syncGetJs));
 
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", new EmptyInputStream()));
+                new WebResourceResponse("text/html", "UTF-8", new EmptyInputStream()));
         assertEquals("\"[200][OK]\"",
                 executeJavaScriptAndWaitForResult(mAwContents, mContentsClient, syncGetJs));
 
-        mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", new EmptyInputStream(),
-                        TEAPOT_STATUS_CODE, TEAPOT_RESPONSE_PHRASE, new HashMap<String, String>()));
+        mShouldInterceptRequestHelper.setReturnValue(new WebResourceResponse("text/html", "UTF-8",
+                TEAPOT_STATUS_CODE, TEAPOT_RESPONSE_PHRASE, new HashMap<String, String>(),
+                new EmptyInputStream()));
         assertEquals("\"[" + TEAPOT_STATUS_CODE + "][" + TEAPOT_RESPONSE_PHRASE + "]\"",
                 executeJavaScriptAndWaitForResult(mAwContents, mContentsClient, syncGetJs));
     }
 
     private String getHeaderValue(AwContents awContents, TestAwContentsClient contentsClient,
             String url, String headerName) throws Exception {
         final String syncGetJs =
                 "(function() {"
                 + "  var xhr = new XMLHttpRequest();"
                 + "  xhr.open('GET', '" + url + "', false);"
@@ skipping 20 matching lines @@
         final String clientResponseHeaderValue = "shouldInterceptRequest";
         final String syncGetUrl = mWebServer.getResponseUrl("/intercept_me");
         enableJavaScriptOnUiThread(mAwContents);
 
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
         loadUrlSync(mAwContents, mContentsClient.getOnPageFinishedHelper(), aboutPageUrl);
 
         // The response header is set regardless of whether the embedder has provided a
         // valid resource stream.
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", null));
+                new WebResourceResponse("text/html", "UTF-8", null));
         assertEquals(clientResponseHeaderValue,
                 getHeaderValue(mAwContents, mContentsClient, syncGetUrl, clientResponseHeaderName));
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", new EmptyInputStream()));
+                new WebResourceResponse("text/html", "UTF-8", new EmptyInputStream()));
         assertEquals(clientResponseHeaderValue,
                 getHeaderValue(mAwContents, mContentsClient, syncGetUrl, clientResponseHeaderName));
 
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testHttpResponseHeader() throws Throwable {
         final String clientResponseHeaderName = "X-Test-Header-Name";
         final String clientResponseHeaderValue = "TestHeaderValue";
         final String syncGetUrl = mWebServer.getResponseUrl("/intercept_me");
         final Map<String, String> headers = new HashMap<String, String>();
         headers.put(clientResponseHeaderName, clientResponseHeaderValue);
         enableJavaScriptOnUiThread(mAwContents);
 
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
         loadUrlSync(mAwContents, mContentsClient.getOnPageFinishedHelper(), aboutPageUrl);
 
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", null, 0, null, headers));
+                new WebResourceResponse("text/html", "UTF-8", 0, null, headers, null));
         assertEquals(clientResponseHeaderValue,
                 getHeaderValue(mAwContents, mContentsClient, syncGetUrl, clientResponseHeaderName));
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testNullHttpResponseHeaders() throws Throwable {
         final String syncGetUrl = mWebServer.getResponseUrl("/intercept_me");
         enableJavaScriptOnUiThread(mAwContents);
 
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
         loadUrlSync(mAwContents, mContentsClient.getOnPageFinishedHelper(), aboutPageUrl);
 
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", null, 0, null, null));
+                new WebResourceResponse("text/html", "UTF-8", 0, null, null, null));
         assertEquals(null, getHeaderValue(mAwContents, mContentsClient, syncGetUrl, "Some-Header"));
     }
 
     private String makePageWithTitle(String title) {
         return CommonResources.makeHtmlPageFrom("<title>" + title + "</title>",
                 "<div> The title is: " + title + " </div>");
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
@@ skipping 26 matching lines @@
         assertEquals(aboutPageUrl, mContentsClient.getOnPageStartedHelper().getUrl());
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testNullInputStreamCausesErrorForMainFrame() throws Throwable {
         final OnReceivedErrorHelper onReceivedErrorHelper =
                 mContentsClient.getOnReceivedErrorHelper();
 
         mShouldInterceptRequestHelper.setReturnValue(
-                new AwWebResourceResponse("text/html", "UTF-8", null));
+                new WebResourceResponse("text/html", "UTF-8", null));
 
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
         final int callCount = onReceivedErrorHelper.getCallCount();
         loadUrlAsync(mAwContents, aboutPageUrl);
         onReceivedErrorHelper.waitForCallback(callCount);
         assertEquals(0, mWebServer.getRequestCount("/" + CommonResources.ABOUT_FILENAME));
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
@@ skipping 10 matching lines @@
         mShouldInterceptRequestHelper.waitForCallback(callCount, 2);
 
         assertEquals(2, mShouldInterceptRequestHelper.getUrls().size());
         assertTrue(mShouldInterceptRequestHelper.getUrls().get(1).endsWith(
                 CommonResources.FAVICON_FILENAME));
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testOnReceivedErrorCallback() throws Throwable {
-        mShouldInterceptRequestHelper.setReturnValue(new AwWebResourceResponse(null, null, null));
+        mShouldInterceptRequestHelper.setReturnValue(new WebResourceResponse(null, null, null));
         OnReceivedErrorHelper onReceivedErrorHelper = mContentsClient.getOnReceivedErrorHelper();
         int onReceivedErrorHelperCallCount = onReceivedErrorHelper.getCallCount();
         loadUrlSync(mAwContents, mContentsClient.getOnPageFinishedHelper(), "foo://bar");
         onReceivedErrorHelper.waitForCallback(onReceivedErrorHelperCallCount, 1);
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testNoOnReceivedErrorCallback() throws Throwable {
         final String imagePath = "/" + CommonResources.FAVICON_FILENAME;
         final String imageUrl = mWebServer.setResponseBase64(imagePath,
                 CommonResources.FAVICON_DATA_BASE64, CommonResources.getImagePngHeaders(true));
         final String pageWithImage =
                 addPageToTestServer(mWebServer, "/page_with_image.html",
                         CommonResources.getOnImageLoadedHtml(CommonResources.FAVICON_FILENAME));
         mShouldInterceptRequestHelper.setReturnValueForUrl(
-                imageUrl, new AwWebResourceResponse(null, null, null));
+                imageUrl, new WebResourceResponse(null, null, null));
         OnReceivedErrorHelper onReceivedErrorHelper = mContentsClient.getOnReceivedErrorHelper();
         int onReceivedErrorHelperCallCount = onReceivedErrorHelper.getCallCount();
         loadUrlSync(mAwContents, mContentsClient.getOnPageFinishedHelper(), pageWithImage);
         assertEquals(onReceivedErrorHelperCallCount, onReceivedErrorHelper.getCallCount());
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testCalledForIframe() throws Throwable {
         final String aboutPageUrl = addAboutPageToTestServer(mWebServer);
@@ skipping 99 matching lines @@
                 getInstrumentation().getTargetContext(), contentResourceName);
         assertEquals(1, contentRequestCount);
     }
 
     @SmallTest
     @Feature({"AndroidWebView"})
     public void testCalledForNonexistentContentUrl() throws Throwable {
         calledForUrlTemplate("content://org.chromium.webview.NoSuchProvider/foo");
     }
 }