[Cronet] Use Https for Quic Test Server

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

Index: components/cronet/android/test/javatests/src/org/chromium/net/QuicTest.java
diff --git a/components/cronet/android/test/javatests/src/org/chromium/net/QuicTest.java b/components/cronet/android/test/javatests/src/org/chromium/net/QuicTest.java
index 000d7cd8093d982391e77775b816e3cd9eb0427c..c225a11fad140c28419c81208235f6f0cf2d5696 100644
--- a/components/cronet/android/test/javatests/src/org/chromium/net/QuicTest.java
+++ b/components/cronet/android/test/javatests/src/org/chromium/net/QuicTest.java
@@ -23,6 +23,7 @@ import java.util.HashMap;
 public class QuicTest extends CronetTestBase {
     private static final String TAG = "cr.QuicTest";
     private CronetTestActivity mActivity;
+    private MockCertVerifier mCertVerifier;
 
     @Override
     protected void setUp() throws Exception {
@@ -30,12 +31,19 @@ public class QuicTest extends CronetTestBase {
         // Load library first, since we need the Quic test server's URL.
         System.loadLibrary("cronet_tests");
         QuicTestServer.startQuicTestServer(getInstrumentation().getTargetContext());
+
+        // Set up a MockCertVerifier to use in the tests.
+        String[] certs = {"quic_test.example.com.crt"};
+        mCertVerifier = new MockCertVerifier(certs);
+
         CronetEngine.Builder builder = new CronetEngine.Builder(mActivity);
         builder.enableQUIC(true);
         builder.addQuicHint(QuicTestServer.getServerHost(), QuicTestServer.getServerPort(),
                 QuicTestServer.getServerPort());
         builder.setExperimentalQuicConnectionOptions("PACE,IW10,FOO,DEADBEEF");
 
+        builder.setMockCertVerifierForTesting(mCertVerifier.getNativePointer());
+
         String[] commandLineArgs = {CronetTestActivity.CONFIG_KEY, builder.toString(),
                 CronetTestActivity.CACHE_KEY, CronetTestActivity.CACHE_DISK_NO_HTTP};
         mActivity = launchCronetTestAppWithUrlAndCommandLineArgs(null, commandLineArgs);

[pauljensen, 2015/10/15 19:13:07]

So, it looks like here we create a native pointer, serialize it to a string,
pass the string as an Intent argument and then deserialize the native pointer
and use it.  This is a little terrifying as Intents are generally used for IPC,
and a native pointer shouldn't be passed via IPC.  It works here because
instrumentation tests run in the same process.  I'm not sure I have a much
better idea.  A small improvement may be to create the MockCertVerifier inside
the CronetTestApp and insert it into the Builder there, so at least it's not
crossing an IPC boundary.  Maybe I'll think of something better tomorrow.

[pauljensen, 2015/10/16 13:03:49]

I guess a bigger question is why do we serialize a CronetEngine.Builder into
Intent arguments?
In launchCronetTestAppWithUrlAndCommandLineArgs() why don't we just cast the
resulting Activity to CronetTestActivity and call a setter function that takes a
CronetEngine.Builder?  I just checked and the resulting Activity in
launchCronetTestAppWithUrlAndCommandLineArgs() is in fact an instance of
CronetTestActivity.

[xunjieli, 2015/10/19 01:40:43]

With the builder serialized in intent arguments, we can create the CronetEngines
in onCreate(). If we have a setter, then we would need to move the
Builder.build() logic from onCreate() to somewhere else. And starting the
application won't initialize the mCronetEngine, which needs to be done in a
separate step.  I am not sure if that's cleaner.

I agree that it's a bit weird that this pointer is created in the
instrumentation app. But as you mentioned, the instrumentation app runs in the
same process as the test app, so there isn't a process boundary.

[pauljensen, 2015/10/19 11:43:31]

I think creating it here and passing it via a setter would be substantially
simpler:
1. We could hide the serialize/deserialize CronetEngine.Builder APIs
2. We could remove the serialize/deserialize logic in our tests, including:
     a. CronetTestActivity.createCronetEngineBuilder
     b. CronetTestActivity.SDCH_KEY
     c. CronetTestActivity.CONFIG_KEY

Actually, now I'm wondering, why do we have a test activity? why don't we simply
extend android.test.AndroidTestCase (a junit test with a Context)? 
Instrumentation tests are meant to test apps, but we just want to test Cronet (a
library not an app).  These are really unit tests, not app tests.

@@ -43,6 +51,7 @@ public class QuicTest extends CronetTestBase {
 
     @Override
     protected void tearDown() throws Exception {
+        mCertVerifier.destroyNativePointer();
         QuicTestServer.shutdownQuicTestServer();
         super.tearDown();
     }
@@ -50,6 +59,10 @@ public class QuicTest extends CronetTestBase {
     @SmallTest
     @Feature({"Cronet"})
     public void testQuicLoadUrl_LegacyAPI() throws Exception {
+        long urlRequestContextAdapter = ((ChromiumUrlRequestFactory) mActivity.mRequestFactory)
+                                                .getRequestContext()
+                                                .getUrlRequestContextAdapter();
+        NativeTestServer.registerHostResolverProc(urlRequestContextAdapter, true);
         String quicURL = QuicTestServer.getServerURL() + "/simple.txt";
 
         HashMap<String, String> headers = new HashMap<String, String>();
@@ -73,6 +86,10 @@ public class QuicTest extends CronetTestBase {
     @LargeTest
     @Feature({"Cronet"})
     public void testQuicLoadUrl() throws Exception {
+        long urlRequestContextAdapter =
+                ((CronetUrlRequestContext) mActivity.mCronetEngine).getUrlRequestContextAdapter();
+        NativeTestServer.registerHostResolverProc(urlRequestContextAdapter, false);
+
         String quicURL = QuicTestServer.getServerURL() + "/simple.txt";
         TestUrlRequestListener listener = new TestUrlRequestListener();
 
@@ -117,7 +134,11 @@ public class QuicTest extends CronetTestBase {
         builder.setStoragePath(mActivity.getTestStorage());
         builder.enableHttpCache(CronetEngine.Builder.HTTP_CACHE_DISK, 1000 * 1024);
         builder.enableQUIC(true);
+        builder.setMockCertVerifierForTesting(mCertVerifier.getNativePointer());
         CronetEngine newEngine = new CronetUrlRequestContext(builder);
+        long newUrlRequestContextAdapter =
+                ((CronetUrlRequestContext) newEngine).getUrlRequestContextAdapter();
+        NativeTestServer.registerHostResolverProc(newUrlRequestContextAdapter, false);
         TestUrlRequestListener listener2 = new TestUrlRequestListener();
         requestBuilder =
                 new UrlRequest.Builder(quicURL, listener2, listener2.getExecutor(), newEngine);