Add a whitelist for QUIC hosts.

components/cronet/android/test/javatests/src/org/chromium/net/QuicTest.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.LargeTest;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.chromium.base.Log;
@@ skipping 24 matching lines @@
         System.loadLibrary("cronet_tests");
         QuicTestServer.startQuicTestServer(getContext());
 
         mBuilder = new CronetEngine.Builder(getContext());
         mBuilder.enableQUIC(true);
         mBuilder.addQuicHint(QuicTestServer.getServerHost(), QuicTestServer.getServerPort(),
                 QuicTestServer.getServerPort());
 
         JSONObject quicParams = new JSONObject()
                                         .put("connection_options", "PACE,IW10,FOO,DEADBEEF")
+                                        .put("host_whitelist", "test.example.com")
                                         .put("store_server_configs_in_properties", true)
                                         .put("delay_tcp_race", true)
                                         .put("max_number_of_lossy_connections", 10)
                                         .put("packet_loss_threshold", 0.5)
                                         .put("idle_connection_timeout_seconds", 300);
         JSONObject experimentalOptions = new JSONObject().put("QUIC", quicParams);
         mBuilder.setExperimentalOptions(experimentalOptions.toString());
 
         mBuilder.setMockCertVerifierForTesting(MockCertVerifier.createMockCertVerifier(CERTS_USED));
         mBuilder.setStoragePath(CronetTestFramework.getTestStorage(getContext()));
@@ skipping 53 matching lines @@
         requestBuilder.build().start();
         callback.blockForDone();
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         String expectedContent = "This is a simple text file served by QUIC.\n";
         assertEquals(expectedContent, callback.mResponseAsString);
         assertEquals("quic/1+spdy/3", callback.mResponseInfo.getNegotiatedProtocol());
         // The total received bytes should be larger than the content length, to account for
         // headers.
         assertTrue(callback.mResponseInfo.getReceivedBytesCount() > expectedContent.length());
-
         // This test takes a long time, since the update will only be scheduled
         // after kUpdatePrefsDelayMs in http_server_properties_manager.cc.
         while (true) {
             Log.i(TAG, "Still waiting for pref file update.....");
             Thread.sleep(10000);
             boolean contains = false;
             try {
                 if (fileContainsString("local_prefs.json", "quic")) break;
             } catch (FileNotFoundException e) {
                 // Ignored this exception since the file will only be created when updates are
                 // flushed to the disk.
             }
         }
         assertTrue(fileContainsString("local_prefs.json",
                 QuicTestServer.getServerHost() + ":" + QuicTestServer.getServerPort()));
         mTestFramework.mCronetEngine.shutdown();
 
         // Make another request using a new context but with no QUIC hints.
         CronetEngine.Builder builder = new CronetEngine.Builder(getContext());
         builder.setStoragePath(CronetTestFramework.getTestStorage(getContext()));
         builder.enableHttpCache(CronetEngine.Builder.HTTP_CACHE_DISK, 1000 * 1024);
         builder.enableQUIC(true);
+        JSONObject quicParams = new JSONObject()
+                                        .put("connection_options", "PACE,IW10,FOO,DEADBEEF")
+                                        .put("host_whitelist", "test.example.com")
+                                        .put("store_server_configs_in_properties", true)

[mef, 2016/01/13 22:18:15]

nit: do we need all these options, or did you add them as an example?

[Ryan Hamilton, 2016/01/13 22:34:58]

Good point. I copied them from the previous setup, but we only need the
whitelist. Done.

+                                        .put("delay_tcp_race", true)
+                                        .put("max_number_of_lossy_connections", 10)
+                                        .put("packet_loss_threshold", 0.5)
+                                        .put("idle_connection_timeout_seconds", 300);
+        JSONObject experimentalOptions = new JSONObject().put("QUIC", quicParams);
+        builder.setExperimentalOptions(experimentalOptions.toString());
         builder.setMockCertVerifierForTesting(MockCertVerifier.createMockCertVerifier(CERTS_USED));
         mTestFramework = startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, builder);
         registerHostResolver(mTestFramework);
         TestUrlRequestCallback callback2 = new TestUrlRequestCallback();
         requestBuilder = new UrlRequest.Builder(
                 quicURL, callback2, callback2.getExecutor(), mTestFramework.mCronetEngine);
         requestBuilder.build().start();
         callback2.blockForDone();
         assertEquals(200, callback2.mResponseInfo.getHttpStatusCode());
         assertEquals(expectedContent, callback2.mResponseAsString);
         assertEquals("quic/1+spdy/3", callback2.mResponseInfo.getNegotiatedProtocol());
         // The total received bytes should be larger than the content length, to account for
         // headers.
         assertTrue(callback2.mResponseInfo.getReceivedBytesCount() > expectedContent.length());
     }
 
     // Returns whether a file contains a particular string.
     @SuppressFBWarnings("OBL_UNSATISFIED_OBLIGATION_EXCEPTION_EDGE")
     private boolean fileContainsString(String filename, String content) throws IOException {
         File file = new File(CronetTestFramework.getTestStorage(getContext()) + "/" + filename);
         FileInputStream fileInputStream = new FileInputStream(file);
         byte[] data = new byte[(int) file.length()];
         fileInputStream.read(data);
         fileInputStream.close();
         return new String(data, "UTF-8").contains(content);
     }
 }