Fix flaky tests in CronetUrlRequestContextTest

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;
 import android.os.Looper;
 import android.os.StrictMode;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.chromium.base.FileUtils;
-import org.chromium.base.Log;
 import org.chromium.base.PathUtils;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.TestUrlRequestCallback.ResponseStep;
 import org.chromium.net.impl.CronetLibraryLoader;
 import org.chromium.net.impl.CronetUrlRequestContext;
 import org.chromium.net.test.EmbeddedTestServer;
 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 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;
 
 /**
  * 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 =
             "http://mock.http/success.txt";
-    private static final String TAG = "RequestContextTest";
     private static final int MAX_FILE_SIZE = 1000000000;
     private static final int NUM_EVENT_FILES = 10;
 
     private EmbeddedTestServer mTestServer;
     private String mUrl;
     private String mUrl404;
     private String mUrl500;
-    CronetTestFramework mTestFramework;
 
     // Thread on which network quality listeners should be notified.
     private Thread mNetworkQualityThread;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         mTestServer = EmbeddedTestServer.createAndStartDefaultServer(getContext());
         mUrl = mTestServer.getURL("/echo?status=200");
         mUrl404 = mTestServer.getURL("/echo?status=404");
@@ skipping 29 matching lines @@
                     new UrlRequest.Builder(mUrl, mCallback, mCallback.getExecutor(), cronetEngine);
             urlRequestBuilder.build().start();
             mCallback.blockForDone();
         }
     }
 
     /**
      * Callback that shutdowns the request context when request has succeeded
      * or failed.
      */
-    class ShutdownTestUrlRequestCallback extends TestUrlRequestCallback {
+    static class ShutdownTestUrlRequestCallback extends TestUrlRequestCallback {
+        private final CronetEngine mCronetEngine;
+        private final ConditionVariable mCallbackCompletionBlock = new ConditionVariable();
+
+        ShutdownTestUrlRequestCallback(CronetEngine cronetEngine) {
+            mCronetEngine = cronetEngine;
+        }
+
         @Override
         public void onSucceeded(UrlRequest request, UrlResponseInfo info) {
-            // TODO: Remove logging when http://crbug.com/596929 & http://crbug.com/635025 is fixed.
-            Log.d(TAG, "ShutdownTestUrlRequestCallback.onSucceeded() has started");
             super.onSucceeded(request, info);
-            Log.d(TAG, "ShutdownTestUrlRequestCallback.onSucceeded() before calling shutdown");
-            mTestFramework.mCronetEngine.shutdown();
-            Log.d(TAG, "ShutdownTestUrlRequestCallback.hasFinished() has finished");
+            mCronetEngine.shutdown();
+            mCallbackCompletionBlock.open();
         }
 
         @Override
         public void onFailed(UrlRequest request, UrlResponseInfo info, UrlRequestException error) {
-            // TODO: Remove logging when http://crbug.com/596929 & http://crbug.com/635025 is fixed.
-            Log.d(TAG, "ShutdownTestUrlRequestCallback.onFailed() has started");
             super.onFailed(request, info, error);
-            Log.d(TAG, "ShutdownTestUrlRequestCallback.onFailed() before calling shutdown");
-            mTestFramework.mCronetEngine.shutdown();
-            Log.d(TAG, "ShutdownTestUrlRequestCallback.onFailed() has finished.");
+            mCronetEngine.shutdown();
+            mCallbackCompletionBlock.open();
+        }
+
+        void blockForCallbackToComplete() {
+            // Wait for request completion callback.

[pauljensen, 2016/08/18 16:39:55]

move this comment up a line

[kapishnikov, 2016/08/18 16:55:06]

Done.

+            mCallbackCompletionBlock.block();
         }
     }
 
     static class TestExecutor implements Executor {
         private final LinkedList<Runnable> mTaskQueue = new LinkedList<Runnable>();
 
         @Override
         public void execute(Runnable task) {
             mTaskQueue.add(task);
         }
@@ skipping 35 matching lines @@
     @SuppressWarnings("deprecation")
     public void testConfigUserAgent() throws Exception {
         String userAgentName = "User-Agent";
         String userAgentValue = "User-Agent-Value";
         CronetEngine.Builder cronetEngineBuilder = new CronetEngine.Builder(getContext());
         if (testingJavaImpl()) {
             cronetEngineBuilder.enableLegacyMode(true);
         }
         cronetEngineBuilder.setUserAgent(userAgentValue);
         cronetEngineBuilder.setLibraryName("cronet_tests");
-        mTestFramework =
+        final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCronetEngineBuilder(mUrl, cronetEngineBuilder);
         NativeTestServer.shutdownNativeTestServer(); // startNativeTestServer returns false if it's
         // already running
         assertTrue(NativeTestServer.startNativeTestServer(getContext()));
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
                 new UrlRequest.Builder(NativeTestServer.getEchoHeaderURL(userAgentName), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                        callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(userAgentValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testDataReductionProxyEnabled() throws Exception {
-        mTestFramework = startCronetTestFrameworkAndSkipLibraryInit();
+        final CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
 
         // Ensure native code is loaded before trying to start test server.
         new CronetEngine.Builder(getContext()).setLibraryName("cronet_tests").build().shutdown();
 
         assertTrue(NativeTestServer.startNativeTestServer(getContext()));
         if (!NativeTestServer.isDataReductionProxySupported()) {
             return;
         }
         String serverHostPort = NativeTestServer.getHostPort();
 
         // Enable the Data Reduction Proxy and configure it to use the test
         // server as its primary proxy, and to check successfully that this
         // proxy is OK to use.
         CronetEngine.Builder cronetEngineBuilder = new CronetEngine.Builder(getContext());
         cronetEngineBuilder.enableDataReductionProxy("test-key");
         cronetEngineBuilder.setDataReductionProxyOptions(serverHostPort, "unused.net:9999",
                 NativeTestServer.getFileURL("/secureproxychecksuccess.txt"));
         cronetEngineBuilder.setLibraryName("cronet_tests");
-        mTestFramework.mCronetEngine = cronetEngineBuilder.build();
+        testFramework.mCronetEngine = cronetEngineBuilder.build();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
 
         // Construct and start a request that can only be returned by the test
         // server. This request will fail if the configuration logic for the
         // Data Reduction Proxy is not used.
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
                 "http://DomainThatDoesnt.Resolve/datareductionproxysuccess.txt", callback,
-                callback.getExecutor(), mTestFramework.mCronetEngine);
+                callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
 
         // Verify that the request is successful and that the Data Reduction
         // Proxy logic configured to use the test server as its proxy.
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(serverHostPort, callback.mResponseInfo.getProxyServer());
         assertEquals("http://DomainThatDoesnt.Resolve/datareductionproxysuccess.txt",
                 callback.mResponseInfo.getUrl());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testRealTimeNetworkQualityObservationsNotEnabled() throws Exception {
         CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
-        mTestFramework =
+        final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
         Executor networkQualityExecutor = Executors.newSingleThreadExecutor();
         TestNetworkQualityRttListener rttListener =
                 new TestNetworkQualityRttListener(networkQualityExecutor);
         TestNetworkQualityThroughputListener throughputListener =
                 new TestNetworkQualityThroughputListener(networkQualityExecutor, null);
         try {
-            mTestFramework.mCronetEngine.addRttListener(rttListener);
+            testFramework.mCronetEngine.addRttListener(rttListener);
             fail("Should throw an exception.");
         } catch (IllegalStateException e) {
         }
         try {
-            mTestFramework.mCronetEngine.addThroughputListener(throughputListener);
+            testFramework.mCronetEngine.addThroughputListener(throughputListener);
             fail("Should throw an exception.");
         } catch (IllegalStateException e) {
         }
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder builder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         UrlRequest urlRequest = builder.build();
 
         urlRequest.start();
         callback.blockForDone();
         assertEquals(0, rttListener.rttObservationCount());
         assertEquals(0, throughputListener.throughputObservationCount());
-        mTestFramework.mCronetEngine.shutdown();
+        testFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testRealTimeNetworkQualityObservationsListenerRemoved() throws Exception {
         CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
         TestExecutor networkQualityExecutor = new TestExecutor();
         TestNetworkQualityRttListener rttListener =
                 new TestNetworkQualityRttListener(networkQualityExecutor);
         mCronetEngineBuilder.enableNetworkQualityEstimator(true);
-        mTestFramework =
+        final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
-        mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
+        testFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
 
-        mTestFramework.mCronetEngine.addRttListener(rttListener);
-        mTestFramework.mCronetEngine.removeRttListener(rttListener);
+        testFramework.mCronetEngine.addRttListener(rttListener);
+        testFramework.mCronetEngine.removeRttListener(rttListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder builder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.blockForDone();
         networkQualityExecutor.runAllTasks();
         assertEquals(0, rttListener.rttObservationCount());
-        mTestFramework.mCronetEngine.shutdown();
+        testFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testRealTimeNetworkQualityObservationsQuicDisabled() throws Exception {
         CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
         Executor listenersExecutor = Executors.newSingleThreadExecutor(new ExecutorThreadFactory());
         ConditionVariable waitForThroughput = new ConditionVariable();
         TestNetworkQualityRttListener rttListener =
                 new TestNetworkQualityRttListener(listenersExecutor);
         TestNetworkQualityThroughputListener throughputListener =
                 new TestNetworkQualityThroughputListener(listenersExecutor, waitForThroughput);
         mCronetEngineBuilder.enableHttp2(true).enableQuic(false).enableNetworkQualityEstimator(
                 true);
-        mTestFramework =
+        final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
-        mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
+        testFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
 
-        mTestFramework.mCronetEngine.addRttListener(rttListener);
-        mTestFramework.mCronetEngine.addThroughputListener(throughputListener);
+        testFramework.mCronetEngine.addRttListener(rttListener);
+        testFramework.mCronetEngine.addThroughputListener(throughputListener);
 
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder builder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.blockForDone();
 
         // Throughput observation is posted to the network quality estimator on the network thread
         // after the UrlRequest is completed. The observations are then eventually posted to
         // throughput listeners on the executor provided to network quality.
         waitForThroughput.block();
         assertTrue(throughputListener.throughputObservationCount() > 0);
 
         // Check RTT observation count after throughput observation has been received. This ensures
         // that executor has finished posting the RTT observation to the RTT listeners.
         assertTrue(rttListener.rttObservationCount() > 0);
 
         // NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST
         assertTrue(rttListener.rttObservationCount(0) > 0);
 
         // NETWORK_QUALITY_OBSERVATION_SOURCE_TCP
         assertTrue(rttListener.rttObservationCount(1) > 0);
 
         // NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC
         assertEquals(0, rttListener.rttObservationCount(2));
 
         // Verify that the listeners were notified on the expected thread.
         assertEquals(mNetworkQualityThread, rttListener.getThread());
         assertEquals(mNetworkQualityThread, throughputListener.getThread());
 
         // Verify that effective connection type callback is received and
         // effective connection type is correctly set.
-        assertTrue(mTestFramework.mCronetEngine.getEffectiveConnectionType()
+        assertTrue(testFramework.mCronetEngine.getEffectiveConnectionType()
                 != EffectiveConnectionType.EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
 
-        mTestFramework.mCronetEngine.shutdown();
+        testFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     // TODO: Remove the annotation after fixing http://crbug.com/637979 & http://crbug.com/637972
     @OnlyRunNativeCronet
     public void testShutdown() throws Exception {
-        Log.i(TAG, "testShutdown() has started");
-        mTestFramework = startCronetTestFramework();
-        TestUrlRequestCallback callback = new ShutdownTestUrlRequestCallback();
+        final CronetTestFramework testFramework = startCronetTestFramework();
+        ShutdownTestUrlRequestCallback callback =
+                new ShutdownTestUrlRequestCallback(testFramework.mCronetEngine);
         // Block callback when response starts to verify that shutdown fails
         // if there are active requests.
         callback.setAutoAdvance(false);
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         UrlRequest urlRequest = urlRequestBuilder.build();
         urlRequest.start();
         try {
-            mTestFramework.mCronetEngine.shutdown();
+            testFramework.mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Cannot shutdown with active requests.",
                          e.getMessage());
         }
 
         callback.waitForNextStep();
         assertEquals(ResponseStep.ON_RESPONSE_STARTED, callback.mResponseStep);
         try {
-            mTestFramework.mCronetEngine.shutdown();
+            testFramework.mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Cannot shutdown with active requests.",
                          e.getMessage());
         }
         callback.startNextRead(urlRequest);
 
         callback.waitForNextStep();
         assertEquals(ResponseStep.ON_READ_COMPLETED, callback.mResponseStep);
         try {
-            mTestFramework.mCronetEngine.shutdown();
+            testFramework.mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Cannot shutdown with active requests.",
                          e.getMessage());
         }
 
         // May not have read all the data, in theory. Just enable auto-advance
         // and finish the request.
         callback.setAutoAdvance(true);
         callback.startNextRead(urlRequest);
         callback.blockForDone();
-        // TODO: Remove sleep when http://crbug.com/596929 is fixed.
-        // The sleep gives the thread that shuts down the engine time to complete.
-        // See http://crbug.com/596929
-        Thread.sleep(3000);
-        Log.i(TAG, "testShutdown() has finished");
+        callback.blockForCallbackToComplete();
+        callback.shutdownExecutor();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testShutdownDuringInit() throws Exception {
         final CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
         final ConditionVariable block = new ConditionVariable(false);
 
         // Post a task to main thread to block until shutdown is called to test
@@ skipping 58 matching lines @@
             }
         };
         new Handler(Looper.getMainLooper()).post(blockingTask);
         // Wait for shutdown to complete on main thread.
         block.block();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testMultipleShutdown() throws Exception {
-        mTestFramework = startCronetTestFramework();
+        final CronetTestFramework testFramework = startCronetTestFramework();
         try {
-            mTestFramework.mCronetEngine.shutdown();
-            mTestFramework.mCronetEngine.shutdown();
+            testFramework.mCronetEngine.shutdown();
+            testFramework.mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Engine is shut down.", e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     // TODO: Remove the annotation after fixing http://crbug.com/637972
     @OnlyRunNativeCronet
     public void testShutdownAfterError() throws Exception {
-        Log.i(TAG, "testShutdownAfterError() has started");
-        mTestFramework = startCronetTestFramework();
-        TestUrlRequestCallback callback = new ShutdownTestUrlRequestCallback();
+        final CronetTestFramework testFramework = startCronetTestFramework();
+        ShutdownTestUrlRequestCallback callback =
+                new ShutdownTestUrlRequestCallback(testFramework.mCronetEngine);
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(MOCK_CRONET_TEST_FAILED_URL,
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertTrue(callback.mOnErrorCalled);
-        // TODO: Remove sleep when http://crbug.com/635025 is fixed.
-        // The sleep gives the thread that shuts down the engine time to complete.
-        // See http://crbug.com/637986
-        Thread.sleep(3000);
-        Log.i(TAG, "testShutdownAfterError() has finished");
+        callback.blockForCallbackToComplete();
+        callback.shutdownExecutor();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testShutdownAfterCancel() throws Exception {
-        mTestFramework = startCronetTestFramework();
+        final CronetTestFramework testFramework = startCronetTestFramework();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         // Block callback when response starts to verify that shutdown fails
         // if there are active requests.
         callback.setAutoAdvance(false);
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         UrlRequest urlRequest = urlRequestBuilder.build();
         urlRequest.start();
         try {
-            mTestFramework.mCronetEngine.shutdown();
+            testFramework.mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Cannot shutdown with active requests.",
                          e.getMessage());
         }
         callback.waitForNextStep();
         assertEquals(ResponseStep.ON_RESPONSE_STARTED, callback.mResponseStep);
         urlRequest.cancel();
-        mTestFramework.mCronetEngine.shutdown();
+        testFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet // No netlogs for pure java impl
     public void testNetLog() throws Exception {
         Context context = getContext();
         File directory = new File(PathUtils.getDataDirectory(context));
         File file = File.createTempFile("cronet", "json", directory);
         CronetEngine cronetEngine = new CronetUrlRequestContext(
@@ skipping 204 matching lines @@
         FileUtils.recursivelyDeleteFile(netLogDir2);
         assertFalse(netLogDir2.exists());
     }
 
     @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 {
-        enableCache(CronetEngine.Builder.HTTP_CACHE_DISK);
+        final CronetTestFramework testFramework =
+                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
         // Make a request to a cacheable resource.
-        checkRequestCaching(url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
 
         // 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.
-                mTestFramework.mCronetEngine.shutdown();
+                testFramework.mCronetEngine.shutdown();
             }
 
             @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");
             }
         }
         CancelUrlRequestCallback callback = new CancelUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                url, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                url, callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertTrue(callback.mResponseInfo.wasCached());
         assertTrue(callback.mOnCanceledCalled);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testNetLogAfterShutdown() throws Exception {
-        mTestFramework = startCronetTestFramework();
+        final CronetTestFramework testFramework = startCronetTestFramework();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
-        mTestFramework.mCronetEngine.shutdown();
+        testFramework.mCronetEngine.shutdown();
 
         File directory = new File(PathUtils.getDataDirectory(getContext()));
         File file = File.createTempFile("cronet", "json", directory);
         try {
-            mTestFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
+            testFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
             fail("Should throw an exception.");
         } catch (Exception e) {
             assertEquals("Engine is shut down.", e.getMessage());
         }
         assertFalse(hasBytesInNetLog(file));
         assertTrue(file.delete());
         assertTrue(!file.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testBoundedFileNetLogAfterShutdown() throws Exception {
-        mTestFramework = startCronetTestFramework();
+        final CronetTestFramework testFramework = startCronetTestFramework();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
-        mTestFramework.mCronetEngine.shutdown();
+        testFramework.mCronetEngine.shutdown();
 
         File directory = new File(PathUtils.getDataDirectory(getContext()));
         File netLogDir = new File(directory, "NetLog");
         assertFalse(netLogDir.exists());
         assertTrue(netLogDir.mkdir());
         File constantsFile = new File(netLogDir, "constants.json");
         try {
-            mTestFramework.mCronetEngine.startNetLogToDisk(
+            testFramework.mCronetEngine.startNetLogToDisk(
                     netLogDir.getPath(), false, MAX_FILE_SIZE);
             fail("Should throw an exception.");
         } catch (Exception e) {
             assertEquals("Engine is shut down.", e.getMessage());
         }
         assertFalse(constantsFile.exists());
         FileUtils.recursivelyDeleteFile(netLogDir);
         assertFalse(netLogDir.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testNetLogStartMultipleTimes() throws Exception {
-        mTestFramework = startCronetTestFramework();
+        final CronetTestFramework testFramework = startCronetTestFramework();
         File directory = new File(PathUtils.getDataDirectory(getContext()));
         File file = File.createTempFile("cronet", "json", directory);
         // Start NetLog multiple times.
-        mTestFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
-        mTestFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
-        mTestFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
-        mTestFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
+        testFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
+        testFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
+        testFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
+        testFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
-        mTestFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
         assertTrue(file.exists());
         assertTrue(file.length() != 0);
         assertFalse(hasBytesInNetLog(file));
         assertTrue(file.delete());
         assertTrue(!file.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testBoundedFileNetLogStartMultipleTimes() throws Exception {
-        mTestFramework = startCronetTestFramework();
+        final CronetTestFramework testFramework = startCronetTestFramework();
         File directory = new File(PathUtils.getDataDirectory(getContext()));
         File netLogDir = new File(directory, "NetLog");
         assertFalse(netLogDir.exists());
         assertTrue(netLogDir.mkdir());
         File eventFile = new File(netLogDir, "event_file_0.json");
         // Start NetLog multiple times. This should be equivalent to starting NetLog
         // once. Each subsequent start (without calling stopNetLog) should be a no-op.
-        mTestFramework.mCronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
-        mTestFramework.mCronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
-        mTestFramework.mCronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
-        mTestFramework.mCronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
+        testFramework.mCronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
+        testFramework.mCronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
+        testFramework.mCronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
+        testFramework.mCronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
-        mTestFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
         assertTrue(eventFile.exists());
         assertTrue(eventFile.length() != 0);
         assertFalse(hasBytesInNetLog(eventFile));
         FileUtils.recursivelyDeleteFile(netLogDir);
         assertFalse(netLogDir.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testNetLogStopMultipleTimes() throws Exception {
-        mTestFramework = startCronetTestFramework();
+        final CronetTestFramework testFramework = startCronetTestFramework();
         File directory = new File(PathUtils.getDataDirectory(getContext()));
         File file = File.createTempFile("cronet", "json", directory);
-        mTestFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
+        testFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
         // Stop NetLog multiple times.
-        mTestFramework.mCronetEngine.stopNetLog();
-        mTestFramework.mCronetEngine.stopNetLog();
-        mTestFramework.mCronetEngine.stopNetLog();
-        mTestFramework.mCronetEngine.stopNetLog();
-        mTestFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
         assertTrue(file.exists());
         assertTrue(file.length() != 0);
         assertFalse(hasBytesInNetLog(file));
         assertTrue(file.delete());
         assertTrue(!file.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testBoundedFileNetLogStopMultipleTimes() throws Exception {
-        mTestFramework = startCronetTestFramework();
+        final CronetTestFramework testFramework = startCronetTestFramework();
         File directory = new File(PathUtils.getDataDirectory(getContext()));
         File netLogDir = new File(directory, "NetLog");
         assertFalse(netLogDir.exists());
         assertTrue(netLogDir.mkdir());
         File eventFile = new File(netLogDir, "event_file_0.json");
-        mTestFramework.mCronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
+        testFramework.mCronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
         // Stop NetLog multiple times. This should be equivalent to stopping NetLog once.
         // Each subsequent stop (without calling startNetLogToDisk first) should be a no-op.
-        mTestFramework.mCronetEngine.stopNetLog();
-        mTestFramework.mCronetEngine.stopNetLog();
-        mTestFramework.mCronetEngine.stopNetLog();
-        mTestFramework.mCronetEngine.stopNetLog();
-        mTestFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
+        testFramework.mCronetEngine.stopNetLog();
         assertTrue(eventFile.exists());
         assertTrue(eventFile.length() != 0);
         assertFalse(hasBytesInNetLog(eventFile));
         FileUtils.recursivelyDeleteFile(netLogDir);
         assertFalse(netLogDir.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
@@ skipping 74 matching lines @@
     private void makeRequestAndCheckStatus(
             CronetEngine engine, String url, int expectedStatusCode) {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest request =
                 new UrlRequest.Builder(url, callback, callback.getExecutor(), engine).build();
         request.start();
         callback.blockForDone();
         assertEquals(expectedStatusCode, callback.mResponseInfo.getHttpStatusCode());
     }
 
-    private void enableCache(int cacheType) throws Exception {
+    private CronetTestFramework startCronetTestFrameworkWithCacheEnabled(int cacheType)
+            throws Exception {
         String cacheTypeString = "";
         if (cacheType == CronetEngine.Builder.HTTP_CACHE_DISK) {
             cacheTypeString = CronetTestFramework.CACHE_DISK;
         } else if (cacheType == CronetEngine.Builder.HTTP_CACHE_DISK_NO_HTTP) {
             cacheTypeString = CronetTestFramework.CACHE_DISK_NO_HTTP;
         } else if (cacheType == CronetEngine.Builder.HTTP_CACHE_IN_MEMORY) {
             cacheTypeString = CronetTestFramework.CACHE_IN_MEMORY;
         }
         String[] commandLineArgs = {CronetTestFramework.CACHE_KEY, cacheTypeString};
-        mTestFramework = startCronetTestFrameworkWithUrlAndCommandLineArgs(null, commandLineArgs);
+        CronetTestFramework testFramework =
+                startCronetTestFrameworkWithUrlAndCommandLineArgs(null, commandLineArgs);
         assertTrue(NativeTestServer.startNativeTestServer(getContext()));
+        return testFramework;
     }
 
-    private void checkRequestCaching(String url, boolean expectCached) {
-        checkRequestCaching(url, expectCached, false);
+    private void checkRequestCaching(CronetEngine engine, String url, boolean expectCached) {
+        checkRequestCaching(engine, url, expectCached, false);
     }
 
-    private void checkRequestCaching(String url, boolean expectCached,
-            boolean disableCache) {
+    private void checkRequestCaching(
+            CronetEngine engine, String url, boolean expectCached, boolean disableCache) {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                url, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder =
+                new UrlRequest.Builder(url, callback, callback.getExecutor(), engine);
         if (disableCache) {
             urlRequestBuilder.disableCache();
         }
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(expectCached, callback.mResponseInfo.wasCached());
         assertEquals("this is a cacheable file\n", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEnableHttpCacheDisabled() throws Exception {
-        enableCache(CronetEngine.Builder.HTTP_CACHE_DISABLED);
+        final CronetTestFramework testFramework =
+                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISABLED);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
-        checkRequestCaching(url, false);
-        checkRequestCaching(url, false);
-        checkRequestCaching(url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testEnableHttpCacheInMemory() throws Exception {
-        enableCache(CronetEngine.Builder.HTTP_CACHE_IN_MEMORY);
+        final CronetTestFramework testFramework =
+                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_IN_MEMORY);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
-        checkRequestCaching(url, false);
-        checkRequestCaching(url, true);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, true);
         NativeTestServer.shutdownNativeTestServer();
-        checkRequestCaching(url, true);
+        checkRequestCaching(testFramework.mCronetEngine, url, true);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testEnableHttpCacheDisk() throws Exception {
-        enableCache(CronetEngine.Builder.HTTP_CACHE_DISK);
+        final CronetTestFramework testFramework =
+                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
-        checkRequestCaching(url, false);
-        checkRequestCaching(url, true);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, true);
         NativeTestServer.shutdownNativeTestServer();
-        checkRequestCaching(url, true);
+        checkRequestCaching(testFramework.mCronetEngine, url, true);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEnableHttpCacheDiskNoHttp() throws Exception {
-        enableCache(CronetEngine.Builder.HTTP_CACHE_DISABLED);
+        final CronetTestFramework testFramework =
+                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISABLED);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
-        checkRequestCaching(url, false);
-        checkRequestCaching(url, false);
-        checkRequestCaching(url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testDisableCache() throws Exception {
-        enableCache(CronetEngine.Builder.HTTP_CACHE_DISK);
+        final CronetTestFramework testFramework =
+                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
 
         // When cache is disabled, making a request does not write to the cache.
-        checkRequestCaching(url, false, true /** disable cache */);
-        checkRequestCaching(url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, false, true /** disable cache */);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
 
         // When cache is enabled, the second request is cached.
-        checkRequestCaching(url, false, true /** disable cache */);
-        checkRequestCaching(url, true);
+        checkRequestCaching(testFramework.mCronetEngine, url, false, true /** disable cache */);
+        checkRequestCaching(testFramework.mCronetEngine, url, true);
 
         // Shut down the server, next request should have a cached response.
         NativeTestServer.shutdownNativeTestServer();
-        checkRequestCaching(url, true);
+        checkRequestCaching(testFramework.mCronetEngine, url, true);
 
         // Cache is disabled after server is shut down, request should fail.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                url, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                url, callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.disableCache();
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertNotNull(callback.mError);
         assertEquals("Exception in CronetUrlRequest: net::ERR_CONNECTION_REFUSED",
                 callback.mError.getMessage());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testEnableHttpCacheDiskNewEngine() throws Exception {
-        enableCache(CronetEngine.Builder.HTTP_CACHE_DISK);
+        final CronetTestFramework testFramework =
+                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
-        checkRequestCaching(url, false);
-        checkRequestCaching(url, true);
+        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(testFramework.mCronetEngine, url, true);
         NativeTestServer.shutdownNativeTestServer();
-        checkRequestCaching(url, true);
+        checkRequestCaching(testFramework.mCronetEngine, url, true);
 
         // Shutdown original context and create another that uses the same cache.
-        mTestFramework.mCronetEngine.shutdown();
-        mTestFramework.mCronetEngine = mTestFramework.getCronetEngineBuilder().build();
-        checkRequestCaching(url, true);
+        testFramework.mCronetEngine.shutdown();
+        testFramework.mCronetEngine = testFramework.getCronetEngineBuilder().build();
+        checkRequestCaching(testFramework.mCronetEngine, url, true);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testInitEngineAndStartRequest() {
         CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
 
         // Immediately make a request after initializing the engine.
         CronetEngine cronetEngine = testFramework.initCronetEngine();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
@@ skipping 85 matching lines @@
         assertEquals(200, thread1.mCallback.mResponseInfo.getHttpStatusCode());
         assertEquals(404, thread2.mCallback.mResponseInfo.getHttpStatusCode());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testInitDifferentEngines() throws Exception {
         // Test that concurrently instantiating Cronet context's upon various
         // different versions of the same Android Context does not cause crashes
         // like crbug.com/453845
-        mTestFramework = startCronetTestFramework();
+        final CronetTestFramework testFramework = startCronetTestFramework();
         CronetEngine firstEngine =
-                new CronetUrlRequestContext(mTestFramework.createCronetEngineBuilder(getContext()));
+                new CronetUrlRequestContext(testFramework.createCronetEngineBuilder(getContext()));
         CronetEngine secondEngine = new CronetUrlRequestContext(
-                mTestFramework.createCronetEngineBuilder(getContext().getApplicationContext()));
+                testFramework.createCronetEngineBuilder(getContext().getApplicationContext()));
         CronetEngine thirdEngine = new CronetUrlRequestContext(
-                mTestFramework.createCronetEngineBuilder(new ContextWrapper(getContext())));
+                testFramework.createCronetEngineBuilder(new ContextWrapper(getContext())));
         firstEngine.shutdown();
         secondEngine.shutdown();
         thirdEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testGetGlobalMetricsDeltas() throws Exception {
-        mTestFramework = startCronetTestFramework();
+        final CronetTestFramework testFramework = startCronetTestFramework();
 
-        byte delta1[] = mTestFramework.mCronetEngine.getGlobalMetricsDeltas();
+        byte delta1[] = testFramework.mCronetEngine.getGlobalMetricsDeltas();
 
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder builder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
         builder.build().start();
         callback.blockForDone();
-        byte delta2[] = mTestFramework.mCronetEngine.getGlobalMetricsDeltas();
+        byte delta2[] = testFramework.mCronetEngine.getGlobalMetricsDeltas();
         assertTrue(delta2.length != 0);
         assertFalse(Arrays.equals(delta1, delta2));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testCronetEngineBuilderConfig() throws Exception {
         // This is to prompt load of native library.
         startCronetTestFramework();
         // Verify CronetEngine.Builder config is passed down accurately to native code.
@@ skipping 68 matching lines @@
                     }
                 }.start();
                 otherThreadDone.block();
                 builder.build().shutdown();
                 uiThreadDone.open();
             }
         });
         assertTrue(uiThreadDone.block(1000));
     }
 }