Initial implementation of Cronet Async API.

components/cronet/android/test/javatests/src/org/chromium/cronet_test_apk/CronetUrlRequestTest.java

Index: components/cronet/android/test/javatests/src/org/chromium/cronet_test_apk/CronetUrlRequestTest.java
diff --git a/components/cronet/android/test/javatests/src/org/chromium/cronet_test_apk/CronetUrlRequestTest.java b/components/cronet/android/test/javatests/src/org/chromium/cronet_test_apk/CronetUrlRequestTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2308a7b3082ee181e5111b71e21b457198e5aff4
--- /dev/null
+++ b/components/cronet/android/test/javatests/src/org/chromium/cronet_test_apk/CronetUrlRequestTest.java
@@ -0,0 +1,647 @@
+// Copyright 2014 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.cronet_test_apk;
+
+import android.os.ConditionVariable;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.chromium.base.test.util.Feature;
+import org.chromium.net.ExtendedResponseInfo;
+import org.chromium.net.ResponseInfo;
+import org.chromium.net.UrlRequest;
+import org.chromium.net.UrlRequestException;
+import org.chromium.net.UrlRequestListener;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+
+/**
+ * Test functionality of CronetUrlRequest.
+ */
+public class CronetUrlRequestTest extends CronetTestBase {
+    // URL used for base tests.
+    private static final String TEST_URL = "http://127.0.0.1:8000";
+    private static final String MOCK_SUCCESS_PATH = "success.txt";
+
+    private static final String MOCK_CRONET_TEST_SUCCESS_URL =
+            "http://mock.http/success.txt";
+    private static final String MOCK_CRONET_TEST_REDIRECT_URL =
+            "http://mock.http/redirect.html";
+    private static final String MOCK_CRONET_TEST_MULTI_REDIRECT_URL =
+            "http://mock.http/multiredirect.html";
+    private static final String MOCK_CRONET_TEST_NOTFOUND_URL =
+            "http://mock.http/notfound.html";
+    private static final String MOCK_CRONET_TEST_FAILED_URL =
+            "http://mock.failed.request/-2";
+
+    // Executor for Cronet callbacks.
+    ExecutorService mExecutor = Executors.newSingleThreadExecutor(
+            new ExecutorThreadFactory());
+
+    Thread mExecutorThread;
+    CronetTestActivity mActivity;
+
+    private enum LastCalled {
+        Nothing,
+        OnRedirect,
+        OnResponseStarted,
+        OnDataReceived,
+        OnComplete
+    };
+
+    private enum FailureType {
+        None,
+        CancelSync,
+        CancelAsync,
+        ThrowSync
+    };
+
+    class ExecutorThreadFactory implements ThreadFactory {
+        public Thread newThread(Runnable r) {
+            mExecutorThread = new Thread(r);
+            return mExecutorThread;
+        }
+    }
+
+    /** Listener that tracks information from different callbacks
+     * and opens conditional variable |mDone| when request is done.
+     */
+    class SimpleUrlRequestListener implements UrlRequestListener {
+        public ArrayList<ResponseInfo> mRedirectResponseInfoList =
+                new ArrayList<ResponseInfo>();
+        public ResponseInfo mResponseInfo;
+        public ExtendedResponseInfo mExtendedResponseInfo;
+        public UrlRequestException mError;
+
+        public LastCalled mLastCalled = LastCalled.Nothing;
+
+        public boolean mOnRedirectCalled = false;
+        public boolean mOnErrorCalled = false;
+
+        public int mHttpResponseDataLength = 0;
+        public byte[] mLastDataReceivedAsBytes;
+        public String mResponseAsString = "";
+
+        // Signals when request is done either successfully or not.
+        private ConditionVariable mDone = new ConditionVariable();
+
+        public SimpleUrlRequestListener() {
+        }
+
+        @Override
+        public void onRedirect(UrlRequest request,
+                               ResponseInfo info,
+                               String newLocationUrl) {
+            assertEquals(mExecutorThread, Thread.currentThread());
+            assertTrue(mLastCalled == LastCalled.Nothing
+                       || mLastCalled == LastCalled.OnRedirect);
+            mRedirectResponseInfoList.add(info);
+            mLastCalled = LastCalled.OnRedirect;
+            mOnRedirectCalled = true;
+        }
+
+        @Override
+        public void onResponseStarted(UrlRequest request, ResponseInfo info) {
+            assertEquals(mExecutorThread, Thread.currentThread());
+            assertTrue(mLastCalled == LastCalled.Nothing
+                       || mLastCalled == LastCalled.OnRedirect);
+            mLastCalled = LastCalled.OnResponseStarted;
+            mResponseInfo = info;
+        }
+
+        @Override
+        public void onDataReceived(UrlRequest request,
+                                   ResponseInfo info,
+                                   ByteBuffer byteBuffer) {
+            assertEquals(mExecutorThread, Thread.currentThread());
+            assertTrue(mLastCalled == LastCalled.OnResponseStarted
+                       || mLastCalled == LastCalled.OnDataReceived);
+            mLastCalled = LastCalled.OnDataReceived;
+
+            mHttpResponseDataLength += byteBuffer.capacity();
+            mLastDataReceivedAsBytes = new byte[byteBuffer.capacity()];
+            byteBuffer.get(mLastDataReceivedAsBytes);
+            mResponseAsString += new String(mLastDataReceivedAsBytes);
+        }
+
+        @Override
+        public void onComplete(UrlRequest request, ExtendedResponseInfo info) {
+            assertEquals(mExecutorThread, Thread.currentThread());
+            assertTrue(mLastCalled == LastCalled.OnResponseStarted
+                       || mLastCalled == LastCalled.OnDataReceived);
+            mLastCalled = LastCalled.OnComplete;
+            mExtendedResponseInfo = info;
+            openDone();
+        }
+
+        @Override
+        public void onError(UrlRequest request,
+                            ResponseInfo info,
+                            UrlRequestException error) {
+            assertEquals(mExecutorThread, Thread.currentThread());
+            mOnErrorCalled = true;
+            mError = error;
+            openDone();
+        }
+
+        public void blockForDone() {
+            mDone.block();
+        }
+
+        protected void openDone() {
+            mDone.open();
+        }
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mActivity = launchCronetTestApp();
+        // Make sure the activity was created as expected.
+        waitForActiveShellToBeDoneLoading();
+        assertTrue(UploadTestServer.startUploadTestServer());
+        // AddUrlInterceptors() after native application context is initialized.
+        MockUrlRequestJobUtil.addUrlInterceptors();
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        mExecutor.shutdown();
+        mExecutor.awaitTermination(5, TimeUnit.SECONDS);
+        mActivity.mUrlRequestContext.shutdown();
+        super.tearDown();
+    }
+
+    private SimpleUrlRequestListener startAndWaitForComplete(String url)
+            throws Exception {
+        SimpleUrlRequestListener listener = new SimpleUrlRequestListener();
+        // Create request.
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                url, listener, mExecutor);
+        urlRequest.start();
+        listener.blockForDone();
+        return listener;
+    }
+
+    private void checkResponseInfo(ResponseInfo responseInfo,
+            String expectedUrl, int expectedStatusHttpCode) {
+        assertEquals(expectedUrl, responseInfo.getUrl());
+        assertEquals(expectedUrl, responseInfo.getUrlChain()[
+                responseInfo.getUrlChain().length - 1]);
+        assertEquals(expectedStatusHttpCode, responseInfo.getHttpStatusCode());
+        assertEquals(expectedStatusHttpCode, Integer.parseInt(
+                responseInfo.getAllHeaders().get(null).get(0).split(" ")[1]));
+        assertFalse(responseInfo.wasCached());
+    }
+
+    private void checkResponseInfoHeader(ResponseInfo responseInfo,
+            String headerName, String headerValue) {
+        Map<String, List<String>> responseHeaders =
+                responseInfo.getAllHeaders();
+        List<String> header = responseHeaders.get(headerName);
+        assertNotNull(header);
+        assertTrue(header.contains(headerValue));
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testSimpleGet() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                UploadTestServer.getEchoMethodURL());
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        // Default method is 'GET'.
+        assertEquals("GET", listener.mResponseAsString);
+        assertFalse(listener.mOnRedirectCalled);
+        assertEquals(listener.mLastCalled, LastCalled.OnComplete);
+        checkResponseInfo(listener.mResponseInfo,
+                UploadTestServer.getEchoMethodURL(), 200);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testSetHttpMethod() throws Exception {
+        SimpleUrlRequestListener listener = new SimpleUrlRequestListener();
+        String methodName = "HEAD";
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                UploadTestServer.getEchoMethodURL(), listener,
+                mExecutor);
+        // Try to set 'null' method.
+        try {
+            urlRequest.setHttpMethod(null);
+            fail("Exception not thrown");
+        } catch (NullPointerException e) {
+            assertEquals("Method is required.", e.getMessage());
+        }
+
+        urlRequest.setHttpMethod(methodName);
+        urlRequest.start();
+        try {
+            urlRequest.setHttpMethod("toolate");
+            fail("Exception not thrown");
+        } catch (IllegalStateException e) {
+            assertEquals("Request is already started.", e.getMessage());
+        }
+        listener.blockForDone();
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertEquals(0, listener.mHttpResponseDataLength);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testBadMethod() throws Exception {
+        SimpleUrlRequestListener listener = new SimpleUrlRequestListener();
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                TEST_URL, listener, mExecutor);
+        try {
+            urlRequest.setHttpMethod("bad:method!");
+            urlRequest.start();
+            fail("IllegalArgumentException not thrown.");
+        } catch (IllegalArgumentException e) {
+            assertEquals("Invalid http method bad:method!",
+                    e.getMessage());
+        }
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testBadHeader() throws Exception {
+        SimpleUrlRequestListener listener = new SimpleUrlRequestListener();
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                TEST_URL, listener, mExecutor);
+        try {
+            urlRequest.addHeader("header:name", "headervalue");
+            urlRequest.addHeader("headername", "bad header\r\nvalue");
+            urlRequest.start();
+            fail("IllegalArgumentException not thrown.");
+        } catch (IllegalArgumentException e) {
+            assertEquals("Invalid header header:name=headervalue",
+                    e.getMessage());
+        }
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testAddHeader() throws Exception {
+        SimpleUrlRequestListener listener = new SimpleUrlRequestListener();
+        String headerName = "header-name";
+        String headerValue = "header-value";
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                UploadTestServer.getEchoHeaderURL(headerName), listener,
+                mExecutor);
+
+        urlRequest.addHeader(headerName, headerValue);
+        urlRequest.start();
+        try {
+            urlRequest.addHeader("header2", "value");
+            fail("Exception not thrown");
+        } catch (IllegalStateException e) {
+            assertEquals("Request is already started.", e.getMessage());
+        }
+        listener.blockForDone();
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertEquals(headerValue, listener.mResponseAsString);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMultiRequestHeaders() throws Exception {
+        SimpleUrlRequestListener listener = new SimpleUrlRequestListener();
+        String headerName = "header-name";
+        String headerValue1 = "header-value1";
+        String headerValue2 = "header-value2";
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                UploadTestServer.getEchoHeaderURL(headerName), listener,
+                mExecutor);
+        urlRequest.addHeader(headerName, headerValue1);
+        urlRequest.addHeader(headerName, headerValue2);
+        urlRequest.start();
+        listener.blockForDone();
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        // TODO(mef): Fix embedded test server to correctly return combination
+        // of headerValue1 +  headerValue2.
+        assertEquals(headerValue2, listener.mResponseAsString);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testCustomUserAgent() throws Exception {
+        SimpleUrlRequestListener listener = new SimpleUrlRequestListener();
+        String userAgentName = "User-Agent";
+        String userAgentValue = "User-Agent-Value";
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                UploadTestServer.getEchoHeaderURL(userAgentName), listener,
+                mExecutor);
+        urlRequest.addHeader(userAgentName, userAgentValue);
+        urlRequest.start();
+        listener.blockForDone();
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertEquals(userAgentValue, listener.mResponseAsString);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testDefaultUserAgent() throws Exception {
+        SimpleUrlRequestListener listener = new SimpleUrlRequestListener();
+        String headerName = "User-Agent";
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                UploadTestServer.getEchoHeaderURL(headerName), listener,
+                mExecutor);
+        urlRequest.start();
+        listener.blockForDone();
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertTrue("Default User-Agent should contain Cronet/n.n.n.n but is "
+                           + listener.mResponseAsString,
+                   Pattern.matches(".+Cronet/\\d+\\.\\d+\\.\\d+\\.\\d+.+",
+                           listener.mResponseAsString));
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockSuccess() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MOCK_CRONET_TEST_SUCCESS_URL);
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertEquals(0, listener.mRedirectResponseInfoList.size());
+        assertTrue(listener.mHttpResponseDataLength != 0);
+        assertEquals(listener.mLastCalled, LastCalled.OnComplete);
+        Map<String, List<String>> responseHeaders =
+                listener.mResponseInfo.getAllHeaders();
+        assertEquals("header-value", responseHeaders.get("header-name").get(0));
+        List<String> multiHeader = responseHeaders.get("multi-header-name");
+        assertEquals(2, multiHeader.size());
+        assertEquals("header-value1", multiHeader.get(0));
+        assertEquals("header-value2", multiHeader.get(1));
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockRedirect() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MOCK_CRONET_TEST_REDIRECT_URL);
+        ResponseInfo mResponseInfo = listener.mResponseInfo;
+        assertTrue(listener.mOnRedirectCalled);
+        assertEquals(200, mResponseInfo.getHttpStatusCode());
+        assertEquals(1, listener.mRedirectResponseInfoList.size());
+        assertEquals(MOCK_CRONET_TEST_SUCCESS_URL,
+                mResponseInfo.getUrl());
+        assertEquals(2, mResponseInfo.getUrlChain().length);
+        assertEquals(MOCK_CRONET_TEST_REDIRECT_URL,
+                mResponseInfo.getUrlChain()[0]);
+        assertEquals(MOCK_CRONET_TEST_SUCCESS_URL,
+                mResponseInfo.getUrlChain()[1]);
+        checkResponseInfo(listener.mRedirectResponseInfoList.get(0),
+                MOCK_CRONET_TEST_REDIRECT_URL, 302);
+        checkResponseInfoHeader(listener.mRedirectResponseInfoList.get(0),
+                "redirect-header", "header-value");
+        assertTrue(listener.mHttpResponseDataLength != 0);
+        assertTrue(listener.mOnRedirectCalled);
+        assertEquals(listener.mLastCalled, LastCalled.OnComplete);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockMultiRedirect() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MOCK_CRONET_TEST_MULTI_REDIRECT_URL);
+        ResponseInfo mResponseInfo = listener.mResponseInfo;
+        assertTrue(listener.mOnRedirectCalled);
+        assertEquals(200, mResponseInfo.getHttpStatusCode());
+        assertEquals(2, listener.mRedirectResponseInfoList.size());
+        assertEquals(MOCK_CRONET_TEST_SUCCESS_URL,
+                mResponseInfo.getUrl());
+        assertEquals(3, mResponseInfo.getUrlChain().length);
+        assertEquals(MOCK_CRONET_TEST_MULTI_REDIRECT_URL,
+                mResponseInfo.getUrlChain()[0]);
+        assertEquals(MOCK_CRONET_TEST_REDIRECT_URL,
+                mResponseInfo.getUrlChain()[1]);
+        assertEquals(MOCK_CRONET_TEST_SUCCESS_URL,
+                mResponseInfo.getUrlChain()[2]);
+        assertEquals(2, listener.mRedirectResponseInfoList.size());
+
+        // Check First redirect (multiredirect.html -> redirect.html)
+        ResponseInfo firstRedirectResponseInfo =
+                listener.mRedirectResponseInfoList.get(0);
+        assertEquals(1, firstRedirectResponseInfo.getUrlChain().length);
+        assertEquals(MOCK_CRONET_TEST_MULTI_REDIRECT_URL,
+                firstRedirectResponseInfo.getUrlChain()[0]);
+        checkResponseInfo(firstRedirectResponseInfo,
+                MOCK_CRONET_TEST_MULTI_REDIRECT_URL, 302);
+        checkResponseInfoHeader(firstRedirectResponseInfo,
+                "redirect-header0", "header-value");
+
+        // Check Second redirect (redirect.html -> success.txt)
+        ResponseInfo secondRedirectResponseInfo =
+                listener.mRedirectResponseInfoList.get(1);
+        assertEquals(2, secondRedirectResponseInfo.getUrlChain().length);
+        assertEquals(MOCK_CRONET_TEST_MULTI_REDIRECT_URL,
+                secondRedirectResponseInfo.getUrlChain()[0]);
+        assertEquals(MOCK_CRONET_TEST_REDIRECT_URL,
+                secondRedirectResponseInfo.getUrlChain()[1]);
+        checkResponseInfo(secondRedirectResponseInfo,
+                MOCK_CRONET_TEST_REDIRECT_URL, 302);
+        checkResponseInfoHeader(secondRedirectResponseInfo,
+                "redirect-header", "header-value");
+        assertTrue(listener.mHttpResponseDataLength != 0);
+        assertTrue(listener.mOnRedirectCalled);
+        assertEquals(listener.mLastCalled, LastCalled.OnComplete);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockNotFound() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MOCK_CRONET_TEST_NOTFOUND_URL);
+        assertEquals(404, listener.mResponseInfo.getHttpStatusCode());
+        assertTrue(listener.mHttpResponseDataLength != 0);
+        assertFalse(listener.mOnRedirectCalled);
+        assertFalse(listener.mOnErrorCalled);
+        assertEquals(listener.mLastCalled, LastCalled.OnComplete);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockStartAsyncError() throws Exception {
+        final int arbitraryNetError = -3;
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MockUrlRequestJobUtil.getMockUrlWithFailure(
+                        MOCK_SUCCESS_PATH,
+                        MockUrlRequestJobUtil.FailurePhase.START,
+                        arbitraryNetError));
+        assertNull(listener.mResponseInfo);
+        assertNotNull(listener.mError);
+        assertEquals(arbitraryNetError, listener.mError.netError());
+        assertFalse(listener.mOnRedirectCalled);
+        assertTrue(listener.mOnErrorCalled);
+        assertEquals(listener.mLastCalled, LastCalled.Nothing);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockReadDataSyncError() throws Exception {
+        final int arbitraryNetError = -4;
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MockUrlRequestJobUtil.getMockUrlWithFailure(
+                        MOCK_SUCCESS_PATH,
+                        MockUrlRequestJobUtil.FailurePhase.READ_SYNC,
+                        arbitraryNetError));
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertNotNull(listener.mError);
+        assertEquals(arbitraryNetError, listener.mError.netError());
+        assertFalse(listener.mOnRedirectCalled);
+        assertTrue(listener.mOnErrorCalled);
+        assertEquals(listener.mLastCalled, LastCalled.OnResponseStarted);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockReadDataAsyncError() throws Exception {
+        final int arbitraryNetError = -5;
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MockUrlRequestJobUtil.getMockUrlWithFailure(
+                        MOCK_SUCCESS_PATH,
+                        MockUrlRequestJobUtil.FailurePhase.READ_ASYNC,
+                        arbitraryNetError));
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertNotNull(listener.mError);
+        assertEquals(arbitraryNetError, listener.mError.netError());
+        assertFalse(listener.mOnRedirectCalled);
+        assertTrue(listener.mOnErrorCalled);
+        assertEquals(listener.mLastCalled, LastCalled.OnResponseStarted);
+    }
+
+    /**
+     * UrlRequestListener that allows to cancel request or throw an exception
+     * from arbitrary step.
+     */
+    class CancelingUrlRequestListener extends SimpleUrlRequestListener {
+        FailureType mFailureType = FailureType.None;
+        LastCalled mFailureStep = LastCalled.Nothing;
+        ExecutorService mExecutor;
+
+        public CancelingUrlRequestListener(ExecutorService executor) {
+            mExecutor = executor;
+        }
+
+        @Override
+        public void onRedirect(UrlRequest request,
+                               ResponseInfo info,
+                               String newLocationUrl) {
+            super.onRedirect(request, info, newLocationUrl);
+            maybeThrowOrCancel(request);
+        }
+
+        @Override
+        public void onResponseStarted(UrlRequest request, ResponseInfo info) {
+            super.onResponseStarted(request, info);
+            maybeThrowOrCancel(request);
+        }
+
+        @Override
+        public void onDataReceived(UrlRequest request,
+                                   ResponseInfo info,
+                                   ByteBuffer byteBuffer) {
+            super.onDataReceived(request, info, byteBuffer);
+            maybeThrowOrCancel(request);
+        }
+
+        @Override
+        public void onComplete(UrlRequest request, ExtendedResponseInfo info) {
+            super.onComplete(request, info);
+            maybeThrowOrCancel(request);
+        }
+
+        private void maybeThrowOrCancel(final UrlRequest request) {
+            if (mLastCalled != mFailureStep) {
+                return;
+            }
+            if (mFailureType == FailureType.None) {
+                return;
+            }
+            if (mFailureType == FailureType.ThrowSync) {
+                throw new IllegalStateException("Listener Exception.");
+            }
+            Runnable task = new Runnable() {
+                public void run() {
+                    request.cancel();
+                    openDone();
+                }
+            };
+            if (mFailureType == FailureType.CancelAsync) {
+                mExecutor.execute(task);
+            } else {
+                task.run();
+            }
+        }
+    }
+
+    private void throwOrCancel(FailureType failureType, LastCalled failureStep,
+            boolean expectResponseInfo, boolean expectError) {
+        CancelingUrlRequestListener listener =
+                new CancelingUrlRequestListener(mExecutor);
+        listener.mFailureType = failureType;
+        listener.mFailureStep = failureStep;
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                MOCK_CRONET_TEST_REDIRECT_URL, listener, mExecutor);
+        urlRequest.start();
+        listener.blockForDone();
+        assertTrue(listener.mOnRedirectCalled);
+        assertEquals(listener.mLastCalled, failureStep);
+        assertTrue(urlRequest.isCanceled());
+        assertEquals(expectResponseInfo, listener.mResponseInfo != null);
+        assertEquals(expectError, listener.mError != null);
+        assertEquals(expectError, listener.mOnErrorCalled);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testFailures() throws Exception {
+        throwOrCancel(FailureType.CancelSync, LastCalled.OnRedirect,
+                false, false);
+        throwOrCancel(FailureType.CancelAsync, LastCalled.OnRedirect,
+                false, false);
+        throwOrCancel(FailureType.ThrowSync, LastCalled.OnRedirect,
+                false, true);
+
+        throwOrCancel(FailureType.CancelSync, LastCalled.OnResponseStarted,
+                true, false);
+        throwOrCancel(FailureType.CancelAsync, LastCalled.OnResponseStarted,
+                true, false);
+        throwOrCancel(FailureType.ThrowSync, LastCalled.OnResponseStarted,
+                true, true);
+
+        throwOrCancel(FailureType.CancelSync, LastCalled.OnDataReceived,
+                true, false);
+        throwOrCancel(FailureType.CancelAsync, LastCalled.OnDataReceived,
+                true, false);
+        throwOrCancel(FailureType.ThrowSync, LastCalled.OnDataReceived,
+                true, true);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testThrowOnComplete() {
+        CancelingUrlRequestListener listener =
+                new CancelingUrlRequestListener(mExecutor);
+        listener.mFailureType = FailureType.ThrowSync;
+        listener.mFailureStep = LastCalled.OnComplete;
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                MOCK_CRONET_TEST_REDIRECT_URL, listener, mExecutor);
+        urlRequest.start();
+        listener.blockForDone();
+        assertTrue(listener.mOnRedirectCalled);
+        assertEquals(listener.mLastCalled, LastCalled.OnComplete);
+        assertFalse(urlRequest.isCanceled());
+        assertNotNull(listener.mResponseInfo);
+        assertNull(listener.mError);
+        assertFalse(listener.mOnErrorCalled);
+    }
+}