Cronet API Refactoring

components/cronet/android/test/javatests/src/org/chromium/net/PkpTest.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 android.test.suitebuilder.annotation.SmallTest;
 
+import org.json.JSONObject;
+
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.test.util.CertTestUtil;
-import org.json.JSONObject;
 
 import java.io.ByteArrayInputStream;
 import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
 import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.HashSet;
 import java.util.Set;
 
 /**
  * Public-Key-Pinning tests of Cronet Java API.
  */
 public class PkpTest extends CronetTestBase {
     private static final String CERT_USED = "quic_test.example.com.crt";
     private static final String[] CERTS_USED = {CERT_USED};
     private static final int DISTANT_FUTURE = Integer.MAX_VALUE;
     private static final boolean INCLUDE_SUBDOMAINS = true;
     private static final boolean EXCLUDE_SUBDOMAINS = false;
     private static final boolean KNOWN_ROOT = true;
     private static final boolean UNKNOWN_ROOT = false;
     private static final boolean ENABLE_PINNING_BYPASS_FOR_LOCAL_ANCHORS = true;
     private static final boolean DISABLE_PINNING_BYPASS_FOR_LOCAL_ANCHORS = false;
 
     private CronetTestFramework mTestFramework;
-    private CronetEngine.Builder mBuilder;
+    private ExperimentalCronetEngine.Builder mBuilder;
     private TestUrlRequestCallback mListener;
     private String mServerUrl; // https://test.example.com:6121
     private String mServerHost; // test.example.com
     private String mDomain; // example.com
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         // Start QUIC Test Server
         System.loadLibrary("cronet_tests");
@@ skipping 332 matching lines @@
             fail("Did not expect an error but got error code "
                     + mListener.mError.getCronetInternalErrorCode());
         }
         assertNotNull("Expected non-null response from the server", mListener.mResponseInfo);
         assertEquals(200, mListener.mResponseInfo.getHttpStatusCode());
     }
 
     private void createCronetEngineBuilder(boolean bypassPinningForLocalAnchors, boolean knownRoot)
             throws Exception {
         // Set common CronetEngine parameters
-        mBuilder = new CronetEngine.Builder(getContext());
+        mBuilder = new ExperimentalCronetEngine.Builder(getContext());
         mBuilder.enablePublicKeyPinningBypassForLocalTrustAnchors(bypassPinningForLocalAnchors);
         mBuilder.enableQuic(true);
         mBuilder.addQuicHint(QuicTestServer.getServerHost(), QuicTestServer.getServerPort(),
                 QuicTestServer.getServerPort());
         JSONObject quicParams = new JSONObject().put("host_whitelist", "test.example.com");
         JSONObject hostResolverParams = CronetTestUtil.generateHostResolverRules();
         JSONObject experimentalOptions = new JSONObject()
                                                  .put("QUIC", quicParams)
                                                  .put("HostResolverRules", hostResolverParams);
         mBuilder.setExperimentalOptions(experimentalOptions.toString());
         mBuilder.setStoragePath(CronetTestFramework.getTestStorage(getContext()));
         mBuilder.enableHttpCache(CronetEngine.Builder.HTTP_CACHE_DISK_NO_HTTP, 1000 * 1024);
-        mBuilder.setMockCertVerifierForTesting(
-                MockCertVerifier.createMockCertVerifier(CERTS_USED, knownRoot));
+        CronetTestUtil.setMockCertVerifierForTesting(
+                mBuilder, MockCertVerifier.createMockCertVerifier(CERTS_USED, knownRoot));
     }
 
     private void startCronetFramework() {
         mTestFramework = startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mBuilder);
     }
 
     private void shutdownCronetEngine() {
         if (mTestFramework != null && mTestFramework.mCronetEngine != null) {
             mTestFramework.mCronetEngine.shutdown();
         }
     }
 
     private byte[] generateSomeSha256() {
         byte[] sha256 = new byte[32];
         Arrays.fill(sha256, (byte) 58);
         return sha256;
     }
 
     private void addPkpSha256(
             String host, byte[] pinHashValue, boolean includeSubdomain, int maxAgeInSec) {
         Set<byte[]> hashes = new HashSet<>();
         hashes.add(pinHashValue);
         mBuilder.addPublicKeyPins(host, hashes, includeSubdomain, dateInFuture(maxAgeInSec));
     }
 
     private void sendRequestAndWaitForResult() {
         mListener = new TestUrlRequestCallback();
 
         String quicURL = mServerUrl + "/simple.txt";
-        UrlRequest.Builder requestBuilder = new UrlRequest.Builder(
-                quicURL, mListener, mListener.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder requestBuilder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
+                quicURL, mListener, mListener.getExecutor());
         requestBuilder.build().start();
         mListener.blockForDone();
     }
 
     private X509Certificate readCertFromFileInPemFormat(String certFileName) throws Exception {
         byte[] certDer = CertTestUtil.pemToDer(CertTestUtil.CERTS_DIRECTORY + certFileName);
         CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
         return (X509Certificate) certFactory.generateCertificate(new ByteArrayInputStream(certDer));
     }
 
@@ skipping 35 matching lines @@
             if (!shouldThrowNpe) {
                 fail("Null pointer exception was not expected: " + ex.toString());
             }
             return;
         }
         if (shouldThrowNpe) {
             fail("NullPointerException was expected");
         }
     }
 }