Cronet API Refactoring

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.json.JSONObject;
 
+import static org.chromium.net.CronetEngine.Builder.HTTP_CACHE_IN_MEMORY;
+
 import org.chromium.base.FileUtils;
 import org.chromium.base.PathUtils;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.MetricsTestUtil.TestExecutor;
 import org.chromium.net.TestUrlRequestCallback.ResponseStep;
+import org.chromium.net.impl.CronetEngineBase;
+import org.chromium.net.impl.CronetEngineBuilderImpl;
 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.net.URL;
 import java.util.Arrays;
 import java.util.concurrent.Executor;
@@ skipping 50 matching lines @@
             mUrl = url;
             mRunBlocker = runBlocker;
         }
 
         @Override
         public void run() {
             mRunBlocker.block();
             CronetEngine cronetEngine = mTestFramework.initCronetEngine();
             mCallback = new TestUrlRequestCallback();
             UrlRequest.Builder urlRequestBuilder =
-                    new UrlRequest.Builder(mUrl, mCallback, mCallback.getExecutor(), cronetEngine);
+                    cronetEngine.newUrlRequestBuilder(mUrl, mCallback, mCallback.getExecutor());
             urlRequestBuilder.build().start();
             mCallback.blockForDone();
         }
     }
 
     /**
      * Callback that shutdowns the request context when request has succeeded
      * or failed.
      */
     static class ShutdownTestUrlRequestCallback extends TestUrlRequestCallback {
@@ skipping 45 matching lines @@
             return mNetworkQualityThread;
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @SuppressWarnings("deprecation")
     public void testConfigUserAgent() throws Exception {
         String userAgentName = "User-Agent";
         String userAgentValue = "User-Agent-Value";
-        CronetEngine.Builder cronetEngineBuilder = new CronetEngine.Builder(getContext());
+        ExperimentalCronetEngine.Builder cronetEngineBuilder =
+                new ExperimentalCronetEngine.Builder(getContext());
         if (testingJavaImpl()) {
             cronetEngineBuilder.enableLegacyMode(true);
         }
         cronetEngineBuilder.setUserAgent(userAgentValue);
-        cronetEngineBuilder.setLibraryName("cronet_tests");
+        CronetTestUtil.setLibraryName(cronetEngineBuilder, "cronet_tests");
         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(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoHeaderURL(userAgentName), callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(userAgentValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testDataReductionProxyEnabled() throws Exception {
         final CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
 
         // Ensure native code is loaded before trying to start test server.
-        new CronetEngine.Builder(getContext()).setLibraryName("cronet_tests").build().shutdown();
+        ExperimentalCronetEngine.Builder engineBuilder =
+                new ExperimentalCronetEngine.Builder(getContext());
+        CronetTestUtil.setLibraryName(engineBuilder, "cronet_tests");
+        engineBuilder.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());
+        ExperimentalCronetEngine.Builder cronetEngineBuilder =
+                new ExperimentalCronetEngine.Builder(getContext());
         cronetEngineBuilder.enableDataReductionProxy("test-key");
         cronetEngineBuilder.setDataReductionProxyOptions(serverHostPort, "unused.net:9999",
                 NativeTestServer.getFileURL("/secureproxychecksuccess.txt"));
-        cronetEngineBuilder.setLibraryName("cronet_tests");
-        testFramework.mCronetEngine = cronetEngineBuilder.build();
+        CronetTestUtil.setLibraryName(cronetEngineBuilder, "cronet_tests");
+        testFramework.mCronetEngine = (CronetEngineBase) 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(
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
                 "http://DomainThatDoesnt.Resolve/datareductionproxysuccess.txt", callback,
-                callback.getExecutor(), testFramework.mCronetEngine);
+                callback.getExecutor());
         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());
+        ExperimentalCronetEngine.Builder mCronetEngineBuilder =
+                new ExperimentalCronetEngine.Builder(getContext());
         final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
         Executor networkQualityExecutor = Executors.newSingleThreadExecutor();
         TestNetworkQualityRttListener rttListener =
                 new TestNetworkQualityRttListener(networkQualityExecutor);
         TestNetworkQualityThroughputListener throughputListener =
                 new TestNetworkQualityThroughputListener(networkQualityExecutor, null);
         try {
             testFramework.mCronetEngine.addRttListener(rttListener);
             fail("Should throw an exception.");
         } catch (IllegalStateException e) {
         }
         try {
             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(), testFramework.mCronetEngine);
+        UrlRequest.Builder builder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         UrlRequest urlRequest = builder.build();
 
         urlRequest.start();
         callback.blockForDone();
         assertEquals(0, rttListener.rttObservationCount());
         assertEquals(0, throughputListener.throughputObservationCount());
         testFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testRealTimeNetworkQualityObservationsListenerRemoved() throws Exception {
-        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        ExperimentalCronetEngine.Builder mCronetEngineBuilder =
+                new ExperimentalCronetEngine.Builder(getContext());
         TestExecutor networkQualityExecutor = new TestExecutor();
         TestNetworkQualityRttListener rttListener =
                 new TestNetworkQualityRttListener(networkQualityExecutor);
         mCronetEngineBuilder.enableNetworkQualityEstimator(true);
         final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
         testFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
 
         testFramework.mCronetEngine.addRttListener(rttListener);
         testFramework.mCronetEngine.removeRttListener(rttListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
+        UrlRequest.Builder builder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.blockForDone();
         networkQualityExecutor.runAllTasks();
         assertEquals(0, rttListener.rttObservationCount());
         testFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testRealTimeNetworkQualityObservationsQuicDisabled() throws Exception {
-        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        ExperimentalCronetEngine.Builder mCronetEngineBuilder =
+                new ExperimentalCronetEngine.Builder(getContext());
         assert RttThroughputValues.INVALID_RTT_THROUGHPUT < 0;
-
         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);
+        mCronetEngineBuilder.enableNetworkQualityEstimator(true).enableHttp2(true).enableQuic(
+                false);
         final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
         testFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
 
         testFramework.mCronetEngine.addRttListener(rttListener);
         testFramework.mCronetEngine.addThroughputListener(throughputListener);
 
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
+        UrlRequest.Builder builder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         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);
 
@@ skipping 42 matching lines @@
     @Feature({"Cronet"})
     // TODO: Remove the annotation after fixing http://crbug.com/637979 & http://crbug.com/637972
     @OnlyRunNativeCronet
     public void testShutdown() throws Exception {
         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(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         UrlRequest urlRequest = urlRequestBuilder.build();
         urlRequest.start();
         try {
             testFramework.mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Cannot shutdown with active requests.",
                          e.getMessage());
         }
 
@@ skipping 114 matching lines @@
     }
 
     @SmallTest
     @Feature({"Cronet"})
     // TODO: Remove the annotation after fixing http://crbug.com/637972
     @OnlyRunNativeCronet
     public void testShutdownAfterError() throws Exception {
         final CronetTestFramework testFramework = startCronetTestFramework();
         ShutdownTestUrlRequestCallback callback =
                 new ShutdownTestUrlRequestCallback(testFramework.mCronetEngine);
-        UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(MOCK_CRONET_TEST_FAILED_URL,
-                callback, callback.getExecutor(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                MOCK_CRONET_TEST_FAILED_URL, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertTrue(callback.mOnErrorCalled);
         callback.blockForCallbackToComplete();
         callback.shutdownExecutor();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testShutdownAfterCancel() throws Exception {
         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(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         UrlRequest urlRequest = urlRequestBuilder.build();
         urlRequest.start();
         try {
             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();
         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());
         File file = File.createTempFile("cronet", "json", directory);
         CronetEngine cronetEngine = new CronetUrlRequestContext(
-                new CronetEngine.Builder(context).setLibraryName("cronet_tests"));
+                new CronetEngineBuilderImpl(context).setLibraryName("cronet_tests"));
         // Start NetLog immediately after the request context is created to make
         // sure that the call won't crash the app even when the native request
         // context is not fully initialized. See crbug.com/470196.
         cronetEngine.startNetLogToFile(file.getPath(), false);
 
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
-                new UrlRequest.Builder(mUrl, callback, callback.getExecutor(), cronetEngine);
+                cronetEngine.newUrlRequestBuilder(mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         cronetEngine.stopNetLog();
         assertTrue(file.exists());
         assertTrue(file.length() != 0);
         assertFalse(hasBytesInNetLog(file));
         assertTrue(file.delete());
         assertTrue(!file.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet // No netlogs for pure java impl
     public void testBoundedFileNetLog() throws Exception {
         Context context = getContext();
         File directory = new File(PathUtils.getDataDirectory());
         File netLogDir = new File(directory, "NetLog");
         assertFalse(netLogDir.exists());
         assertTrue(netLogDir.mkdir());
         File eventFile = new File(netLogDir, "event_file_0.json");
-        CronetEngine cronetEngine = new CronetUrlRequestContext(
-                new CronetEngine.Builder(context).setLibraryName("cronet_tests"));
+        CronetUrlRequestContext cronetEngine = new CronetUrlRequestContext(
+                new CronetEngineBuilderImpl(context).setLibraryName("cronet_tests"));
         // Start NetLog immediately after the request context is created to make
         // sure that the call won't crash the app even when the native request
         // context is not fully initialized. See crbug.com/470196.
         cronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
 
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
-                new UrlRequest.Builder(mUrl, callback, callback.getExecutor(), cronetEngine);
+                cronetEngine.newUrlRequestBuilder(mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         cronetEngine.stopNetLog();
         assertTrue(eventFile.exists());
         assertTrue(eventFile.length() != 0);
         assertFalse(hasBytesInNetLog(eventFile));
         FileUtils.recursivelyDeleteFile(netLogDir);
         assertFalse(netLogDir.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet // No netlogs for pure java impl
     // Tests that if stopNetLog is not explicity called, CronetEngine.shutdown()
     // will take care of it. crbug.com/623701.
     public void testNoStopNetLog() throws Exception {
         Context context = getContext();
         File directory = new File(PathUtils.getDataDirectory());
         File file = File.createTempFile("cronet", "json", directory);
-        CronetEngine cronetEngine = new CronetUrlRequestContext(
-                new CronetEngine.Builder(context).setLibraryName("cronet_tests"));
+        CronetUrlRequestContext cronetEngine = new CronetUrlRequestContext(
+                new CronetEngineBuilderImpl(context).setLibraryName("cronet_tests"));
         cronetEngine.startNetLogToFile(file.getPath(), false);
 
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
-                new UrlRequest.Builder(mUrl, callback, callback.getExecutor(), cronetEngine);
+                cronetEngine.newUrlRequestBuilder(mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         // Shut down the engine without calling stopNetLog.
         cronetEngine.shutdown();
         assertTrue(file.exists());
         assertTrue(file.length() != 0);
         assertFalse(hasBytesInNetLog(file));
         assertTrue(file.delete());
         assertTrue(!file.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet // No netlogs for pure java impl
     // Tests that if stopNetLog is not explicity called, CronetEngine.shutdown()
     // will take care of it. crbug.com/623701.
     public void testNoStopBoundedFileNetLog() throws Exception {
         Context context = getContext();
         File directory = new File(PathUtils.getDataDirectory());
         File netLogDir = new File(directory, "NetLog");
         assertFalse(netLogDir.exists());
         assertTrue(netLogDir.mkdir());
         File eventFile = new File(netLogDir, "event_file_0.json");
-        CronetEngine cronetEngine = new CronetUrlRequestContext(
-                new CronetEngine.Builder(context).setLibraryName("cronet_tests"));
+        CronetUrlRequestContext cronetEngine = new CronetUrlRequestContext(
+                new CronetEngineBuilderImpl(context).setLibraryName("cronet_tests"));
         cronetEngine.startNetLogToDisk(netLogDir.getPath(), false, MAX_FILE_SIZE);
 
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
-                new UrlRequest.Builder(mUrl, callback, callback.getExecutor(), cronetEngine);
+                cronetEngine.newUrlRequestBuilder(mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         // Shut down the engine without calling stopNetLog.
         cronetEngine.shutdown();
         assertTrue(eventFile.exists());
         assertTrue(eventFile.length() != 0);
 
         FileUtils.recursivelyDeleteFile(netLogDir);
         assertFalse(netLogDir.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     // Tests that NetLog contains events emitted by all live CronetEngines.
     public void testNetLogContainEventsFromAllLiveEngines() throws Exception {
         Context context = getContext();
         File directory = new File(PathUtils.getDataDirectory());
         File file1 = File.createTempFile("cronet1", "json", directory);
         File file2 = File.createTempFile("cronet2", "json", directory);
         CronetEngine cronetEngine1 = new CronetUrlRequestContext(
-                new CronetEngine.Builder(context).setLibraryName("cronet_tests"));
+                new CronetEngineBuilderImpl(context).setLibraryName("cronet_tests"));
         CronetEngine cronetEngine2 = new CronetUrlRequestContext(
-                new CronetEngine.Builder(context).setLibraryName("cronet_tests"));
+                new CronetEngineBuilderImpl(context).setLibraryName("cronet_tests"));
 
         cronetEngine1.startNetLogToFile(file1.getPath(), false);
         cronetEngine2.startNetLogToFile(file2.getPath(), false);
 
         // Warm CronetEngine and make sure both CronetUrlRequestContexts are
         // initialized before testing the logs.
         makeRequestAndCheckStatus(cronetEngine1, mUrl, 200);
         makeRequestAndCheckStatus(cronetEngine2, mUrl, 200);
 
         // Use cronetEngine1 to make a request to mUrl404.
@@ skipping 26 matching lines @@
         File netLogDir1 = new File(directory, "NetLog1");
         assertFalse(netLogDir1.exists());
         assertTrue(netLogDir1.mkdir());
         File netLogDir2 = new File(directory, "NetLog2");
         assertFalse(netLogDir2.exists());
         assertTrue(netLogDir2.mkdir());
         File eventFile1 = new File(netLogDir1, "event_file_0.json");
         File eventFile2 = new File(netLogDir2, "event_file_0.json");
 
         CronetUrlRequestContext cronetEngine1 = new CronetUrlRequestContext(
-                new CronetEngine.Builder(context).setLibraryName("cronet_tests"));
+                new CronetEngineBuilderImpl(context).setLibraryName("cronet_tests"));
         CronetUrlRequestContext cronetEngine2 = new CronetUrlRequestContext(
-                new CronetEngine.Builder(context).setLibraryName("cronet_tests"));
+                new CronetEngineBuilderImpl(context).setLibraryName("cronet_tests"));
 
         cronetEngine1.startNetLogToDisk(netLogDir1.getPath(), false, MAX_FILE_SIZE);
         cronetEngine2.startNetLogToDisk(netLogDir2.getPath(), false, MAX_FILE_SIZE);
 
         // Warm CronetEngine and make sure both CronetUrlRequestContexts are
         // initialized before testing the logs.
         makeRequestAndCheckStatus(cronetEngine1, mUrl, 200);
         makeRequestAndCheckStatus(cronetEngine2, mUrl, 200);
 
         // Use cronetEngine1 to make a request to mUrl404.
@@ skipping 65 matching lines @@
         }
         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);
+                testFramework.mCronetEngine.newUrlRequestBuilder(url, callback, directExecutor);
         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,
@@ skipping 23 matching lines @@
                 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(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                url, callback, callback.getExecutor());
         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 {
         final CronetTestFramework testFramework = startCronetTestFramework();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         testFramework.mCronetEngine.shutdown();
 
         File directory = new File(PathUtils.getDataDirectory());
         File file = File.createTempFile("cronet", "json", directory);
         try {
             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 {
         final CronetTestFramework testFramework = startCronetTestFramework();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         testFramework.mCronetEngine.shutdown();
 
         File directory = new File(PathUtils.getDataDirectory());
         File netLogDir = new File(directory, "NetLog");
         assertFalse(netLogDir.exists());
         assertTrue(netLogDir.mkdir());
         File constantsFile = new File(netLogDir, "constants.json");
         try {
@@ skipping 14 matching lines @@
         final CronetTestFramework testFramework = startCronetTestFramework();
         File directory = new File(PathUtils.getDataDirectory());
         File file = File.createTempFile("cronet", "json", directory);
         // Start NetLog multiple times.
         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(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         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 {
         final CronetTestFramework testFramework = startCronetTestFramework();
         File directory = new File(PathUtils.getDataDirectory());
         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.
         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(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         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 {
         final CronetTestFramework testFramework = startCronetTestFramework();
         File directory = new File(PathUtils.getDataDirectory());
         File file = File.createTempFile("cronet", "json", directory);
         testFramework.mCronetEngine.startNetLogToFile(file.getPath(), false);
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         // Stop NetLog multiple times.
         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 {
         final CronetTestFramework testFramework = startCronetTestFramework();
         File directory = new File(PathUtils.getDataDirectory());
         File netLogDir = new File(directory, "NetLog");
         assertFalse(netLogDir.exists());
         assertTrue(netLogDir.mkdir());
         File eventFile = new File(netLogDir, "event_file_0.json");
         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(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         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.
         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
     public void testNetLogWithBytes() throws Exception {
         Context context = getContext();
         File directory = new File(PathUtils.getDataDirectory());
         File file = File.createTempFile("cronet", "json", directory);
         CronetEngine cronetEngine = new CronetUrlRequestContext(
-                new CronetEngine.Builder(context).setLibraryName("cronet_tests"));
+                new CronetEngineBuilderImpl(context).setLibraryName("cronet_tests"));
         // Start NetLog with logAll as true.
         cronetEngine.startNetLogToFile(file.getPath(), true);
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
-                new UrlRequest.Builder(mUrl, callback, callback.getExecutor(), cronetEngine);
+                cronetEngine.newUrlRequestBuilder(mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         cronetEngine.stopNetLog();
         assertTrue(file.exists());
         assertTrue(file.length() != 0);
         assertTrue(hasBytesInNetLog(file));
         assertTrue(file.delete());
         assertTrue(!file.exists());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testBoundedFileNetLogWithBytes() throws Exception {
         Context context = getContext();
         File directory = new File(PathUtils.getDataDirectory());
         File netLogDir = new File(directory, "NetLog");
         assertFalse(netLogDir.exists());
         assertTrue(netLogDir.mkdir());
         File eventFile = new File(netLogDir, "event_file_0.json");
         CronetUrlRequestContext cronetEngine = new CronetUrlRequestContext(
-                new CronetEngine.Builder(context).setLibraryName("cronet_tests"));
+                new CronetEngineBuilderImpl(context).setLibraryName("cronet_tests"));
         // Start NetLog with logAll as true.
         cronetEngine.startNetLogToDisk(netLogDir.getPath(), true, MAX_FILE_SIZE);
         // Start a request.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
-                new UrlRequest.Builder(mUrl, callback, callback.getExecutor(), cronetEngine);
+                cronetEngine.newUrlRequestBuilder(mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         cronetEngine.stopNetLog();
 
         assertTrue(eventFile.exists());
         assertTrue(eventFile.length() != 0);
         assertTrue(hasBytesInNetLog(eventFile));
         FileUtils.recursivelyDeleteFile(netLogDir);
         assertFalse(netLogDir.exists());
     }
@@ skipping 18 matching lines @@
     }
 
     /**
      * Helper method to make a request to {@code url}, wait for it to
      * complete, and check that the status code is the same as {@code expectedStatusCode}.
      */
     private void makeRequestAndCheckStatus(
             CronetEngine engine, String url, int expectedStatusCode) {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest request =
-                new UrlRequest.Builder(url, callback, callback.getExecutor(), engine).build();
+                engine.newUrlRequestBuilder(url, callback, callback.getExecutor()).build();
         request.start();
         callback.blockForDone();
         assertEquals(expectedStatusCode, callback.mResponseInfo.getHttpStatusCode());
     }
 
     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) {
+        } else if (cacheType == HTTP_CACHE_IN_MEMORY) {
             cacheTypeString = CronetTestFramework.CACHE_IN_MEMORY;
         }
         String[] commandLineArgs = {CronetTestFramework.CACHE_KEY, cacheTypeString};
         CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCommandLineArgs(null, commandLineArgs);
         assertTrue(NativeTestServer.startNativeTestServer(getContext()));
         return testFramework;
     }
 
     private void checkRequestCaching(CronetEngine engine, String url, boolean expectCached) {
         checkRequestCaching(engine, url, expectCached, false);
     }
 
     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(), engine);
+                engine.newUrlRequestBuilder(url, callback, callback.getExecutor());
         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 {
         final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISABLED);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
         checkRequestCaching(testFramework.mCronetEngine, url, false);
         checkRequestCaching(testFramework.mCronetEngine, url, false);
         checkRequestCaching(testFramework.mCronetEngine, url, false);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testEnableHttpCacheInMemory() throws Exception {
         final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_IN_MEMORY);
+                startCronetTestFrameworkWithCacheEnabled(HTTP_CACHE_IN_MEMORY);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
         checkRequestCaching(testFramework.mCronetEngine, url, false);
         checkRequestCaching(testFramework.mCronetEngine, url, true);
         NativeTestServer.shutdownNativeTestServer();
         checkRequestCaching(testFramework.mCronetEngine, url, true);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testEnableHttpCacheDisk() throws Exception {
@@ skipping 32 matching lines @@
         // When cache is enabled, the second request is cached.
         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(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(), testFramework.mCronetEngine);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                url, callback, callback.getExecutor());
         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 {
         final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
         checkRequestCaching(testFramework.mCronetEngine, url, false);
         checkRequestCaching(testFramework.mCronetEngine, url, true);
         NativeTestServer.shutdownNativeTestServer();
         checkRequestCaching(testFramework.mCronetEngine, url, true);
 
         // Shutdown original context and create another that uses the same cache.
         testFramework.mCronetEngine.shutdown();
-        testFramework.mCronetEngine = testFramework.getCronetEngineBuilder().build();
+        testFramework.mCronetEngine =
+                (CronetEngineBase) 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();
         UrlRequest.Builder urlRequestBuilder =
-                new UrlRequest.Builder(mUrl, callback, callback.getExecutor(), cronetEngine);
+                cronetEngine.newUrlRequestBuilder(mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testEmptyGetCertVerifierData() {
         CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
 
         // Immediately make a request after initializing the engine.
-        CronetEngine cronetEngine = testFramework.initCronetEngine();
+        ExperimentalCronetEngine cronetEngine = testFramework.initCronetEngine();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
-                new UrlRequest.Builder(mUrl, callback, callback.getExecutor(), cronetEngine);
+                cronetEngine.newUrlRequestBuilder(mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
 
         try {
             cronetEngine.getCertVerifierData(-1);
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("timeout must be a positive value", e.getMessage());
         }
         // Because mUrl is http, getCertVerifierData() will return empty data.
         String data = cronetEngine.getCertVerifierData(100);
         assertTrue(data.isEmpty());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testInitEngineStartTwoRequests() throws Exception {
         CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
 
         // Make two requests after initializing the context.
         CronetEngine cronetEngine = testFramework.initCronetEngine();
         int[] statusCodes = {0, 0};
         String[] urls = {mUrl, mUrl404};
         for (int i = 0; i < 2; i++) {
             TestUrlRequestCallback callback = new TestUrlRequestCallback();
             UrlRequest.Builder urlRequestBuilder =
-                    new UrlRequest.Builder(urls[i], callback, callback.getExecutor(), cronetEngine);
+                    cronetEngine.newUrlRequestBuilder(urls[i], callback, callback.getExecutor());
             urlRequestBuilder.build().start();
             callback.blockForDone();
             statusCodes[i] = callback.mResponseInfo.getHttpStatusCode();
         }
         assertEquals(200, statusCodes[0]);
         assertEquals(404, statusCodes[1]);
     }
 
     @SmallTest
     @Feature({"Cronet"})
@@ skipping 32 matching lines @@
     }
 
     @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
         final CronetTestFramework testFramework = startCronetTestFramework();
         CronetEngine firstEngine =
-                new CronetUrlRequestContext(testFramework.createCronetEngineBuilder(getContext()));
+                new CronetUrlRequestContext(CronetTestUtil.getCronetEngineBuilderImpl(
+                        testFramework.createCronetEngineBuilder(getContext())));
         CronetEngine secondEngine = new CronetUrlRequestContext(
-                testFramework.createCronetEngineBuilder(getContext().getApplicationContext()));
-        CronetEngine thirdEngine = new CronetUrlRequestContext(
-                testFramework.createCronetEngineBuilder(new ContextWrapper(getContext())));
+                CronetTestUtil.getCronetEngineBuilderImpl(testFramework.createCronetEngineBuilder(
+                        getContext().getApplicationContext())));
+        CronetEngine thirdEngine =
+                new CronetUrlRequestContext(CronetTestUtil.getCronetEngineBuilderImpl(
+                        testFramework.createCronetEngineBuilder(new ContextWrapper(getContext()))));
         firstEngine.shutdown();
         secondEngine.shutdown();
         thirdEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testGetGlobalMetricsDeltas() throws Exception {
         final CronetTestFramework testFramework = startCronetTestFramework();
 
         byte delta1[] = testFramework.mCronetEngine.getGlobalMetricsDeltas();
 
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(
-                mUrl, callback, callback.getExecutor(), testFramework.mCronetEngine);
+        UrlRequest.Builder builder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                mUrl, callback, callback.getExecutor());
         builder.build().start();
         callback.blockForDone();
         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.
-        CronetEngine.Builder builder = new CronetEngine.Builder(getContext());
+        CronetEngineBuilderImpl builder = new CronetEngineBuilderImpl(getContext());
         builder.enableHttp2(false);
         builder.enableQuic(true);
         builder.enableSdch(true);
         builder.addQuicHint("example.com", 12, 34);
         builder.setCertVerifierData("test_cert_verifier_data");
-        builder.enableHttpCache(CronetEngine.Builder.HTTP_CACHE_IN_MEMORY, 54321);
+        builder.enableHttpCache(HTTP_CACHE_IN_MEMORY, 54321);
         builder.enableDataReductionProxy("abcd");
         builder.setUserAgent("efgh");
         builder.setExperimentalOptions("ijkl");
         builder.setDataReductionProxyOptions("mnop", "qrst", "uvwx");
         builder.setStoragePath(CronetTestFramework.getTestStorage(getContext()));
         builder.enablePublicKeyPinningBypassForLocalTrustAnchors(false);
         nativeVerifyUrlRequestContextConfig(
-                CronetUrlRequestContext.createNativeUrlRequestContextConfig(getContext(), builder),
+                CronetUrlRequestContext.createNativeUrlRequestContextConfig(builder),
                 CronetTestFramework.getTestStorage(getContext()));
     }
 
     // Verifies that CronetEngine.Builder config from testCronetEngineBuilderConfig() is properly
     // translated to a native UrlRequestContextConfig.
     private static native void nativeVerifyUrlRequestContextConfig(long config, String storagePath);
 
     private static class TestBadLibraryLoader extends CronetEngine.Builder.LibraryLoader {
         private boolean mWasCalled = false;
 
         public void loadLibrary(String libName) {
             // Report that this method was called, but don't load the library
             mWasCalled = true;
         }
 
         boolean wasCalled() {
             return mWasCalled;
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSkipLibraryLoading() throws Exception {
-        CronetEngine.Builder builder = new CronetEngine.Builder(getContext());
+        CronetEngineBuilderImpl builder = new CronetEngineBuilderImpl(getContext());
         TestBadLibraryLoader loader = new TestBadLibraryLoader();
         builder.setLibraryLoader(loader).setLibraryName("cronet_tests");
         try {
             // ensureInitialized() calls native code to check the version right after library load
             // and will error with the message below if library loading was skipped
             CronetLibraryLoader.ensureInitialized(getContext(), builder);
             fail("Native library should not be loaded");
         } catch (UnsatisfiedLinkError e) {
             assertTrue(loader.wasCalled());
         }
     }
 
     // Creates a CronetEngine on another thread and then one on the main thread.  This shouldn't
     // crash.
     @SmallTest
     @Feature({"Cronet"})
     public void testThreadedStartup() throws Exception {
         final ConditionVariable otherThreadDone = new ConditionVariable();
         final ConditionVariable uiThreadDone = new ConditionVariable();
         new Handler(Looper.getMainLooper()).post(new Runnable() {
             public void run() {
-                final CronetEngine.Builder builder =
-                        new CronetEngine.Builder(getContext()).setLibraryName("cronet_tests");
+                final ExperimentalCronetEngine.Builder builder =
+                        new ExperimentalCronetEngine.Builder(getContext());
+                CronetTestUtil.setLibraryName(builder, "cronet_tests");
                 new Thread() {
                     public void run() {
                         CronetEngine cronetEngine = builder.build();
                         otherThreadDone.open();
                         cronetEngine.shutdown();
                     }
                 }.start();
                 otherThreadDone.block();
                 builder.build().shutdown();
                 uiThreadDone.open();
             }
         });
         assertTrue(uiThreadDone.block(1000));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testHostResolverRules() throws Exception {
         String resolverTestHostname = "some-weird-hostname";
         URL testUrl = new URL(mUrl);
-        CronetEngine.Builder cronetEngineBuilder = new CronetEngine.Builder(getContext());
+        ExperimentalCronetEngine.Builder cronetEngineBuilder =
+                new ExperimentalCronetEngine.Builder(getContext());
         JSONObject hostResolverRules = new JSONObject().put(
                 "host_resolver_rules", "MAP " + resolverTestHostname + " " + testUrl.getHost());
         JSONObject experimentalOptions =
                 new JSONObject().put("HostResolverRules", hostResolverRules);
         cronetEngineBuilder.setExperimentalOptions(experimentalOptions.toString());
 
         final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, cronetEngineBuilder);
         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);
+        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+                requestUrl.toString(), callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
     }
 }