Allow direct executors in cronet.

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

 // 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.net;
 
 import android.os.ConditionVariable;
 import android.test.MoreAsserts;
 import android.test.suitebuilder.annotation.SmallTest;
 import android.util.Log;
 
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.TestUrlRequestCallback.FailureType;
 import org.chromium.net.TestUrlRequestCallback.ResponseStep;
 import org.chromium.net.impl.CronetUrlRequest;
 import org.chromium.net.test.FailurePhase;
 
 import java.io.IOException;
 import java.net.ConnectException;
 import java.nio.ByteBuffer;
 import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
  * Test functionality of CronetUrlRequest.
  */
 public class CronetUrlRequestTest extends CronetTestBase {
@@ skipping 1298 matching lines @@
         dataProvider.assertClosed();
 
         assertEquals(1, dataProvider.getNumReadCalls());
         assertEquals(0, dataProvider.getNumRewindCalls());
 
         assertEquals("Exception received from UploadDataProvider", callback.mError.getMessage());
         assertEquals("Async read failure", callback.mError.getCause().getMessage());
         assertEquals(null, callback.mResponseInfo);
     }
 
+    /** This test uses a direct executor for upload, and non direct for callbacks */
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testDirectExecutorUploadProhibitedByDefault() throws Exception {
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        Executor myExecutor = new Executor() {
+
+            @Override
+            public void execute(Runnable command) {
+                command.run();
+            }
+        };
+        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
+                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+
+        TestUploadDataProvider dataProvider = new TestUploadDataProvider(
+                TestUploadDataProvider.SuccessCallbackMode.SYNC, myExecutor);
+        // This will never be read, but if the length is 0, read may never be
+        // called.
+        dataProvider.addRead("test".getBytes());
+        builder.setUploadDataProvider(dataProvider, myExecutor);
+        builder.addHeader("Content-Type", "useless/string");
+        builder.build().start();
+        callback.blockForDone();
+
+        assertEquals(0, dataProvider.getNumReadCalls());
+        assertEquals(0, dataProvider.getNumRewindCalls());
+
+        assertEquals("Exception received from UploadDataProvider", callback.mError.getMessage());
+        assertEquals("Inline execution is prohibited for this request",
+                callback.mError.getCause().getMessage());
+        assertEquals(null, callback.mResponseInfo);
+    }
+
+    /** This test uses a direct executor for callbacks, and non direct for upload */
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testDirectExecutorProhibitedByDefault() throws Exception {
+        System.out.println("testing with " + mTestFramework.mCronetEngine);
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        Executor myExecutor = new Executor() {
+
+            @Override
+            public void execute(Runnable command) {
+                command.run();
+            }
+        };
+        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
+                callback, myExecutor, mTestFramework.mCronetEngine);
+
+        TestUploadDataProvider dataProvider = new TestUploadDataProvider(
+                TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
+        // This will never be read, but if the length is 0, read may never be
+        // called.
+        dataProvider.addRead("test".getBytes());
+        builder.setUploadDataProvider(dataProvider, callback.getExecutor());
+        builder.addHeader("Content-Type", "useless/string");
+        builder.build().start();
+        callback.blockForDone();
+
+        assertEquals(1, dataProvider.getNumReadCalls());
+        assertEquals(0, dataProvider.getNumRewindCalls());
+
+        callback.mError.printStackTrace();
+        assertEquals("Exception posting task to executor", callback.mError.getMessage());
+        assertEquals("Inline execution is prohibited for this request",
+                callback.mError.getCause().getMessage());
+        assertEquals(null, callback.mResponseInfo);
+        dataProvider.assertClosed();
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testDirectExecutorAllowed() throws Exception {

[mef, 2016/09/01 15:17:18]

Would it make sense to add a test that canceling request from a callback invoked
on direct executor works as expected?
Also,  it would be useful to verify that CronetEngine.shutdown() from request
completion callback on direct executor throws an exception as expected?

[Charles, 2016/09/01 16:45:24]

Done.

+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        callback.setAllowDirectExecutor(true);
+        Executor myExecutor = new Executor() {
+
+            @Override
+            public void execute(Runnable command) {
+                command.run();
+            }
+        };
+        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
+                callback, myExecutor, mTestFramework.mCronetEngine);
+        UploadDataProvider dataProvider = UploadDataProviders.create("test".getBytes("UTF-8"));
+        builder.setUploadDataProvider(dataProvider, myExecutor);
+        builder.addHeader("Content-Type", "useless/string");
+        builder.allowDirectExecutor();
+        builder.build().start();
+        callback.blockForDone();
+
+        if (callback.mOnErrorCalled) {
+            throw callback.mError;
+        }
+
+        assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
+        assertEquals("test", callback.mResponseAsString);
+    }
+
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadReadFailThrown() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
                 callback, callback.getExecutor(), mTestFramework.mCronetEngine);
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.setReadFailure(0, TestUploadDataProvider.FailMode.THROWN);
@@ skipping 460 matching lines @@
     private String bufferContentsToString(ByteBuffer byteBuffer, int start, int end) {
         // Use a duplicate to avoid modifying byteBuffer.
         ByteBuffer duplicate = byteBuffer.duplicate();
         duplicate.position(start);
         duplicate.limit(end);
         byte[] contents = new byte[duplicate.remaining()];
         duplicate.get(contents);
         return new String(contents);
     }
 }