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..60a2e9455c88bd030363f2309522d48c377f6f0f
--- /dev/null
+++ b/components/cronet/android/test/javatests/src/org/chromium/cronet_test_apk/CronetUrlRequestTest.java
@@ -0,0 +1,608 @@
+// 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.net.URL;
+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.TimeUnit;
+import java.util.regex.Pattern;

[mmenke, 2014/10/29 21:40:30]

Should there be blank lines between imports based on the first component or the
first two components?  When I searched through the code, the latter two looked
more common to me (You're also doing that up top, with the two android imports)

[mef, 2014/10/30 03:01:32]

Good question. I'd say just first component, but I could be wrong.

[mmenke, 2014/10/30 21:47:56]

Android style guide indicates it's just first component, so let's go with that
unless we hear otherwise.

+
+/**
+ * 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();
+    CronetTestActivity mActivity;
+
+    private enum LastCalled {
+        Nothing,
+        OnRedirect,
+        OnResponseStarted,
+        OnDataReceived,
+        OnComplete
+    };
+
+    private enum FailureType {
+        None,
+        CancelSync,
+        CancelAsync,
+        ThrowSync
+    };
+
+    class SimpleUrlRequestListener implements UrlRequestListener {

[mmenke, 2014/10/29 21:40:29]

Should describe what this class does

[mmenke, 2014/10/29 21:40:30]

For these tests, we should make sure the SimpleUrlRequestListener is called on
the correct thread.

There are a couple ways to do it - we could create a ThreadPoolExecutor with our
own ThreadFactory, and keep a pointer to the single thread it created, and make
sure that matches the current thread whenever we call into this.  Or we could
create our own thread, and add an executor for it.  Probably other ways, first
is probably the simplest.

[mef, 2014/10/30 03:01:32]

Done.

[mef, 2014/10/30 03:01:32]

Done.

+        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 = "";
+
+        private ConditionVariable mComplete = new ConditionVariable();

[mmenke, 2014/10/29 21:40:30]

Should describe what this class does.

[mef, 2014/10/30 03:01:32]

Done.

+
+        public SimpleUrlRequestListener() {
+        }
+
+        @Override
+        public void onRedirect(UrlRequest request,
+                               ResponseInfo info,
+                               URL newLocation) {
+            assertTrue(mLastCalled == LastCalled.Nothing
+                       || mLastCalled == LastCalled.OnRedirect);

[mmenke, 2014/10/29 21:40:30]

nit:  Put || on previous line (x3)

[mef, 2014/10/30 03:01:32]

presubmit made me do it, I swear!

+            mRedirectResponseInfoList.add(info);
+            mLastCalled = LastCalled.OnRedirect;
+            mOnRedirectCalled = true;
+        }
+
+        @Override
+        public void onResponseStarted(UrlRequest request, ResponseInfo info) {
+            assertTrue(mLastCalled == LastCalled.Nothing
+                       || mLastCalled == LastCalled.OnRedirect);
+            mLastCalled = LastCalled.OnResponseStarted;
+            mResponseInfo = info;
+        }
+
+        @Override
+        public void onDataReceived(UrlRequest request,
+                                   ResponseInfo info,
+                                   ByteBuffer byteBuffer) {
+            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) {
+            assertTrue(mLastCalled == LastCalled.OnResponseStarted
+                       || mLastCalled == LastCalled.OnDataReceived);
+            mLastCalled = LastCalled.OnComplete;
+            mExtendedResponseInfo = info;
+            openComplete();

[mmenke, 2014/10/29 21:40:29]

nit:  complete's over's overloaded here - onComplete means on successful
completion, but blockForComplete means until done.

Suggest changing the test-only "completes" to "done" to make it clear they're
different.

As for the API maybe onComplete -> onSuccess (Updating the API as well)?  Open
to other ideas.  Think a non-ambiguous name is preferable (See earlier confusion
with old API if we called the completion function on error or not).

[mef, 2014/10/30 03:01:32]

Done.

+        }
+
+        @Override
+        public void onError(UrlRequest request,
+                            ResponseInfo info,
+                            UrlRequestException error) {
+            mOnErrorCalled = true;
+            mError = error;
+            openComplete();
+        }
+
+        public void blockForComplete() {
+            mComplete.block();
+        }
+
+        protected void openComplete() {
+            mComplete.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.blockForComplete();
+        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.blockForComplete();
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertEquals(0, listener.mHttpResponseDataLength);
+    }
+
+    @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.blockForComplete();
+        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.blockForComplete();
+        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.blockForComplete();
+        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.blockForComplete();
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertTrue("Default User-Agent should contain Cronet/n.n.n.n but is "
+                           + listener.mResponseAsString,

[mmenke, 2014/10/29 21:40:30]

nit:  Operator on previous line.

[mef, 2014/10/30 03:01:32]

Presubmit fails if so.

+                   Pattern.matches(".+Cronet/\\d+\\.\\d+\\.\\d+\\.\\d+.+",
+                           listener.mResponseAsString));
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockSuccess() throws Exception {

[mmenke, 2014/10/29 21:40:29]

Check RedirectResponseInfoList is empty?

[mef, 2014/10/30 03:01:32]

Done.

+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MOCK_CRONET_TEST_SUCCESS_URL);
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        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 {

[mmenke, 2014/10/29 21:40:29]

Check RedirectResponseInfoList's length in all redirect tests?

[mef, 2014/10/30 03:01:32]

Done.

+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MOCK_CRONET_TEST_REDIRECT_URL);
+        ResponseInfo mResponseInfo = listener.mResponseInfo;
+        assertTrue(listener.mOnRedirectCalled);
+        assertEquals(200, mResponseInfo.getHttpStatusCode());
+        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_SUCCESS_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(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(MOCK_CRONET_TEST_MULTI_REDIRECT_URL,
+                firstRedirectResponseInfo.getUrlChain()[0]);

[mmenke, 2014/10/29 21:40:29]

Check secondRedirectResponseInfo.getUrlChain()[1]?  (Unless you follow my
comment about not including it until after we follow the redirect)

[mmenke, 2014/10/29 21:40:30]

Check URL chain length?

[mef, 2014/10/30 03:01:32]

Done.

+        checkResponseInfo(firstRedirectResponseInfo,
+                MOCK_CRONET_TEST_REDIRECT_URL, 302);
+        checkResponseInfoHeader(firstRedirectResponseInfo,
+                "redirect-header0", "header-value");
+
+        // Check Second redirect (redirect.html -> success.txt)
+        ResponseInfo secondRedirectResponseInfo =
+                listener.mRedirectResponseInfoList.get(1);
+        assertEquals(MOCK_CRONET_TEST_MULTI_REDIRECT_URL,
+                secondRedirectResponseInfo.getUrlChain()[0]);
+        assertEquals(MOCK_CRONET_TEST_REDIRECT_URL,
+                secondRedirectResponseInfo.getUrlChain()[1]);
+        assertEquals(MOCK_CRONET_TEST_SUCCESS_URL,
+                secondRedirectResponseInfo.getUrlChain()[2]);

[mmenke, 2014/10/29 21:40:29]

Check URL chain length here, too

[mef, 2014/10/30 03:01:32]

Done.

+        checkResponseInfo(secondRedirectResponseInfo,
+                MOCK_CRONET_TEST_SUCCESS_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 {
+        int arbitraryNetError = -3;

[mmenke, 2014/10/29 21:40:29]

Hrm...make these test constants final?  We'd prefix them with k in C++, but I
guess not here.

[mef, 2014/10/30 03:01:32]

Done.

+        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 {
+        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 {
+        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);
+    }
+
+    class CancelingUrlRequestListener extends SimpleUrlRequestListener {

[mmenke, 2014/10/29 21:40:29]

Should describe what this class does

[mef, 2014/10/30 03:01:32]

Done.

+

[mmenke, 2014/10/29 21:40:30]

nit:  Remove blank line.

[mef, 2014/10/30 03:01:32]

Done.

+        FailureType mFailureType = FailureType.None;
+        LastCalled mFailureStep = LastCalled.Nothing;
+
+        ExecutorService mExecutor;
+
+        public CancelingUrlRequestListener(ExecutorService executor) {
+            mExecutor = executor;
+        }
+
+        @Override
+        public void onRedirect(UrlRequest request,
+                               ResponseInfo info,
+                               URL newLocation) {
+            super.onRedirect(request, info, newLocation);
+            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();
+                    openComplete();
+                }
+            };
+            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.blockForComplete();
+        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.blockForComplete();
+        assertTrue(listener.mOnRedirectCalled);
+        assertEquals(listener.mLastCalled, LastCalled.OnComplete);
+        assertFalse(urlRequest.isCanceled());
+        assertNotNull(listener.mResponseInfo);
+        assertNull(listener.mError);
+        assertFalse(listener.mOnErrorCalled);
+    }
+}