Cronet API Refactoring

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

 // Copyright 2016 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.test.suitebuilder.annotation.SmallTest;
 
 import org.json.JSONObject;
 
 import org.chromium.base.test.util.Feature;
-import org.chromium.net.CronetTestBase.OnlyRunNativeCronet;
 import org.chromium.net.MetricsTestUtil.TestRequestFinishedListener;
 
 import java.nio.ByteBuffer;
 import java.util.Date;
 import java.util.HashSet;
 
 /**
  * Tests functionality of BidirectionalStream's QUIC implementation.
  */
 public class BidirectionalStreamQuicTest extends CronetTestBase {
     private CronetTestFramework mTestFramework;
     private enum QuicBidirectionalStreams {
         ENABLED,
         DISABLED,
     }
 
     private void setUp(QuicBidirectionalStreams enabled) throws Exception {
         // Load library first to create MockCertVerifier.
         System.loadLibrary("cronet_tests");
-        CronetEngine.Builder builder = new CronetEngine.Builder(getContext());
+        ExperimentalCronetEngine.Builder builder =
+                new ExperimentalCronetEngine.Builder(getContext());
 
         QuicTestServer.startQuicTestServer(getContext());
 
         builder.enableQuic(true);
         JSONObject quicParams = new JSONObject().put("host_whitelist", "test.example.com");
         if (enabled == QuicBidirectionalStreams.DISABLED) {
             quicParams.put("quic_disable_bidirectional_streams", true);
         }
         JSONObject hostResolverParams = CronetTestUtil.generateHostResolverRules();
         JSONObject experimentalOptions = new JSONObject()
                                                  .put("QUIC", quicParams)
                                                  .put("HostResolverRules", hostResolverParams);
         builder.setExperimentalOptions(experimentalOptions.toString());
 
         builder.addQuicHint(QuicTestServer.getServerHost(), QuicTestServer.getServerPort(),
                 QuicTestServer.getServerPort());
 
-        builder.setMockCertVerifierForTesting(QuicTestServer.createMockCertVerifier());
+        CronetTestUtil.setMockCertVerifierForTesting(
+                builder, QuicTestServer.createMockCertVerifier());
 
         mTestFramework = startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, builder);
     }
 
     @Override
     protected void tearDown() throws Exception {
         QuicTestServer.shutdownQuicTestServer();
         super.tearDown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     // Test that QUIC is negotiated.
     public void testSimpleGet() throws Exception {
         setUp(QuicBidirectionalStreams.ENABLED);
         String path = "/simple.txt";
         String quicURL = QuicTestServer.getServerURL() + path;
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(quicURL, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .setHttpMethod("GET")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(quicURL, callback, callback.getExecutor())
+                        .setHttpMethod("GET")
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("This is a simple text file served by QUIC.\n", callback.mResponseAsString);
         assertEquals("quic/1+spdy/3", callback.mResponseInfo.getNegotiatedProtocol());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimplePost() throws Exception {
         setUp(QuicBidirectionalStreams.ENABLED);
         String path = "/simple.txt";
         String quicURL = QuicTestServer.getServerURL() + path;
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         // Although we have no way to verify data sent at this point, this test
         // can make sure that onWriteCompleted is invoked appropriately.
         callback.addWriteData("Test String".getBytes());
         callback.addWriteData("1234567890".getBytes());
         callback.addWriteData("woot!".getBytes());
         TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
         mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(quicURL, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .addHeader("foo", "bar")
-                                             .addHeader("empty", "")
-                                             .addHeader("Content-Type", "zebra")
-                                             .addRequestAnnotation("request annotation")
-                                             .addRequestAnnotation(this)
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(quicURL, callback, callback.getExecutor())
+                        .addHeader("foo", "bar")
+                        .addHeader("empty", "")
+                        .addHeader("Content-Type", "zebra")
+                        .addRequestAnnotation("request annotation")
+                        .addRequestAnnotation(this)
+                        .build();
         Date startTime = new Date();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         requestFinishedListener.blockUntilDone();
         Date endTime = new Date();
         RequestFinishedInfo finishedInfo = requestFinishedListener.getRequestInfo();
         assertNotNull("RequestFinishedInfo.Listener must be called", finishedInfo);
         RequestFinishedInfo.Metrics metrics = finishedInfo.getMetrics();
         assertNotNull(metrics);
@@ skipping 18 matching lines @@
         // TODO(xunjieli): Use ParameterizedTest instead of the loop.
         for (int i = 0; i < 2; i++) {
             String path = "/simple.txt";
             String quicURL = QuicTestServer.getServerURL() + path;
             TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
             // Although we have no way to verify data sent at this point, this test
             // can make sure that onWriteCompleted is invoked appropriately.
             callback.addWriteData("Test String".getBytes(), false);
             callback.addWriteData("1234567890".getBytes(), false);
             callback.addWriteData("woot!".getBytes(), true);
-            BidirectionalStream stream = new BidirectionalStream
-                                                 .Builder(quicURL, callback, callback.getExecutor(),
-                                                         mTestFramework.mCronetEngine)
+            BidirectionalStream stream = mTestFramework.mCronetEngine
+                                                 .newBidirectionalStreamBuilder(
+                                                         quicURL, 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(
@@ skipping 13 matching lines @@
             String quicURL = QuicTestServer.getServerURL() + path;
             TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
             // Although we have no way to verify data sent at this point, this test
             // can make sure that onWriteCompleted is invoked appropriately.
             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(quicURL, callback, callback.getExecutor(),
-                                                         mTestFramework.mCronetEngine)
+            BidirectionalStream stream = mTestFramework.mCronetEngine
+                                                 .newBidirectionalStreamBuilder(
+                                                         quicURL, 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(
@@ skipping 13 matching lines @@
             String url = QuicTestServer.getServerURL() + path;
 
             TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback() {
                 @Override
                 public void onStreamReady(BidirectionalStream stream) {
                     // This flush should send the delayed headers.
                     stream.flush();
                     super.onStreamReady(stream);
                 }
             };
-            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();
@@ skipping 10 matching lines @@
     @OnlyRunNativeCronet
     public void testSimplePostWithFlushAfterOneWrite() throws Exception {
         setUp(QuicBidirectionalStreams.ENABLED);
         // TODO(xunjieli): Use ParameterizedTest instead of the loop.
         for (int i = 0; i < 2; i++) {
             String path = "/simple.txt";
             String url = QuicTestServer.getServerURL() + path;
 
             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(
                     "This is a simple text file served by QUIC.\n", callback.mResponseAsString);
             assertEquals("quic/1+spdy/3", callback.mResponseInfo.getNegotiatedProtocol());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testQuicBidirectionalStreamDisabled() throws Exception {
         setUp(QuicBidirectionalStreams.DISABLED);
         String path = "/simple.txt";
         String quicURL = QuicTestServer.getServerURL() + path;
 
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(quicURL, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .setHttpMethod("GET")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(quicURL, callback, callback.getExecutor())
+                        .setHttpMethod("GET")
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertTrue(callback.mOnErrorCalled);
         assertNull(callback.mResponseInfo);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
@@ skipping 15 matching lines @@
                 // Shut down the server, and the stream should error out.
                 // The second call to shutdownQuicTestServer is no-op.
                 QuicTestServer.shutdownQuicTestServer();
             }
         };
 
         callback.addWriteData("Test String".getBytes());
         callback.addWriteData("1234567890".getBytes());
         callback.addWriteData("woot!".getBytes());
 
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(quicURL, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .addHeader("foo", "bar")
-                                             .addHeader("empty", "")
-                                             .addHeader("Content-Type", "zebra")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(quicURL, callback, callback.getExecutor())
+                        .addHeader("foo", "bar")
+                        .addHeader("empty", "")
+                        .addHeader("Content-Type", "zebra")
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         // Server terminated on us, so the stream must fail.
         // QUIC reports this as ERR_QUIC_PROTOCOL_ERROR. Sometimes we get ERR_CONNECTION_REFUSED.
         assertNotNull(callback.mError);
         assertTrue(NetError.ERR_QUIC_PROTOCOL_ERROR == callback.mError.getCronetInternalErrorCode()
                 || NetError.ERR_CONNECTION_REFUSED == callback.mError.getCronetInternalErrorCode());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     // Test that certificate verify results are serialized and deserialized correctly.
     public void testSerializeDeserialize() throws Exception {
         setUp(QuicBidirectionalStreams.ENABLED);
         String path = "/simple.txt";
         String quicURL = QuicTestServer.getServerURL() + path;
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
-        BidirectionalStream stream = new BidirectionalStream
-                                             .Builder(quicURL, callback, callback.getExecutor(),
-                                                     mTestFramework.mCronetEngine)
-                                             .setHttpMethod("GET")
-                                             .build();
+        BidirectionalStream stream =
+                mTestFramework.mCronetEngine
+                        .newBidirectionalStreamBuilder(quicURL, callback, callback.getExecutor())
+                        .setHttpMethod("GET")
+                        .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("This is a simple text file served by QUIC.\n", callback.mResponseAsString);
         assertEquals("quic/1+spdy/3", callback.mResponseInfo.getNegotiatedProtocol());
 
         String serialized_data = mTestFramework.mCronetEngine.getCertVerifierData(100);
         assertFalse(serialized_data.isEmpty());
 
         // Create a new builder and verify that the |serialized_data| is deserialized correctly.
-        CronetEngine.Builder builder = new CronetEngine.Builder(getContext());
+        ExperimentalCronetEngine.Builder builder =
+                new ExperimentalCronetEngine.Builder(getContext());
         builder.enableQuic(true);
-        builder.setMockCertVerifierForTesting(QuicTestServer.createMockCertVerifier());
+        CronetTestUtil.setMockCertVerifierForTesting(
+                builder, QuicTestServer.createMockCertVerifier());
         builder.setCertVerifierData(serialized_data);
 
         CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, builder);
         String deserialized_data = testFramework.mCronetEngine.getCertVerifierData(100);
         assertEquals(deserialized_data, serialized_data);
     }
 }