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..52fa520767a62c63a67a0430985510f83d53524f
--- /dev/null
+++ b/components/cronet/android/test/javatests/src/org/chromium/cronet_test_apk/CronetUrlRequestTest.java
@@ -0,0 +1,416 @@
+// 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.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * Test basic functionality of UrlRequest.
+ */
+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_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;
+
+    class SimpleUrlRequestListener implements UrlRequestListener {
+        ConditionVariable mComplete = new ConditionVariable();
+        public ResponseInfo mResponseInfo;
+        public UrlRequestException mError;
+
+        public int mHttpResponseDataLength = 0;
+
+        public boolean mOnRedirectCalled = false;
+        public boolean mOnResponseStartedCalled = false;
+        public boolean mOnDataReceivedCalled = false;
+        public boolean mOnCompleteCalled = false;
+        public boolean mOnErrorCalled = false;
+
+        public SimpleUrlRequestListener() {
+        }
+
+        @Override
+        public void onRedirect(UrlRequest request,
+                               ResponseInfo info,
+                               URL newLocation) {
+            mOnRedirectCalled = true;
+        }
+
+        @Override
+        public void onResponseStarted(UrlRequest request, ResponseInfo info) {
+            mOnResponseStartedCalled = true;
+            mResponseInfo = info;
+        }
+
+        @Override
+        public void onDataReceived(UrlRequest request,
+                                   ResponseInfo info,
+                                   ByteBuffer byteBuffer) {
+            mOnDataReceivedCalled = true;
+            mHttpResponseDataLength += byteBuffer.capacity();
+        }
+
+        @Override
+        public void onComplete(UrlRequest request, ExtendedResponseInfo info) {
+            mOnCompleteCalled = true;
+            mComplete.open();
+        }
+
+        @Override
+        public void onError(UrlRequest request,
+                            ResponseInfo info,
+                            UrlRequestException error) {
+            mOnErrorCalled = true;
+            mError = error;
+            mComplete.open();
+        }
+
+        public void blockForComplete() {
+            mComplete.block();
+        }
+
+        public void resetComplete() {
+            mComplete.close();
+        }
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mActivity = launchCronetTestApp();
+        // Make sure the activity was created as expected.
+        waitForActiveShellToBeDoneLoading();
+        // AddUrlInterceptors() after native application context is initialized.
+        MockUrlRequestJobUtil.addUrlInterceptors();
+    }
+
+    public 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;
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testSimpleGet() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(TEST_URL);
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertTrue(listener.mHttpResponseDataLength != 0);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockSuccess() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MOCK_CRONET_TEST_SUCCESS_URL);
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertTrue(listener.mHttpResponseDataLength != 0);
+    }
+
+    @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(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]);
+        assertTrue(listener.mHttpResponseDataLength != 0);
+    }
+
+    @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);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockFailed() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MOCK_CRONET_TEST_FAILED_URL);
+        assertEquals(null, listener.mResponseInfo);
+        assertEquals(0, listener.mHttpResponseDataLength);
+        assertNotNull(listener.mError);
+        assertEquals(-2, listener.mError.netError());
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockStartSyncError() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MockUrlRequestJobUtil.getMockUrlWithFailure(
+                        MOCK_SUCCESS_PATH,
+                        MockUrlRequestJobUtil.FailurePhase.START,
+                        -3));
+        assertNull(listener.mResponseInfo);
+        assertNotNull(listener.mError);
+        assertEquals(-3, listener.mError.netError());
+        assertFalse(listener.mOnRedirectCalled);
+        assertFalse(listener.mOnResponseStartedCalled);
+        assertFalse(listener.mOnDataReceivedCalled);
+        assertFalse(listener.mOnCompleteCalled);
+        assertTrue(listener.mOnErrorCalled);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockReadDataSyncError() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MockUrlRequestJobUtil.getMockUrlWithFailure(
+                        MOCK_SUCCESS_PATH,
+                        MockUrlRequestJobUtil.FailurePhase.READ_SYNC,
+                        -5));
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertNotNull(listener.mError);
+        assertEquals(-5, listener.mError.netError());
+        assertFalse(listener.mOnRedirectCalled);
+        assertTrue(listener.mOnResponseStartedCalled);
+        assertFalse(listener.mOnDataReceivedCalled);
+        assertFalse(listener.mOnCompleteCalled);
+        assertTrue(listener.mOnErrorCalled);
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMockReadDataAsyncError() throws Exception {
+        SimpleUrlRequestListener listener = startAndWaitForComplete(
+                MockUrlRequestJobUtil.getMockUrlWithFailure(
+                        MOCK_SUCCESS_PATH,
+                        MockUrlRequestJobUtil.FailurePhase.READ_ASYNC,
+                        -5));
+        assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
+        assertNotNull(listener.mError);
+        assertEquals(-5, listener.mError.netError());
+        assertFalse(listener.mOnRedirectCalled);
+        assertTrue(listener.mOnResponseStartedCalled);
+        assertFalse(listener.mOnDataReceivedCalled);
+        assertFalse(listener.mOnCompleteCalled);
+        assertTrue(listener.mOnErrorCalled);
+    }
+
+    class CancelingUrlRequestListener extends SimpleUrlRequestListener {
+        public boolean mCancelAfterRedirect = false;
+        public boolean mCancelAfterResponseStarted = false;
+        public boolean mCancelAfterDataReceived = false;
+
+        public boolean mCancelFromRedirect = false;
+        public boolean mCancelFromResponseStarted = false;
+        public boolean mCancelFromDataReceived = false;
+
+        public CancelingUrlRequestListener() {
+        }
+
+        @Override
+        public void onRedirect(UrlRequest request,
+                               ResponseInfo info,
+                               URL newLocation) {
+            super.onRedirect(request, info, newLocation);
+            if (mCancelFromRedirect) {
+                request.cancel();
+                mComplete.open();
+            }
+            maybePostCancel(request, mCancelAfterRedirect);
+        }
+
+        @Override
+        public void onResponseStarted(UrlRequest request, ResponseInfo info) {
+            super.onResponseStarted(request, info);
+            if (mCancelFromResponseStarted) {
+                request.cancel();
+                mComplete.open();
+            }
+            maybePostCancel(request, mCancelAfterResponseStarted);
+        }
+
+        @Override
+        public void onDataReceived(UrlRequest request,
+                                   ResponseInfo info,
+                                   ByteBuffer byteBuffer) {
+            super.onDataReceived(request, info, byteBuffer);
+            if (mCancelFromDataReceived) {
+                request.cancel();
+                mComplete.open();
+            }
+            maybePostCancel(request, mCancelAfterDataReceived);
+        }
+
+        void maybePostCancel(final UrlRequest request, boolean doPostCancel) {
+            if (doPostCancel) {
+                Runnable task = new Runnable() {
+                    public void run() {
+                        request.cancel();
+                        mComplete.open();
+                    }
+                };
+                mExecutor.execute(task);
+            }
+        }
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testCancelAfterOnRedirect() throws Exception {
+        CancelingUrlRequestListener listener =
+                new CancelingUrlRequestListener();
+        listener.mCancelAfterRedirect = true;
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                MOCK_CRONET_TEST_REDIRECT_URL, listener, mExecutor);
+        urlRequest.start();
+        listener.blockForComplete();
+        assertNull(listener.mResponseInfo);
+        assertNull(listener.mError);
+        assertTrue(listener.mOnRedirectCalled);
+        assertFalse(listener.mOnResponseStartedCalled);
+        assertFalse(listener.mOnDataReceivedCalled);
+        assertFalse(listener.mOnCompleteCalled);
+        assertFalse(listener.mOnErrorCalled);
+        assertTrue(urlRequest.isCanceled());
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testCancelAfterOnResponseStarted() throws Exception {
+        CancelingUrlRequestListener listener =
+                new CancelingUrlRequestListener();
+        listener.mCancelAfterResponseStarted = true;
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                MOCK_CRONET_TEST_REDIRECT_URL, listener, mExecutor);
+        urlRequest.start();
+        listener.blockForComplete();
+        assertNotNull(listener.mResponseInfo);
+        assertNull(listener.mError);
+        assertTrue(listener.mOnRedirectCalled);
+        assertTrue(listener.mOnResponseStartedCalled);
+        assertFalse(listener.mOnDataReceivedCalled);
+        assertFalse(listener.mOnCompleteCalled);
+        assertFalse(listener.mOnErrorCalled);
+        assertTrue(urlRequest.isCanceled());
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testCancelAfterOnDataReceived() throws Exception {
+        CancelingUrlRequestListener listener =
+                new CancelingUrlRequestListener();
+        listener.mCancelAfterDataReceived = true;
+        // Create request.
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                MOCK_CRONET_TEST_REDIRECT_URL, listener, mExecutor);
+        urlRequest.start();
+        listener.blockForComplete();
+        assertNotNull(listener.mResponseInfo);
+        assertNull(listener.mError);
+        assertTrue(listener.mOnRedirectCalled);
+        assertTrue(listener.mOnResponseStartedCalled);
+        assertTrue(listener.mOnDataReceivedCalled);
+        assertFalse(listener.mOnCompleteCalled);
+        assertFalse(listener.mOnErrorCalled);
+        assertTrue(urlRequest.isCanceled());
+    }
+
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testCancelFromOnRedirect() throws Exception {
+        CancelingUrlRequestListener listener =
+                new CancelingUrlRequestListener();
+        listener.mCancelFromRedirect = true;
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                MOCK_CRONET_TEST_REDIRECT_URL, listener, mExecutor);
+        urlRequest.start();
+        listener.blockForComplete();
+        assertNull(listener.mResponseInfo);
+        assertNull(listener.mError);
+        assertTrue(listener.mOnRedirectCalled);
+        assertFalse(listener.mOnResponseStartedCalled);
+        assertFalse(listener.mOnDataReceivedCalled);
+        assertFalse(listener.mOnCompleteCalled);
+        assertFalse(listener.mOnErrorCalled);
+        assertTrue(urlRequest.isCanceled());
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testCancelFromOnResponseStarted() throws Exception {
+        CancelingUrlRequestListener listener =
+                new CancelingUrlRequestListener();
+        listener.mCancelFromResponseStarted = true;
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                MOCK_CRONET_TEST_REDIRECT_URL, listener, mExecutor);
+        urlRequest.start();
+        listener.blockForComplete();
+        assertNotNull(listener.mResponseInfo);
+        assertNull(listener.mError);
+        assertTrue(listener.mOnRedirectCalled);
+        assertTrue(listener.mOnResponseStartedCalled);
+        assertFalse(listener.mOnDataReceivedCalled);
+        assertFalse(listener.mOnCompleteCalled);
+        assertFalse(listener.mOnErrorCalled);
+        assertTrue(urlRequest.isCanceled());
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testCancelFromOnDataReceived() throws Exception {
+        CancelingUrlRequestListener listener =
+                new CancelingUrlRequestListener();
+        listener.mCancelFromDataReceived = true;
+        // Create request.
+        UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
+                MOCK_CRONET_TEST_REDIRECT_URL, listener, mExecutor);
+        urlRequest.start();
+        listener.blockForComplete();
+        assertNotNull(listener.mResponseInfo);
+        assertNull(listener.mError);
+        assertTrue(listener.mOnRedirectCalled);
+        assertTrue(listener.mOnResponseStartedCalled);
+        assertTrue(listener.mOnDataReceivedCalled);
+        assertFalse(listener.mOnCompleteCalled);
+        assertFalse(listener.mOnErrorCalled);
+        assertTrue(urlRequest.isCanceled());
+    }
+}