Cronet API Refactoring

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

 // Copyright 2015 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 static org.chromium.base.CollectionUtil.newHashSet;
 
 import android.os.ConditionVariable;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.chromium.base.test.util.DisabledTest;
 import org.chromium.base.test.util.Feature;
-import org.chromium.net.CronetTestBase.OnlyRunNativeCronet;
 import org.chromium.net.MetricsTestUtil.TestExecutor;
 import org.chromium.net.MetricsTestUtil.TestRequestFinishedListener;
 import org.chromium.net.TestBidirectionalStreamCallback.FailureType;
 import org.chromium.net.TestBidirectionalStreamCallback.ResponseStep;
 import org.chromium.net.impl.CronetBidirectionalStream;
 
 import java.nio.ByteBuffer;
 import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
  * Test functionality of BidirectionalStream interface.
  */
 public class BidirectionalStreamTest extends CronetTestBase {
     private CronetTestFramework mTestFramework;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         // Load library first to create MockCertVerifier.
         System.loadLibrary("cronet_tests");
-        CronetEngine.Builder builder = new CronetEngine.Builder(getContext());
-        builder.setMockCertVerifierForTesting(QuicTestServer.createMockCertVerifier());
+        ExperimentalCronetEngine.Builder builder =
+                new ExperimentalCronetEngine.Builder(getContext());
+        CronetTestUtil.setMockCertVerifierForTesting(
+                builder, QuicTestServer.createMockCertVerifier());
 
         mTestFramework = startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, builder);
         assertTrue(Http2TestServer.startHttp2TestServer(
                 getContext(), QuicTestServer.getServerCert(), QuicTestServer.getServerCertKey()));
     }
 
     @Override
     protected void tearDown() throws Exception {
         assertTrue(Http2TestServer.shutdownHttp2TestServer());
         if (mTestFramework.mCronetEngine != null) {
@@ skipping 33 matching lines @@
                 Arrays.asList(urls), statusCode, message, headersList, false, "h2", null);
         urlResponseInfo.setReceivedBytesCount(receivedBytes);
         return urlResponseInfo;
     }
 
     private void runSimpleGetWithExpectedReceivedBytesCount(int expectedReceivedBytes)
             throws Exception {
         String url = Http2TestServer.getEchoMethodUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .setHttpMethod("GET")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .setHttpMethod("GET")
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         // Default method is 'GET'.
         assertEquals("GET", callback.mResponseAsString);
         UrlResponseInfo urlResponseInfo = createUrlResponseInfo(
                 new String[] {url}, "", 200, expectedReceivedBytes, ":status", "200");
         assertResponseEquals(urlResponseInfo, callback.mResponseInfo);
         checkResponseInfo(callback.mResponseInfo, Http2TestServer.getEchoMethodUrl(), 200, "");
     }
 
     @SmallTest
     @Feature({"Cronet"})
+    @OnlyRunNativeCronet

[pauljensen, 2016/09/26 14:51:22]

perhaps we should run with the java-only impl and test that the appropriate
exception is thrown when newBidirectionalStreamBuilder is called?

[kapishnikov, 2016/09/27 18:38:26]

I will add a new test.

[kapishnikov, 2016/09/30 16:01:43]

Done.

     public void testBuilderChecks() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         try {
-            new BidirectionalStream.Builder(
-                    null, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+            mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                    null, callback, callback.getExecutor());
             fail("URL not null-checked");
         } catch (NullPointerException e) {
             assertEquals("URL is required.", e.getMessage());
         }
         try {
-            new BidirectionalStream.Builder(Http2TestServer.getServerUrl(), null,
-                    callback.getExecutor(), mTestFramework.mCronetEngine);
+            mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                    Http2TestServer.getServerUrl(), null, callback.getExecutor());
             fail("Callback not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Callback is required.", e.getMessage());
         }
         try {
-            new BidirectionalStream.Builder(
-                    Http2TestServer.getServerUrl(), callback, null, mTestFramework.mCronetEngine);
+            mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                    Http2TestServer.getServerUrl(), callback, null);
             fail("Executor not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Executor is required.", e.getMessage());
         }
-        try {
-            new BidirectionalStream.Builder(
-                    Http2TestServer.getServerUrl(), callback, callback.getExecutor(), null);
-            fail("CronetEngine not null-checked");
-        } catch (NullPointerException e) {
-            assertEquals("CronetEngine is required.", e.getMessage());
-        }
         // Verify successful creation doesn't throw.
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getServerUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getServerUrl(), callback, callback.getExecutor());
         try {
             builder.addHeader(null, "value");
             fail("Header name is not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Invalid header name.", e.getMessage());
         }
         try {
             builder.addHeader("name", null);
             fail("Header value is not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Invalid header value.", e.getMessage());
         }
         try {
             builder.setHttpMethod(null);
             fail("Method name is not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Method is required.", e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testFailPlainHttp() throws Exception {
         String url = "http://example.com";
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals("Exception in BidirectionalStream: net::ERR_DISALLOWED_URL_SCHEME",
                 callback.mError.getMessage());
         assertEquals(-301, callback.mError.getCronetInternalErrorCode());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimpleGet() throws Exception {
         // Since this is the first request on the connection, the expected received bytes count
         // must account for an HPACK dynamic table size update.
         runSimpleGetWithExpectedReceivedBytesCount(31);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimpleHead() throws Exception {
         String url = Http2TestServer.getEchoMethodUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .setHttpMethod("HEAD")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .setHttpMethod("HEAD")
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("HEAD", callback.mResponseAsString);
         UrlResponseInfo urlResponseInfo =
                 createUrlResponseInfo(new String[] {url}, "", 200, 32, ":status", "200");
         assertResponseEquals(urlResponseInfo, callback.mResponseInfo);
         checkResponseInfo(callback.mResponseInfo, Http2TestServer.getEchoMethodUrl(), 200, "");
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimplePost() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.addWriteData("Test String".getBytes());
         callback.addWriteData("1234567890".getBytes());
         callback.addWriteData("woot!".getBytes());
         TestExecutor testExecutor = new TestExecutor();
         TestRequestFinishedListener requestFinishedListener =
                 new TestRequestFinishedListener(testExecutor);
         mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .addHeader("foo", "bar")
-                                             .addHeader("empty", "")
-                                             .addHeader("Content-Type", "zebra")
-                                             .addRequestAnnotation(this)
-                                             .addRequestAnnotation("request annotation")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .addRequestAnnotation(this)
+                        .addRequestAnnotation("request annotation")
+                        .addHeader("foo", "bar")
+                        .addHeader("empty", "")
+                        .addHeader("Content-Type", "zebra")
+                        .build();
         stream.start();
         callback.blockForDone();
         testExecutor.runAllTasks();
         assertTrue(stream.isDone());
         RequestFinishedInfo finishedInfo = requestFinishedListener.getRequestInfo();
         assertNotNull("RequestFinishedInfo.Listener must be called", finishedInfo);
         assertEquals(url, finishedInfo.getUrl());
         assertEquals(newHashSet("request annotation", this),
                 new HashSet<Object>(finishedInfo.getAnnotations()));
         assertNotNull(finishedInfo.getResponseInfo());
         // TODO(xunjieli): Check other fields once metrics support is in crbug.com/648346.
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("Test String1234567890woot!", callback.mResponseAsString);
         assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
         assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
         assertEquals(
                 "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimplePostWithFlush() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.addWriteData("Test String".getBytes(), false);
         callback.addWriteData("1234567890".getBytes(), false);
         callback.addWriteData("woot!".getBytes(), true);
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .addHeader("foo", "bar")
-                                             .addHeader("empty", "")
-                                             .addHeader("Content-Type", "zebra")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .addHeader("foo", "bar")
+                        .addHeader("empty", "")
+                        .addHeader("Content-Type", "zebra")
+                        .build();
         // Flush before stream is started should not crash.
         stream.flush();
 
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
 
         // Flush after stream is completed is no-op. It shouldn't call into the destroyed adapter.
         stream.flush();
 
@@ skipping 51 matching lines @@
                             ((CronetBidirectionalStream) stream).getFlushDataForTesting().size());
                 }
             }
         };
         callback.addWriteData("1".getBytes(), false);
         callback.addWriteData("2".getBytes(), false);
         callback.addWriteData("3".getBytes(), true);
         callback.addWriteData("4".getBytes(), false);
         callback.addWriteData("5".getBytes(), true);
         callback.addWriteData("6".getBytes(), false);
-        CronetBidirectionalStream stream = (CronetBidirectionalStream) new BidirectionalStream
-                                                   .Builder(url, callback, callback.getExecutor(),
-                                                           mTestFramework.mCronetEngine)
-                                                   .addHeader("foo", "bar")
-                                                   .addHeader("empty", "")
-                                                   .addHeader("Content-Type", "zebra")
-                                                   .build();
+        CronetBidirectionalStream stream =
+                (CronetBidirectionalStream) mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .addHeader("foo", "bar")
+                        .addHeader("empty", "")
+                        .addHeader("Content-Type", "zebra")
+                        .build();
         callback.setAutoAdvance(false);
         stream.start();
         callback.waitForNextWriteStep(); // onStreamReady
 
         assertEquals(0, stream.getPendingDataForTesting().size());
         assertEquals(0, stream.getFlushDataForTesting().size());
 
         // Write 1, 2, 3 and flush().
         callback.startNextWrite(stream);
         // Write 4, 5 and flush(). 4, 5 will be in flush queue.
@@ skipping 32 matching lines @@
                     stream.flush();
                     super.onStreamReady(stream);
                     try {
                         // Attempt to write data for GET request.
                         stream.write(ByteBuffer.wrap("dummy".getBytes()), true);
                     } catch (IllegalArgumentException e) {
                         // Expected.
                     }
                 }
             };
-            BidirectionalStream stream = new BidirectionalStream
-                                                 .Builder(url, callback, callback.getExecutor(),
-                                                         mTestFramework.mCronetEngine)
-                                                 .setHttpMethod("GET")
-                                                 .delayRequestHeadersUntilFirstFlush(i == 0)
-                                                 .addHeader("foo", "bar")
-                                                 .addHeader("empty", "")
-                                                 .build();
+            BidirectionalStream stream =
+                    mTestFramework.mCronetEngine
+                            .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                            .setHttpMethod("GET")
+                            .delayRequestHeadersUntilFirstFlush(i == 0)
+                            .addHeader("foo", "bar")
+                            .addHeader("empty", "")
+                            .build();
             // Flush before stream is started should not crash.
             stream.flush();
 
             stream.start();
             callback.blockForDone();
             assertTrue(stream.isDone());
 
             // Flush after stream is completed is no-op. It shouldn't call into the destroyed
             // adapter.
             stream.flush();
 
             assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
             assertEquals("", callback.mResponseAsString);
             assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
             assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimplePostWithFlushAfterOneWrite() throws Exception {
         // TODO(xunjieli): Use ParameterizedTest instead of the loop.
         for (int i = 0; i < 2; i++) {
             String url = Http2TestServer.getEchoStreamUrl();
             TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
             callback.addWriteData("Test String".getBytes(), true);
-            BidirectionalStream stream = new BidirectionalStream
-                                                 .Builder(url, callback, callback.getExecutor(),
-                                                         mTestFramework.mCronetEngine)
-                                                 .delayRequestHeadersUntilFirstFlush(i == 0)
-                                                 .addHeader("foo", "bar")
-                                                 .addHeader("empty", "")
-                                                 .addHeader("Content-Type", "zebra")
-                                                 .build();
+            BidirectionalStream stream =
+                    mTestFramework.mCronetEngine
+                            .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                            .delayRequestHeadersUntilFirstFlush(i == 0)
+                            .addHeader("foo", "bar")
+                            .addHeader("empty", "")
+                            .addHeader("Content-Type", "zebra")
+                            .build();
             stream.start();
             callback.blockForDone();
             assertTrue(stream.isDone());
 
             assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
             assertEquals("Test String", callback.mResponseAsString);
             assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
             assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
             assertEquals("zebra",
                     callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimplePostWithFlushTwice() throws Exception {
         // TODO(xunjieli): Use ParameterizedTest instead of the loop.
         for (int i = 0; i < 2; i++) {
             String url = Http2TestServer.getEchoStreamUrl();
             TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
             callback.addWriteData("Test String".getBytes(), false);
             callback.addWriteData("1234567890".getBytes(), false);
             callback.addWriteData("woot!".getBytes(), true);
             callback.addWriteData("Test String".getBytes(), false);
             callback.addWriteData("1234567890".getBytes(), false);
             callback.addWriteData("woot!".getBytes(), true);
-            BidirectionalStream stream = new BidirectionalStream
-                                                 .Builder(url, callback, callback.getExecutor(),
-                                                         mTestFramework.mCronetEngine)
-                                                 .delayRequestHeadersUntilFirstFlush(i == 0)
-                                                 .addHeader("foo", "bar")
-                                                 .addHeader("empty", "")
-                                                 .addHeader("Content-Type", "zebra")
-                                                 .build();
+            BidirectionalStream stream =
+                    mTestFramework.mCronetEngine
+                            .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                            .delayRequestHeadersUntilFirstFlush(i == 0)
+                            .addHeader("foo", "bar")
+                            .addHeader("empty", "")
+                            .addHeader("Content-Type", "zebra")
+                            .build();
             stream.start();
             callback.blockForDone();
             assertTrue(stream.isDone());
             assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
             assertEquals("Test String1234567890woot!Test String1234567890woot!",
                     callback.mResponseAsString);
             assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
             assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
             assertEquals("zebra",
                     callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
@@ skipping 14 matching lines @@
             }
             @Override
             public void onResponseHeadersReceived(
                     BidirectionalStream stream, UrlResponseInfo info) {
                 // Do nothing. Skip readng.
             }
         };
         callback.addWriteData("Test String".getBytes());
         callback.addWriteData("1234567890".getBytes());
         callback.addWriteData("woot!".getBytes());
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .addHeader("foo", "bar")
-                                             .addHeader("empty", "")
-                                             .addHeader("Content-Type", "zebra")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .addHeader("foo", "bar")
+                        .addHeader("empty", "")
+                        .addHeader("Content-Type", "zebra")
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("Test String1234567890woot!", callback.mResponseAsString);
         assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
         assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
         assertEquals(
                 "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
     }
@@ skipping 13 matching lines @@
                 startNextWrite(stream);
                 assertEquals(0, numPendingWrites());
             }
         };
         callback.addWriteData("Test String".getBytes(), false);
         callback.addWriteData("1234567890".getBytes(), false);
         callback.addWriteData("woot!".getBytes(), true);
         callback.addWriteData("Test String".getBytes(), false);
         callback.addWriteData("1234567890".getBytes(), false);
         callback.addWriteData("woot!".getBytes(), true);
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .addHeader("foo", "bar")
-                                             .addHeader("empty", "")
-                                             .addHeader("Content-Type", "zebra")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .addHeader("foo", "bar")
+                        .addHeader("empty", "")
+                        .addHeader("Content-Type", "zebra")
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(
                 "Test String1234567890woot!Test String1234567890woot!", callback.mResponseAsString);
         assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
         assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
         assertEquals(
                 "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimplePut() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.addWriteData("Put This Data!".getBytes());
         String methodName = "PUT";
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getServerUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getServerUrl(), callback, callback.getExecutor());
         builder.setHttpMethod(methodName);
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("Put This Data!", callback.mResponseAsString);
         assertEquals(methodName, callback.mResponseInfo.getAllHeaders().get("echo-method").get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testBadMethod() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getServerUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getServerUrl(), 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"})
     @OnlyRunNativeCronet
     public void testBadHeaderName() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getServerUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getServerUrl(), callback, callback.getExecutor());
         try {
             builder.addHeader("goodheader1", "headervalue");
             builder.addHeader("header:name", "headervalue");
             builder.addHeader("goodheader2", "headervalue");
             builder.build().start();
             fail("IllegalArgumentException not thrown.");
         } catch (IllegalArgumentException e) {
             assertEquals("Invalid header header:name=headervalue", e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testBadHeaderValue() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getServerUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getServerUrl(), 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"})
     @OnlyRunNativeCronet
     public void testAddHeader() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         String headerName = "header-name";
         String headerValue = "header-value";
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoHeaderUrl(headerName),
-                        callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoHeaderUrl(headerName), callback,
+                        callback.getExecutor());
         builder.addHeader(headerName, headerValue);
         builder.setHttpMethod("GET");
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(headerValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testMultiRequestHeaders() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         String headerName = "header-name";
         String headerValue1 = "header-value1";
         String headerValue2 = "header-value2";
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoAllHeadersUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoAllHeadersUrl(), callback, callback.getExecutor());
         builder.addHeader(headerName, headerValue1);
         builder.addHeader(headerName, headerValue2);
         builder.setHttpMethod("GET");
         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"})
     @OnlyRunNativeCronet
     public void testEchoTrailers() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         String headerName = "header-name";
         String headerValue = "header-value";
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoTrailersUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoTrailersUrl(), callback, callback.getExecutor());
         builder.addHeader(headerName, headerValue);
         builder.setHttpMethod("GET");
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertNotNull(callback.mTrailers);
         // Verify that header value is properly echoed in trailers.
         assertEquals(headerValue, callback.mTrailers.getAsMap().get("echo-" + headerName).get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testCustomUserAgent() throws Exception {
         String userAgentName = "User-Agent";
         String userAgentValue = "User-Agent-Value";
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoHeaderUrl(userAgentName),
-                        callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoHeaderUrl(userAgentName), callback,
+                        callback.getExecutor());
         builder.setHttpMethod("GET");
         builder.addHeader(userAgentName, userAgentValue);
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(userAgentValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testCustomCronetEngineUserAgent() throws Exception {
         String userAgentName = "User-Agent";
         String userAgentValue = "User-Agent-Value";
-        CronetEngine engine =
-                new CronetEngine.Builder(getContext())
-                        .setMockCertVerifierForTesting(QuicTestServer.createMockCertVerifier())
-                        .setUserAgent(userAgentValue)
-                        .build();
+        ExperimentalCronetEngine.Builder engineBuilder =
+                new ExperimentalCronetEngine.Builder(getContext());
+        engineBuilder.setUserAgent(userAgentValue);
+        CronetTestUtil.setMockCertVerifierForTesting(
+                engineBuilder, QuicTestServer.createMockCertVerifier());
+        ExperimentalCronetEngine engine = engineBuilder.build();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
-        BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoHeaderUrl(userAgentName),
-                        callback, callback.getExecutor(), engine);
+        BidirectionalStream.Builder builder = engine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoHeaderUrl(userAgentName), callback, callback.getExecutor());
         builder.setHttpMethod("GET");
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(userAgentValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testDefaultUserAgent() throws Exception {
         String userAgentName = "User-Agent";
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoHeaderUrl(userAgentName),
-                        callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoHeaderUrl(userAgentName), callback,
+                        callback.getExecutor());
         builder.setHttpMethod("GET");
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(new CronetEngine.Builder(getContext()).getDefaultUserAgent(),
                 callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEchoStream() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         String[] testData = {"Test String", createLongString("1234567890", 50000), "woot!"};
         StringBuilder stringData = new StringBuilder();
         for (String writeData : testData) {
             callback.addWriteData(writeData.getBytes());
             stringData.append(writeData);
         }
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .addHeader("foo", "Value with Spaces")
-                                             .addHeader("Content-Type", "zebra")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .addHeader("foo", "Value with Spaces")
+                        .addHeader("Content-Type", "zebra")
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(stringData.toString(), callback.mResponseAsString);
         assertEquals(
                 "Value with Spaces", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
         assertEquals(
                 "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEchoStreamEmptyWrite() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.addWriteData(new byte[0]);
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testDoubleWrite() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback() {
             @Override
             public void onStreamReady(BidirectionalStream stream) {
                 // super class will call Write() once.
                 super.onStreamReady(stream);
                 // Call Write() again.
                 startNextWrite(stream);
                 // Make sure there is no pending write.
                 assertEquals(0, numPendingWrites());
             }
         };
         callback.addWriteData("1".getBytes());
         callback.addWriteData("2".getBytes());
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("12", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
@@ skipping 11 matching lines @@
                     stream.read(ByteBuffer.allocateDirect(5));
                     fail("Exception is not thrown.");
                 } catch (Exception e) {
                     assertEquals("Unexpected read attempt.", e.getMessage());
                 }
             }
         };
         callback.addWriteData("1".getBytes());
         callback.addWriteData("2".getBytes());
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("12", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     @DisabledTest(message = "Disabled due to timeout. See crbug.com/591112")
     public void testReadAndWrite() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback() {
             @Override
             public void onResponseHeadersReceived(
                     BidirectionalStream stream, UrlResponseInfo info) {
                 // Start the write, that will not complete until callback completion.
                 startNextWrite(stream);
                 // Start the read. It is allowed with write in flight.
                 super.onResponseHeadersReceived(stream, info);
             }
         };
         callback.setAutoAdvance(false);
         callback.addWriteData("1".getBytes());
         callback.addWriteData("2".getBytes());
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .build();
         stream.start();
         callback.waitForNextWriteStep();
         callback.waitForNextReadStep();
         callback.startNextRead(stream);
         callback.setAutoAdvance(true);
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("12", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEchoStreamWriteFirst() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setAutoAdvance(false);
         String[] testData = {"a", "bb", "ccc", "Test String", "1234567890", "woot!"};
         StringBuilder stringData = new StringBuilder();
         for (String writeData : testData) {
             callback.addWriteData(writeData.getBytes());
             stringData.append(writeData);
         }
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .build();
         stream.start();
         // Write first.
         callback.waitForNextWriteStep(); // onStreamReady
         for (String expected : testData) {
             // Write next chunk of test data.
             callback.startNextWrite(stream);
             callback.waitForNextWriteStep(); // onWriteCompleted
         }
 
         // Wait for read step, but don't read yet.
@@ skipping 21 matching lines @@
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setAutoAdvance(false);
         String[] testData = {"a", "bb", "ccc", "Test String", "1234567890", "woot!"};
         StringBuilder stringData = new StringBuilder();
         for (String writeData : testData) {
             callback.addWriteData(writeData.getBytes());
             stringData.append(writeData);
         }
         // Create stream.
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(url, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                        .build();
         stream.start();
         callback.waitForNextWriteStep();
         callback.waitForNextReadStep();
 
         for (String expected : testData) {
             // Write next chunk of test data.
             callback.startNextWrite(stream);
             callback.waitForNextWriteStep();
 
             // Read next chunk of test data.
@@ skipping 16 matching lines @@
      * Checks that the buffer is updated correctly, when starting at an offset.
      */
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimpleGetBufferUpdates() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setAutoAdvance(false);
         // Since the method is "GET", the expected response body is also "GET".
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoMethodUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         BidirectionalStream stream = builder.setHttpMethod("GET").build();
         stream.start();
         callback.waitForNextReadStep();
 
         assertEquals(null, callback.mError);
         assertFalse(callback.isDone());
         assertEquals(TestBidirectionalStreamCallback.ResponseStep.ON_RESPONSE_STARTED,
                 callback.mResponseStep);
 
         ByteBuffer readBuffer = ByteBuffer.allocateDirect(5);
@@ skipping 71 matching lines @@
         runSimpleGetWithExpectedReceivedBytesCount(27);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testBadBuffers() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setAutoAdvance(false);
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoMethodUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         BidirectionalStream stream = builder.setHttpMethod("GET").build();
         stream.start();
         callback.waitForNextReadStep();
 
         assertEquals(null, callback.mError);
         assertFalse(callback.isDone());
         assertEquals(TestBidirectionalStreamCallback.ResponseStep.ON_RESPONSE_STARTED,
                 callback.mResponseStep);
 
         // Try to read using a full buffer.
@@ skipping 22 matching lines @@
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("GET", callback.mResponseAsString);
     }
 
     private void throwOrCancel(
             FailureType failureType, ResponseStep failureStep, boolean expectError) {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setFailure(failureType, failureStep);
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoMethodUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         BidirectionalStream stream = builder.setHttpMethod("GET").build();
         stream.start();
         callback.blockForDone();
         // assertEquals(callback.mResponseStep, failureStep);
         assertTrue(stream.isDone());
         // Cancellation when stream is ready does not guarantee that
         // mResponseInfo is null because there might be a
         // onResponseHeadersReceived already queued in the executor.
         // See crbug.com/594432.
         if (failureStep != ResponseStep.ON_STREAM_READY) {
@@ skipping 29 matching lines @@
         throwOrCancel(FailureType.THROW_SYNC, ResponseStep.ON_READ_COMPLETED, true);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testThrowOnSucceeded() {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setFailure(FailureType.THROW_SYNC, ResponseStep.ON_SUCCEEDED);
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoMethodUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         BidirectionalStream stream = builder.setHttpMethod("GET").build();
         stream.start();
         callback.blockForDone();
         assertEquals(callback.mResponseStep, ResponseStep.ON_SUCCEEDED);
         assertTrue(stream.isDone());
         assertNotNull(callback.mResponseInfo);
         // Check that error thrown from 'onSucceeded' callback is not reported.
         assertNull(callback.mError);
         assertFalse(callback.mOnErrorCalled);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testExecutorShutdownBeforeStreamIsDone() {
         // Test that stream is destroyed even if executor is shut down and rejects posting tasks.
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setAutoAdvance(false);
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoMethodUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         CronetBidirectionalStream stream =
                 (CronetBidirectionalStream) builder.setHttpMethod("GET").build();
         stream.start();
         callback.waitForNextReadStep();
         assertFalse(callback.isDone());
         assertFalse(stream.isDone());
 
         final ConditionVariable streamDestroyed = new ConditionVariable(false);
         stream.setOnDestroyedCallbackForTesting(new Runnable() {
             @Override
@@ skipping 48 matching lines @@
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testCronetEngineShutdown() throws Exception {
         // Test that CronetEngine cannot be shut down if there are any active streams.
         TestBidirectionalStreamCallback callback = new ShutdownTestBidirectionalStreamCallback();
         // Block callback when response starts to verify that shutdown fails
         // if there are active streams.
         callback.setAutoAdvance(false);
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoMethodUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         CronetBidirectionalStream stream =
                 (CronetBidirectionalStream) builder.setHttpMethod("GET").build();
         stream.start();
         try {
             mTestFramework.mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Cannot shutdown with active requests.", e.getMessage());
         }
 
@@ skipping 23 matching lines @@
         callback.blockForDone();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testCronetEngineShutdownAfterStreamFailure() throws Exception {
         // Test that CronetEngine can be shut down after stream reports a failure.
         TestBidirectionalStreamCallback callback = new ShutdownTestBidirectionalStreamCallback();
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoMethodUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         CronetBidirectionalStream stream =
                 (CronetBidirectionalStream) builder.setHttpMethod("GET").build();
         stream.start();
         callback.setFailure(FailureType.THROW_SYNC, ResponseStep.ON_READ_COMPLETED);
         callback.blockForDone();
         assertTrue(callback.mOnErrorCalled);
         assertNull(mTestFramework.mCronetEngine);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testCronetEngineShutdownAfterStreamCancel() throws Exception {
         // Test that CronetEngine can be shut down after stream is canceled.
         TestBidirectionalStreamCallback callback = new ShutdownTestBidirectionalStreamCallback();
         BidirectionalStream.Builder builder =
-                new BidirectionalStream.Builder(Http2TestServer.getEchoMethodUrl(), callback,
-                        callback.getExecutor(), mTestFramework.mCronetEngine);
+                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         CronetBidirectionalStream stream =
                 (CronetBidirectionalStream) builder.setHttpMethod("GET").build();
 
         // Block callback when response starts to verify that shutdown fails
         // if there are active requests.
         callback.setAutoAdvance(false);
         stream.start();
         try {
             mTestFramework.mCronetEngine.shutdown();
             fail("Should throw an exception");
@@ skipping 13 matching lines @@
     private static 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);
     }
 }