Cronet API Refactoring

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.net;
 
 import android.os.ConditionVariable;
 import android.os.StrictMode;
 import android.test.MoreAsserts;
 import android.test.suitebuilder.annotation.SmallTest;
@@ skipping 41 matching lines @@
     @Override
     protected void tearDown() throws Exception {
         NativeTestServer.shutdownNativeTestServer();
         mTestFramework.mCronetEngine.shutdown();
         super.tearDown();
     }
 
     private TestUrlRequestCallback startAndWaitForComplete(String url) throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         // Create request.
-        UrlRequest.Builder builder = new UrlRequest.Builder(
-                url, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                url, callback, callback.getExecutor());
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.blockForDone();
         // Wait for all posted tasks to be executed to ensure there is no unhandled exception.
         callback.shutdownExecutorAndWait();
         assertTrue(urlRequest.isDone());
         return callback;
     }
 
     private void checkResponseInfo(UrlResponseInfo responseInfo, String expectedUrl,
@@ skipping 14 matching lines @@
         List<String> header = responseHeaders.get(headerName);
         assertNotNull(header);
         assertTrue(header.contains(headerValue));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testBuilderChecks() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         try {
-            new UrlRequest.Builder(
-                    null, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+            mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                    null, callback, callback.getExecutor());
             fail("URL not null-checked");
         } catch (NullPointerException e) {
             assertEquals("URL is required.", e.getMessage());
         }
         try {
-            new UrlRequest.Builder(NativeTestServer.getRedirectURL(), null, callback.getExecutor(),
-                    mTestFramework.mCronetEngine);
+            mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                    NativeTestServer.getRedirectURL(), null, callback.getExecutor());
             fail("Callback not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Callback is required.", e.getMessage());
         }
         try {
-            new UrlRequest.Builder(NativeTestServer.getRedirectURL(), callback, null,
-                    mTestFramework.mCronetEngine);
+            mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                    NativeTestServer.getRedirectURL(), callback, null);
             fail("Executor not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Executor is required.", e.getMessage());
         }
-        try {
-            new UrlRequest.Builder(
-                    NativeTestServer.getRedirectURL(), callback, callback.getExecutor(), null);
-            fail("CronetEngine not null-checked");
-        } catch (NullPointerException e) {
-            assertEquals("CronetEngine is required.", e.getMessage());
-        }
         // Verify successful creation doesn't throw.
-        new UrlRequest.Builder(NativeTestServer.getRedirectURL(), callback, callback.getExecutor(),
-                mTestFramework.mCronetEngine);
+        mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getRedirectURL(), callback, callback.getExecutor());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testSimpleGet() throws Exception {
         String url = NativeTestServer.getEchoMethodURL();
         TestUrlRequestCallback callback = startAndWaitForComplete(url);
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         // Default method is 'GET'.
         assertEquals("GET", callback.mResponseAsString);
@@ skipping 17 matching lines @@
         unknown.setReceivedBytesCount(receivedBytes);
         return unknown;
     }
 
     void runConnectionMigrationTest(boolean disableConnectionMigration) {
         // URLRequest load flags at net/base/load_flags_list.h.
         int connectionMigrationLoadFlag = 1 << 18;
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setAutoAdvance(false);
         // Create builder, start a request, and check if default load_flags are set correctly.
-        UrlRequest.Builder builder =
-                new UrlRequest.Builder(NativeTestServer.getFileURL("/success.txt"), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+        ExperimentalUrlRequest.Builder builder =
+                (ExperimentalUrlRequest.Builder) mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                        NativeTestServer.getFileURL("/success.txt"), callback,
+                        callback.getExecutor());
         // Disable connection migration.
         if (disableConnectionMigration) builder.disableConnectionMigration();
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.waitForNextStep();
         int loadFlags = CronetTestUtil.getLoadFlags(urlRequest);
         if (disableConnectionMigration) {
             assertEquals(connectionMigrationLoadFlag, loadFlags & connectionMigrationLoadFlag);
         } else {
             assertEquals(0, loadFlags & connectionMigrationLoadFlag);
@@ skipping 18 matching lines @@
      * Tests a redirect by running it step-by-step. Also tests that delaying a
      * request works as expected. To make sure there are no unexpected pending
      * messages, does a GET between UrlRequest.Callback callbacks.
      */
     @SmallTest
     @Feature({"Cronet"})
     public void testRedirectAsync() throws Exception {
         // Start the request and wait to see the redirect.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setAutoAdvance(false);
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getRedirectURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getRedirectURL(), callback, callback.getExecutor());
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.waitForNextStep();
 
         // Check the redirect.
         assertEquals(ResponseStep.ON_RECEIVED_REDIRECT, callback.mResponseStep);
         assertEquals(1, callback.mRedirectResponseInfoList.size());
         checkResponseInfo(callback.mRedirectResponseInfoList.get(0),
                 NativeTestServer.getRedirectURL(), 302, "Found");
         assertEquals(1, callback.mRedirectResponseInfoList.get(0).getUrlChain().size());
@@ skipping 106 matching lines @@
             }
 
             @Override
             public void onCanceled(UrlRequest request, UrlResponseInfo info) {
                 assertEquals(1, mRedirectCount);
                 failedExpectation.compareAndSet(false, 1 != mRedirectCount);
                 super.onCanceled(request, info);
             }
         };
 
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getMultiRedirectURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getMultiRedirectURL(), callback, callback.getExecutor());
 
         final UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.blockForDone();
         assertFalse(failedExpectation.get());
         // Check that only one redirect is received.
         assertEquals(1, callback.mRedirectCount);
         // Check that onCanceled is called.
         assertTrue(callback.mOnCanceledCalled);
     }
@@ skipping 34 matching lines @@
         // onFailed messages. This test relies on checks in
         // TestUrlRequestCallback catching a second onFailed call.
         testSimpleGet();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testSetHttpMethod() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         String methodName = "HEAD";
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoMethodURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoMethodURL(), callback, callback.getExecutor());
         // Try to set 'null' method.
         try {
             builder.setHttpMethod(null);
             fail("Exception not thrown");
         } catch (NullPointerException e) {
             assertEquals("Method is required.", e.getMessage());
         }
 
         builder.setHttpMethod(methodName);
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(0, callback.mHttpResponseDataLength);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testBadMethod() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(
-                TEST_URL, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                TEST_URL, callback, callback.getExecutor());
         try {
             builder.setHttpMethod("bad:method!");
             builder.build().start();
             fail("IllegalArgumentException not thrown.");
         } catch (IllegalArgumentException e) {
             assertEquals("Invalid http method bad:method!",
                     e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testBadHeaderName() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(
-                TEST_URL, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                TEST_URL, callback, callback.getExecutor());
         try {
             builder.addHeader("header:name", "headervalue");
             builder.build().start();
             fail("IllegalArgumentException not thrown.");
         } catch (IllegalArgumentException e) {
             assertEquals("Invalid header header:name=headervalue",
                     e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testAcceptEncodingIgnored() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoAllHeadersURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoAllHeadersURL(), callback, callback.getExecutor());
         // This line should eventually throw an exception, once callers have migrated
         builder.addHeader("accept-encoding", "foozip");
         builder.build().start();
         callback.blockForDone();
         assertFalse(callback.mResponseAsString.contains("foozip"));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testBadHeaderValue() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(
-                TEST_URL, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                TEST_URL, callback, callback.getExecutor());
         try {
             builder.addHeader("headername", "bad header\r\nvalue");
             builder.build().start();
             fail("IllegalArgumentException not thrown.");
         } catch (IllegalArgumentException e) {
             assertEquals("Invalid header headername=bad header\r\nvalue",
                     e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testAddHeader() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         String headerName = "header-name";
         String headerValue = "header-value";
-        UrlRequest.Builder builder =
-                new UrlRequest.Builder(NativeTestServer.getEchoHeaderURL(headerName), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoHeaderURL(headerName), callback, callback.getExecutor());
 
         builder.addHeader(headerName, headerValue);
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(headerValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testMultiRequestHeaders() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         String headerName = "header-name";
         String headerValue1 = "header-value1";
         String headerValue2 = "header-value2";
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoAllHeadersURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoAllHeadersURL(), callback, callback.getExecutor());
         builder.addHeader(headerName, headerValue1);
         builder.addHeader(headerName, headerValue2);
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         String headers = callback.mResponseAsString;
         Pattern pattern = Pattern.compile(headerName + ":\\s(.*)\\r\\n");
         Matcher matcher = pattern.matcher(headers);
         List<String> actualValues = new ArrayList<String>();
         while (matcher.find()) {
             actualValues.add(matcher.group(1));
         }
         assertEquals(1, actualValues.size());
         assertEquals("header-value2", actualValues.get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testCustomUserAgent() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         String userAgentName = "User-Agent";
         String userAgentValue = "User-Agent-Value";
-        UrlRequest.Builder builder =
-                new UrlRequest.Builder(NativeTestServer.getEchoHeaderURL(userAgentName), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoHeaderURL(userAgentName), callback, callback.getExecutor());
         builder.addHeader(userAgentName, userAgentValue);
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(userAgentValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testDefaultUserAgent() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         String headerName = "User-Agent";
-        UrlRequest.Builder builder =
-                new UrlRequest.Builder(NativeTestServer.getEchoHeaderURL(headerName), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoHeaderURL(headerName), callback, callback.getExecutor());
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertTrue("Default User-Agent should contain Cronet/n.n.n.n but is "
                         + callback.mResponseAsString,
                 Pattern.matches(
                         ".+Cronet/\\d+\\.\\d+\\.\\d+\\.\\d+.+", callback.mResponseAsString));
     }
 
     @SmallTest
@@ skipping 134 matching lines @@
                 MockUrlRequestJobFactory.getMockUrlForClientCertificateRequest());
         assertNotNull(callback.mResponseInfo);
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("data", callback.mResponseAsString);
         assertEquals(0, callback.mRedirectCount);
         assertNull(callback.mError);
         assertFalse(callback.mOnErrorCalled);
     }
 
     /**
-     * Tests that an SSL cert error will be reported via {@link UrlRequest#onFailed}.
+     * Tests that an SSL cert error will be reported via {@link UrlRequest.Callback#onFailed}.
      */
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet // Java impl doesn't support MockUrlRequestJobFactory
     public void testMockSSLCertificateError() throws Exception {
         TestUrlRequestCallback callback = startAndWaitForComplete(
                 MockUrlRequestJobFactory.getMockUrlForSSLCertificateError());
         assertNull(callback.mResponseInfo);
         assertNotNull(callback.mError);
         assertTrue(callback.mOnErrorCalled);
         assertEquals(-201, callback.mError.getCronetInternalErrorCode());
         assertEquals("Exception in CronetUrlRequest: net::ERR_CERT_DATE_INVALID",
                 callback.mError.getMessage());
         assertEquals(ResponseStep.ON_FAILED, callback.mResponseStep);
     }
 
     /**
      * Checks that the buffer is updated correctly, when starting at an offset.
      */
     @SmallTest
     @Feature({"Cronet"})
     public void testSimpleGetBufferUpdates() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setAutoAdvance(false);
         // Since the default method is "GET", the expected response body is also
         // "GET".
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoMethodURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoMethodURL(), callback, callback.getExecutor());
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.waitForNextStep();
 
         ByteBuffer readBuffer = ByteBuffer.allocateDirect(5);
         readBuffer.put("FOR".getBytes());
         assertEquals(3, readBuffer.position());
 
         // Read first two characters of the response ("GE"). It's theoretically
         // possible to need one read per character, though in practice,
@@ skipping 60 matching lines @@
         // Make sure there are no other pending messages, which would trigger
         // asserts in TestUrlRequestCallback.
         testSimpleGet();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testBadBuffers() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setAutoAdvance(false);
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoMethodURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoMethodURL(), callback, callback.getExecutor());
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.waitForNextStep();
 
         // Try to read using a full buffer.
         try {
             ByteBuffer readBuffer = ByteBuffer.allocateDirect(4);
             readBuffer.put("full".getBytes());
             urlRequest.read(readBuffer);
             fail("Exception not thrown");
@@ skipping 20 matching lines @@
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("GET", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testNoIoInCancel() throws Exception {
         final TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setAutoAdvance(false);
         final UrlRequest urlRequest =
-                new UrlRequest
-                        .Builder(NativeTestServer.getEchoHeaderURL("blah-header"), callback,
-                                callback.getExecutor(), mTestFramework.mCronetEngine)
+                mTestFramework.mCronetEngine
+                        .newUrlRequestBuilder(NativeTestServer.getEchoHeaderURL("blah-header"),
+                                callback, callback.getExecutor())
                         .addHeader("blah-header", "blahblahblah")
                         .build();
         urlRequest.start();
         callback.waitForNextStep();
         callback.startNextRead(urlRequest, ByteBuffer.allocateDirect(4));
         callback.waitForNextStep();
         StrictMode.ThreadPolicy oldPolicy = StrictMode.getThreadPolicy();
         StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
                                            .detectAll()
                                            .penaltyDeath()
                                            .penaltyLog()
                                            .build());
         try {
             urlRequest.cancel();
         } finally {
             StrictMode.setThreadPolicy(oldPolicy);
         }
         callback.blockForDone();
         assertEquals(true, callback.mOnCanceledCalled);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUnexpectedReads() throws Exception {
         final TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setAutoAdvance(false);
         final UrlRequest urlRequest =
-                new UrlRequest.Builder(NativeTestServer.getRedirectURL(), callback,
-                                      callback.getExecutor(), mTestFramework.mCronetEngine)
+                mTestFramework.mCronetEngine
+                        .newUrlRequestBuilder(
+                                NativeTestServer.getRedirectURL(), callback, callback.getExecutor())
                         .build();
 
         // Try to read before starting request.
         try {
             callback.startNextRead(urlRequest);
             fail("Exception not thrown");
         } catch (IllegalStateException e) {
         }
 
         // Verify reading right after start throws an assertion. Both must be
@@ skipping 53 matching lines @@
         } catch (IllegalStateException e) {
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUnexpectedFollowRedirects() throws Exception {
         final TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setAutoAdvance(false);
         final UrlRequest urlRequest =
-                new UrlRequest.Builder(NativeTestServer.getRedirectURL(), callback,
-                                      callback.getExecutor(), mTestFramework.mCronetEngine)
+                mTestFramework.mCronetEngine
+                        .newUrlRequestBuilder(
+                                NativeTestServer.getRedirectURL(), callback, callback.getExecutor())
                         .build();
 
         // Try to follow a redirect before starting the request.
         try {
             urlRequest.followRedirect();
             fail("Exception not thrown");
         } catch (IllegalStateException e) {
         }
 
         // Try to follow a redirect just after starting the request. Has to be
@@ skipping 49 matching lines @@
             urlRequest.followRedirect();
             fail("Exception not thrown");
         } catch (IllegalStateException e) {
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadSetDataProvider() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         try {
             builder.setUploadDataProvider(null, callback.getExecutor());
             fail("Exception not thrown");
         } catch (NullPointerException e) {
             assertEquals("Invalid UploadDataProvider.", e.getMessage());
         }
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         try {
             builder.build().start();
             fail("Exception not thrown");
         } catch (IllegalArgumentException e) {
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadEmptyBodySync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
 
         assertEquals(0, dataProvider.getUploadedLength());
         assertEquals(0, dataProvider.getNumReadCalls());
         assertEquals(0, dataProvider.getNumRewindCalls());
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("", callback.mResponseAsString);
         dataProvider.assertClosed();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadSync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(4, dataProvider.getUploadedLength());
         assertEquals(1, dataProvider.getNumReadCalls());
         assertEquals(0, dataProvider.getNumRewindCalls());
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("test", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadMultiplePiecesSync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.addRead("Y".getBytes());
         dataProvider.addRead("et ".getBytes());
         dataProvider.addRead("another ".getBytes());
         dataProvider.addRead("test".getBytes());
 
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(16, dataProvider.getUploadedLength());
         assertEquals(4, dataProvider.getNumReadCalls());
         assertEquals(0, dataProvider.getNumRewindCalls());
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("Yet another test", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadMultiplePiecesAsync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.ASYNC, callback.getExecutor());
         dataProvider.addRead("Y".getBytes());
         dataProvider.addRead("et ".getBytes());
         dataProvider.addRead("another ".getBytes());
         dataProvider.addRead("test".getBytes());
 
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(16, dataProvider.getUploadedLength());
         assertEquals(4, dataProvider.getNumReadCalls());
         assertEquals(0, dataProvider.getNumRewindCalls());
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("Yet another test", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadChangesDefaultMethod() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoMethodURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoMethodURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("POST", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadWithSetMethod() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoMethodURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoMethodURL(), callback, callback.getExecutor());
 
         final String method = "PUT";
         builder.setHttpMethod(method);
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("PUT", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadRedirectSync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder =
-                new UrlRequest.Builder(NativeTestServer.getRedirectToEchoBody(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getRedirectToEchoBody(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         // 1 read call before the rewind, 1 after.
         assertEquals(2, dataProvider.getNumReadCalls());
         assertEquals(1, dataProvider.getNumRewindCalls());
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("test", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadRedirectAsync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder =
-                new UrlRequest.Builder(NativeTestServer.getRedirectToEchoBody(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getRedirectToEchoBody(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.ASYNC, callback.getExecutor());
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         dataProvider.assertClosed();
         callback.blockForDone();
 
         // 1 read call before the rewind, 1 after.
         assertEquals(2, dataProvider.getNumReadCalls());
         assertEquals(1, dataProvider.getNumRewindCalls());
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("test", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadWithBadLength() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor()) {
             @Override
             public long getLength() throws IOException {
                 return 1;
             }
 
             @Override
             public void read(UploadDataSink uploadDataSink, ByteBuffer byteBuffer)
@@ skipping 11 matching lines @@
         assertEquals("Exception received from UploadDataProvider", callback.mError.getMessage());
         assertEquals("Read upload data length 2 exceeds expected length 1",
                 callback.mError.getCause().getMessage());
         assertEquals(null, callback.mResponseInfo);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadWithBadLengthBufferAligned() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor()) {
             @Override
             public long getLength() throws IOException {
                 return 8191;
             }
 
             @Override
             public void read(UploadDataSink uploadDataSink, ByteBuffer byteBuffer)
@@ skipping 11 matching lines @@
         assertEquals("Exception received from UploadDataProvider", callback.mError.getMessage());
         assertEquals("Read upload data length 8192 exceeds expected length 8191",
                 callback.mError.getCause().getMessage());
         assertEquals(null, callback.mResponseInfo);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadReadFailSync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.setReadFailure(0, TestUploadDataProvider.FailMode.CALLBACK_SYNC);
         // This will never be read, but if the length is 0, read may never be
         // called.
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(1, dataProvider.getNumReadCalls());
         assertEquals(0, dataProvider.getNumRewindCalls());
 
         assertEquals("Exception received from UploadDataProvider", callback.mError.getMessage());
         assertEquals("Sync read failure", callback.mError.getCause().getMessage());
         assertEquals(null, callback.mResponseInfo);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadLengthFailSync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.setLengthFailure();
         // This will never be read, but if the length is 0, read may never be
         // called.
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(0, dataProvider.getNumReadCalls());
         assertEquals(0, dataProvider.getNumRewindCalls());
 
         assertEquals("Exception received from UploadDataProvider", callback.mError.getMessage());
         assertEquals("Sync length failure", callback.mError.getCause().getMessage());
         assertEquals(null, callback.mResponseInfo);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadReadFailAsync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.setReadFailure(0, TestUploadDataProvider.FailMode.CALLBACK_ASYNC);
         // This will never be read, but if the length is 0, read may never be
         // called.
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
@@ skipping 13 matching lines @@
     @Feature({"Cronet"})
     public void testDirectExecutorUploadProhibitedByDefault() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         Executor myExecutor = new Executor() {
 
             @Override
             public void execute(Runnable command) {
                 command.run();
             }
         };
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, myExecutor);
         // This will never be read, but if the length is 0, read may never be
         // called.
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, myExecutor);
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
@@ skipping 13 matching lines @@
     public void testDirectExecutorProhibitedByDefault() throws Exception {
         System.out.println("testing with " + mTestFramework.mCronetEngine);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         Executor myExecutor = new Executor() {
 
             @Override
             public void execute(Runnable command) {
                 command.run();
             }
         };
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, myExecutor, mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, myExecutor);
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         // This will never be read, but if the length is 0, read may never be
         // called.
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
@@ skipping 14 matching lines @@
     public void testDirectExecutorAllowed() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setAllowDirectExecutor(true);
         Executor myExecutor = new Executor() {
 
             @Override
             public void execute(Runnable command) {
                 command.run();
             }
         };
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, myExecutor, mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, myExecutor);
         UploadDataProvider dataProvider = UploadDataProviders.create("test".getBytes("UTF-8"));
         builder.setUploadDataProvider(dataProvider, myExecutor);
         builder.addHeader("Content-Type", "useless/string");
         builder.allowDirectExecutor();
         builder.build().start();
         callback.blockForDone();
 
         if (callback.mOnErrorCalled) {
             throw callback.mError;
         }
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("test", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadReadFailThrown() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.setReadFailure(0, TestUploadDataProvider.FailMode.THROWN);
         // This will never be read, but if the length is 0, read may never be
         // called.
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(1, dataProvider.getNumReadCalls());
         assertEquals(0, dataProvider.getNumRewindCalls());
 
         assertEquals("Exception received from UploadDataProvider", callback.mError.getMessage());
         assertEquals("Thrown read failure", callback.mError.getCause().getMessage());
         assertEquals(null, callback.mResponseInfo);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadRewindFailSync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder =
-                new UrlRequest.Builder(NativeTestServer.getRedirectToEchoBody(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getRedirectToEchoBody(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.setRewindFailure(TestUploadDataProvider.FailMode.CALLBACK_SYNC);
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(1, dataProvider.getNumReadCalls());
         assertEquals(1, dataProvider.getNumRewindCalls());
 
         assertEquals("Exception received from UploadDataProvider", callback.mError.getMessage());
         assertEquals("Sync rewind failure", callback.mError.getCause().getMessage());
         assertEquals(null, callback.mResponseInfo);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadRewindFailAsync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder =
-                new UrlRequest.Builder(NativeTestServer.getRedirectToEchoBody(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getRedirectToEchoBody(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.ASYNC, callback.getExecutor());
         dataProvider.setRewindFailure(TestUploadDataProvider.FailMode.CALLBACK_ASYNC);
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(1, dataProvider.getNumReadCalls());
         assertEquals(1, dataProvider.getNumRewindCalls());
 
         assertEquals("Exception received from UploadDataProvider", callback.mError.getMessage());
         assertEquals("Async rewind failure", callback.mError.getCause().getMessage());
         assertEquals(null, callback.mResponseInfo);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadRewindFailThrown() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder =
-                new UrlRequest.Builder(NativeTestServer.getRedirectToEchoBody(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getRedirectToEchoBody(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.setRewindFailure(TestUploadDataProvider.FailMode.THROWN);
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertEquals(1, dataProvider.getNumReadCalls());
         assertEquals(1, dataProvider.getNumRewindCalls());
 
         assertEquals("Exception received from UploadDataProvider", callback.mError.getMessage());
         assertEquals("Thrown rewind failure", callback.mError.getCause().getMessage());
         assertEquals(null, callback.mResponseInfo);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadChunked() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.addRead("test hello".getBytes());
         dataProvider.setChunked(true);
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
 
         assertEquals(-1, dataProvider.getUploadedLength());
 
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         // 1 read call for one data chunk.
         assertEquals(1, dataProvider.getNumReadCalls());
         assertEquals("test hello", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadChunkedLastReadZeroLengthBody() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         // Add 3 reads. The last read has a 0-length body.
         dataProvider.addRead("hello there".getBytes());
         dataProvider.addRead("!".getBytes());
         dataProvider.addRead("".getBytes());
         dataProvider.setChunked(true);
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
 
         assertEquals(-1, dataProvider.getUploadedLength());
 
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         // 2 read call for the first two data chunks, and 1 for final chunk.
         assertEquals(3, dataProvider.getNumReadCalls());
         assertEquals("hello there!", callback.mResponseAsString);
     }
 
     // Test where an upload fails without ever initializing the
     // UploadDataStream, because it can't connect to the server.
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadFailsWithoutInitializingStream() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         // The port for PTP will always refuse a TCP connection
-        UrlRequest.Builder builder = new UrlRequest.Builder("http://127.0.0.1:319", callback,
-                callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                "http://127.0.0.1:319", callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
         dataProvider.assertClosed();
 
         assertNull(callback.mResponseInfo);
         if (testingJavaImpl()) {
             Throwable cause = callback.mError.getCause();
             assertTrue("Exception was: " + cause, cause instanceof ConnectException);
         } else {
             assertEquals("Exception in CronetUrlRequest: net::ERR_CONNECTION_REFUSED",
                     callback.mError.getMessage());
         }
     }
 
     private void throwOrCancel(FailureType failureType, ResponseStep failureStep,
             boolean expectResponseInfo, boolean expectError) {
         if (Log.isLoggable("TESTING", Log.VERBOSE)) {
             Log.v("TESTING", "Testing " + failureType + " during " + failureStep);
         }
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setFailure(failureType, failureStep);
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getRedirectURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getRedirectURL(), callback, callback.getExecutor());
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.blockForDone();
         // Wait for all posted tasks to be executed to ensure there is no unhandled exception.
         callback.shutdownExecutorAndWait();
         assertEquals(1, callback.mRedirectCount);
         if (failureType == FailureType.CANCEL_SYNC || failureType == FailureType.CANCEL_ASYNC) {
             assertEquals(ResponseStep.ON_CANCELED, callback.mResponseStep);
         } else if (failureType == FailureType.THROW_SYNC) {
             assertEquals(ResponseStep.ON_FAILED, callback.mResponseStep);
@@ skipping 40 matching lines @@
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testThrowOrCancelInOnSucceeded() {
         FailureType[] testTypes = new FailureType[] {
                 FailureType.THROW_SYNC, FailureType.CANCEL_SYNC, FailureType.CANCEL_ASYNC};
         for (FailureType type : testTypes) {
             TestUrlRequestCallback callback = new TestUrlRequestCallback();
             callback.setFailure(type, ResponseStep.ON_SUCCEEDED);
-            UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoMethodURL(),
-                    callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+            UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                    NativeTestServer.getEchoMethodURL(), callback, callback.getExecutor());
             UrlRequest urlRequest = builder.build();
             urlRequest.start();
             callback.blockForDone();
             // Wait for all posted tasks to be executed to ensure there is no unhandled exception.
             callback.shutdownExecutorAndWait();
             assertNull(callback.mError);
             assertEquals(ResponseStep.ON_SUCCEEDED, callback.mResponseStep);
             assertTrue(urlRequest.isDone());
             assertNotNull(callback.mResponseInfo);
             assertFalse(callback.mOnErrorCalled);
             assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
             assertEquals("GET", callback.mResponseAsString);
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testThrowOrCancelInOnFailed() {
         FailureType[] testTypes = new FailureType[] {
                 FailureType.THROW_SYNC, FailureType.CANCEL_SYNC, FailureType.CANCEL_ASYNC};
         for (FailureType type : testTypes) {
             String url = NativeTestServer.getEchoBodyURL();
             // Shut down NativeTestServer so request will fail.
             NativeTestServer.shutdownNativeTestServer();
             TestUrlRequestCallback callback = new TestUrlRequestCallback();
             callback.setFailure(type, ResponseStep.ON_FAILED);
-            UrlRequest.Builder builder = new UrlRequest.Builder(
-                    url, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+            UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                    url, callback, callback.getExecutor());
             UrlRequest urlRequest = builder.build();
             urlRequest.start();
             callback.blockForDone();
             // Wait for all posted tasks to be executed to ensure there is no unhandled exception.
             callback.shutdownExecutorAndWait();
             assertEquals(ResponseStep.ON_FAILED, callback.mResponseStep);
             assertTrue(callback.mOnErrorCalled);
             assertNotNull(callback.mError);
             assertTrue(urlRequest.isDone());
             // Start NativeTestServer again to run the test for a second time.
             assertTrue(NativeTestServer.startNativeTestServer(getContext()));
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testThrowOrCancelInOnCanceled() {
         FailureType[] testTypes = new FailureType[] {
                 FailureType.THROW_SYNC, FailureType.CANCEL_SYNC, FailureType.CANCEL_ASYNC};
         for (FailureType type : testTypes) {
             TestUrlRequestCallback callback = new TestUrlRequestCallback() {
                 @Override
                 public void onResponseStarted(UrlRequest request, UrlResponseInfo info) {
                     super.onResponseStarted(request, info);
                     request.cancel();
                 }
             };
             callback.setFailure(type, ResponseStep.ON_CANCELED);
-            UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                    callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+            UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                    NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
             UrlRequest urlRequest = builder.build();
             urlRequest.start();
             callback.blockForDone();
             // Wait for all posted tasks to be executed to ensure there is no unhandled exception.
             callback.shutdownExecutorAndWait();
             assertEquals(ResponseStep.ON_CANCELED, callback.mResponseStep);
             assertTrue(urlRequest.isDone());
             assertNotNull(callback.mResponseInfo);
             assertNull(callback.mError);
             assertTrue(callback.mOnCanceledCalled);
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet // No destroyed callback for tests
     public void testExecutorShutdown() {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
 
         callback.setAutoAdvance(false);
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
         CronetUrlRequest urlRequest = (CronetUrlRequest) builder.build();
         urlRequest.start();
         callback.waitForNextStep();
         assertFalse(callback.isDone());
         assertFalse(urlRequest.isDone());
 
         final ConditionVariable requestDestroyed = new ConditionVariable(false);
         urlRequest.setOnDestroyedCallbackForTesting(new Runnable() {
             @Override
             public void run() {
@@ skipping 33 matching lines @@
                 mByteBuffer = byteBuffer;
                 mReadCalled.open();
             }
 
             @Override
             public void rewind(final UploadDataSink uploadDataSink) {
             }
         }
 
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         ExecutorService uploadExecutor = Executors.newSingleThreadExecutor();
         HangingUploadDataProvider dataProvider = new HangingUploadDataProvider();
         builder.setUploadDataProvider(dataProvider, uploadExecutor);
         builder.addHeader("Content-Type", "useless/string");
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         // Wait for read to be called on executor.
         dataProvider.mReadCalled.block();
         // Shutdown the executor, so posting next task will throw an exception.
@@ skipping 21 matching lines @@
             super.onSucceeded(request, info);
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet // No adapter to destroy in pure java
     // Regression test for crbug.com/564946.
     public void testDestroyUploadDataStreamAdapterOnSucceededCallback() throws Exception {
         TestUrlRequestCallback callback = new QuitOnSuccessCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                NativeTestServer.getEchoBodyURL(), callback, callback.getExecutor());
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         CronetUrlRequest request = (CronetUrlRequest) builder.build();
         final ConditionVariable uploadDataStreamAdapterDestroyed = new ConditionVariable();
         request.setOnDestroyedUploadCallbackForTesting(new Runnable() {
             @Override
             public void run() {
@@ skipping 93 matching lines @@
     private String bufferContentsToString(ByteBuffer byteBuffer, int start, int end) {
         // Use a duplicate to avoid modifying byteBuffer.
         ByteBuffer duplicate = byteBuffer.duplicate();
         duplicate.position(start);
         duplicate.limit(end);
         byte[] contents = new byte[duplicate.remaining()];
         duplicate.get(contents);
         return new String(contents);
     }
 }