Allow direct executors in cronet.

components/cronet/android/test/javatests/src/org/chromium/net/TestUrlRequestCallback.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.os.StrictMode;
 
 import static junit.framework.Assert.assertEquals;
@@ skipping 28 matching lines @@
 
     public int mHttpResponseDataLength = 0;
     public String mResponseAsString = "";
 
     private static final int READ_BUFFER_SIZE = 32 * 1024;
 
     // When false, the consumer is responsible for all calls into the request
     // that advance it.
     private boolean mAutoAdvance = true;
 
+    // Whether to permit calls on the network thread.
+    private boolean mAllowDirectExecutor = false;
+
     // Conditionally fail on certain steps.
     private FailureType mFailureType = FailureType.NONE;
     private ResponseStep mFailureStep = ResponseStep.NOTHING;
 
     // Signals when request is done either successfully or not.
     private final ConditionVariable mDone = new ConditionVariable();
 
     // Signaled on each step when mAutoAdvance is false.
     private final ConditionVariable mStepBlock = new ConditionVariable();
 
@@ skipping 42 matching lines @@
         // Same as above, but continues to advance the request after posting
         // the cancellation task.
         CANCEL_ASYNC_WITHOUT_PAUSE,
         THROW_SYNC
     }
 
     public void setAutoAdvance(boolean autoAdvance) {
         mAutoAdvance = autoAdvance;
     }
 
+    public void setAllowDirectExecutor(boolean allowed) {

[mef, 2016/08/30 17:55:47]

maybe instead of setAllowDirectExecutor() use setUseDirectExecutor() and have
checks below verify that callbacks are done on network thread?

[Charles, 2016/08/30 20:11:06]

That wouldn't fly for javaurlrequest, which has a thread pool it uses for
networking operations.

+        mAllowDirectExecutor = allowed;
+    }
+
     public void setFailure(FailureType failureType, ResponseStep failureStep) {
         mFailureStep = failureStep;
         mFailureType = failureType;
     }
 
     public void blockForDone() {
         mDone.block();
     }
 
     public void waitForNextStep() {
@@ skipping 23 matching lines @@
         mRedirectResponseInfoList.add(info);
         ++mRedirectCount;
         if (maybeThrowCancelOrPause(request)) {
             return;
         }
         request.followRedirect();
     }
 
     @Override
     public void onResponseStarted(UrlRequest request, UrlResponseInfo info) {
-        assertEquals(mExecutorThread, Thread.currentThread());
+        if (!mAllowDirectExecutor) {
+            assertEquals(mExecutorThread, Thread.currentThread());
+        }
         assertFalse(request.isDone());
         assertTrue(mResponseStep == ResponseStep.NOTHING
                 || mResponseStep == ResponseStep.ON_RECEIVED_REDIRECT);
         assertNull(mError);
 
         mResponseStep = ResponseStep.ON_RESPONSE_STARTED;
         mResponseInfo = info;
         if (maybeThrowCancelOrPause(request)) {
             return;
         }
         startNextRead(request);
     }
 
     @Override
     public void onReadCompleted(UrlRequest request, UrlResponseInfo info, ByteBuffer byteBuffer) {
-        assertEquals(mExecutorThread, Thread.currentThread());
+        if (!mAllowDirectExecutor) {
+            assertEquals(mExecutorThread, Thread.currentThread());
+        }
         assertFalse(request.isDone());
         assertTrue(mResponseStep == ResponseStep.ON_RESPONSE_STARTED
                 || mResponseStep == ResponseStep.ON_READ_COMPLETED);
         assertNull(mError);
 
         mResponseStep = ResponseStep.ON_READ_COMPLETED;
 
         final byte[] lastDataReceivedAsBytes;
         final int bytesRead = byteBuffer.position() - mBufferPositionBeforeRead;
         mHttpResponseDataLength += bytesRead;
         lastDataReceivedAsBytes = new byte[bytesRead];
         // Rewind |byteBuffer.position()| to pre-read() position.
         byteBuffer.position(mBufferPositionBeforeRead);
         // This restores |byteBuffer.position()| to its value on entrance to
         // this function.
         byteBuffer.get(lastDataReceivedAsBytes);
         mResponseAsString += new String(lastDataReceivedAsBytes);
 
         if (maybeThrowCancelOrPause(request)) {
             return;
         }
         startNextRead(request);
     }
 
     @Override
     public void onSucceeded(UrlRequest request, UrlResponseInfo info) {
-        assertEquals(mExecutorThread, Thread.currentThread());
+        if (!mAllowDirectExecutor) {
+            assertEquals(mExecutorThread, Thread.currentThread());
+        }
         assertTrue(request.isDone());
         assertTrue(mResponseStep == ResponseStep.ON_RESPONSE_STARTED
                 || mResponseStep == ResponseStep.ON_READ_COMPLETED);
         assertFalse(mOnErrorCalled);
         assertFalse(mOnCanceledCalled);
         assertNull(mError);
 
         mResponseStep = ResponseStep.ON_SUCCEEDED;
         mResponseInfo = info;
         openDone();
         maybeThrowCancelOrPause(request);
     }
 
     @Override
     public void onFailed(UrlRequest request, UrlResponseInfo info, UrlRequestException error) {
-        assertEquals(mExecutorThread, Thread.currentThread());
+        // If the failure is because of prohibited direct execution, the test shouldn't fail
+        // since the request already did.
+        if (!mAllowDirectExecutor
+                && !(error.getCause() instanceof InlineExecutionProhibitedException)) {
+            assertEquals(mExecutorThread, Thread.currentThread());
+        }
         assertTrue(request.isDone());
         // Shouldn't happen after success.
         assertTrue(mResponseStep != ResponseStep.ON_SUCCEEDED);
         // Should happen at most once for a single request.
         assertFalse(mOnErrorCalled);
         assertFalse(mOnCanceledCalled);
         assertNull(mError);
         if (mFailureType == FailureType.THROW_SYNC) {
             assertEquals(UrlRequestError.LISTENER_EXCEPTION_THROWN, error.getErrorCode());
             assertEquals(0, error.getCronetInternalErrorCode());
             assertEquals("Exception received from UrlRequest.Callback", error.getMessage());
             assertNotNull(error.getCause());
             assertTrue(error.getCause() instanceof IllegalStateException);
             assertEquals("Listener Exception.", error.getCause().getMessage());
             assertFalse(error.immediatelyRetryable());
         }
 
         mOnErrorCalled = true;
         mError = error;
         openDone();
+        System.out.println("opened");

[mef, 2016/08/30 17:55:47]

nit: remove

[Charles, 2016/08/30 20:11:06]

Done.

         maybeThrowCancelOrPause(request);
     }
 
     @Override
     public void onCanceled(UrlRequest request, UrlResponseInfo info) {
-        assertEquals(mExecutorThread, Thread.currentThread());
+        if (!mAllowDirectExecutor) {
+            assertEquals(mExecutorThread, Thread.currentThread());
+        }
         assertTrue(request.isDone());
         // Should happen at most once for a single request.
         assertFalse(mOnCanceledCalled);
         assertFalse(mOnErrorCalled);
         assertNull(mError);
 
         mOnCanceledCalled = true;
         openDone();
         maybeThrowCancelOrPause(request);
     }
@@ skipping 41 matching lines @@
         };
         if (mFailureType == FailureType.CANCEL_ASYNC
                 || mFailureType == FailureType.CANCEL_ASYNC_WITHOUT_PAUSE) {
             getExecutor().execute(task);
         } else {
             task.run();
         }
         return mFailureType != FailureType.CANCEL_ASYNC_WITHOUT_PAUSE;
     }
 }