Allow direct executors in cronet.

components/cronet/android/test/javatests/src/org/chromium/net/CronetUrlRequestContextTest.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.content.Context;
 import android.content.ContextWrapper;
 import android.os.ConditionVariable;
 import android.os.Handler;
@@ skipping 14 matching lines @@
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.net.URL;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.NoSuchElementException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * Test CronetEngine.
  */
 @JNINamespace("cronet")
 public class CronetUrlRequestContextTest extends CronetTestBase {
     // URLs used for tests.
     private static final String MOCK_CRONET_TEST_FAILED_URL =
             "http://mock.failed.request/-2";
     private static final String MOCK_CRONET_TEST_SUCCESS_URL =
@@ skipping 695 matching lines @@
         assertTrue(containsStringInNetLog(eventFile1, mUrl404));
         assertTrue(containsStringInNetLog(eventFile1, mUrl500));
         assertTrue(containsStringInNetLog(eventFile2, mUrl404));
         assertTrue(containsStringInNetLog(eventFile2, mUrl500));
 
         FileUtils.recursivelyDeleteFile(netLogDir1);
         assertFalse(netLogDir1.exists());
         FileUtils.recursivelyDeleteFile(netLogDir2);
         assertFalse(netLogDir2.exists());
     }
+    @SmallTest
+    @Feature({"Cronet"})
+    @OnlyRunNativeCronet
+    // Tests that if CronetEngine is shut down on the network thread, an appropriate exception
+    // is thrown.
+    public void testShutDownEngineOnNetworkThread() throws Exception {
+        final CronetTestFramework testFramework =
+                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
+        String url = NativeTestServer.getFileURL("/cacheable.txt");
+        // Make a request to a cacheable resource.
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
+
+        final AtomicReference<Throwable> thrown = new AtomicReference<>();
+        // Shut down the server.
+        NativeTestServer.shutdownNativeTestServer();
+        class CancelUrlRequestCallback extends TestUrlRequestCallback {
+            @Override
+            public void onResponseStarted(UrlRequest request, UrlResponseInfo info) {
+                super.onResponseStarted(request, info);
+                request.cancel();
+                // Shut down CronetEngine immediately after request is destroyed.
+                try {
+                    testFramework.mCronetEngine.shutdown();
+                } catch (Exception e) {
+                    thrown.set(e);
+                }
+            }
+
+            @Override
+            public void onSucceeded(UrlRequest request, UrlResponseInfo info) {
+                // onSucceeded will not happen, because the request is canceled
+                // after sending first read and the executor is single threaded.
+                throw new RuntimeException("Unexpected");
+            }
+
+            @Override
+            public void onFailed(
+                    UrlRequest request, UrlResponseInfo info, UrlRequestException error) {
+                throw new RuntimeException("Unexpected");
+            }
+        }
+        Executor directExecutor = new Executor() {
+            @Override
+            public void execute(Runnable command) {
+                command.run();
+            }
+        };
+        CancelUrlRequestCallback callback = new CancelUrlRequestCallback();
+        callback.setAllowDirectExecutor(true);
+        UrlRequest.Builder urlRequestBuilder =
+                new UrlRequest.Builder(url, callback, directExecutor, testFramework.mCronetEngine);
+        urlRequestBuilder.allowDirectExecutor();
+        urlRequestBuilder.build().start();
+        callback.blockForDone();
+        assertTrue(thrown.get() instanceof RuntimeException);
+    }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     // Tests that if CronetEngine is shut down when reading from disk cache,
     // there isn't a crash. See crbug.com/486120.
     public void testShutDownEngineWhenReadingFromDiskCache() throws Exception {
         final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
@@ skipping 649 matching lines @@
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         URL requestUrl =
                 new URL("http", resolverTestHostname, testUrl.getPort(), testUrl.getFile());
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(requestUrl.toString(),
                 callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
     }
 }