Enable NQE when Cronet Engine is built

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.os.ConditionVariable;
 import android.test.suitebuilder.annotation.LargeTest;
 import android.test.suitebuilder.annotation.SmallTest;
+import android.util.SparseIntArray;
 
 import org.chromium.base.Log;
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.CronetTestBase.OnlyRunNativeCronet;
 import org.json.JSONObject;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.HashMap;
+import java.util.concurrent.Executors;
 
 /**
  * Tests making requests using QUIC.
  */
 public class QuicTest extends CronetTestBase {
     private static final String TAG = "cr.QuicTest";
     private CronetTestFramework mTestFramework;
     private CronetEngine.Builder mBuilder;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         // Load library first, since we need the Quic test server's URL.
         System.loadLibrary("cronet_tests");
         QuicTestServer.startQuicTestServer(getContext());
 
         mBuilder = new CronetEngine.Builder(getContext());
-        mBuilder.enableQUIC(true);
+        mBuilder.enableQUIC(true).enableNetworkQualityEstimator(
+                true, Executors.newSingleThreadExecutor());
         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("max_server_configs_stored_in_properties", 2)
                                         .put("delay_tcp_race", true)
                                         .put("max_number_of_lossy_connections", 10)
                                         .put("packet_loss_threshold", 0.5)
                                         .put("idle_connection_timeout_seconds", 300)
                                         .put("close_sessions_on_ip_change", false)
                                         .put("migrate_sessions_on_network_change", true)
                                         .put("migrate_sessions_early", true);
         JSONObject experimentalOptions = new JSONObject().put("QUIC", quicParams);
         mBuilder.setExperimentalOptions(experimentalOptions.toString());
 
         mBuilder.setMockCertVerifierForTesting(QuicTestServer.createMockCertVerifier());
         mBuilder.setStoragePath(CronetTestFramework.getTestStorage(getContext()));
         mBuilder.enableHttpCache(CronetEngine.Builder.HTTP_CACHE_DISK_NO_HTTP, 1000 * 1024);
     }
 
     @Override
     protected void tearDown() throws Exception {
         QuicTestServer.shutdownQuicTestServer();
         super.tearDown();
     }
 
+    static class TestNetworkQualityListener
+            implements NetworkQualityRttListener, NetworkQualityThroughputListener {
+        // Lock to ensure that observation counts can be updated and read by different threads.
+        private final Object mLock = new Object();

[bengr, 2016/06/07 20:53:16]

Consider renaming as mObservationLock

[tbansal1, 2016/06/07 21:37:17]

Done.

+        private final ConditionVariable mWaitForThroughput;
+        private int mThroughputObservationCount;
+        private SparseIntArray mRttObservationCountBySource = new SparseIntArray();
+
+        TestNetworkQualityListener(ConditionVariable waitForThroughput) {
+            mWaitForThroughput = waitForThroughput;
+        }
+
+        @Override
+        public void onRttObservation(int rttMs, long when, int source) {
+            synchronized (mLock) {
+                mRttObservationCountBySource.put(
+                        source, mRttObservationCountBySource.get(source) + 1);
+            }
+        }
+
+        @Override
+        public void onThroughputObservation(int throughputKbps, long when, int source) {
+            synchronized (mLock) {
+                if (mWaitForThroughput != null) {
+                    mWaitForThroughput.open();
+                }
+                mThroughputObservationCount++;
+            }
+        }
+
+        public int rttObservationCount(int source) {
+            synchronized (mLock) {
+                return mRttObservationCountBySource.get(source);
+            }
+        }
+
+        public int throughputObservationCount() {
+            synchronized (mLock) {
+                return mThroughputObservationCount;
+            }
+        }
+    }
+
     @SmallTest
     @Feature({"Cronet"})
     @SuppressWarnings("deprecation")
     @OnlyRunNativeCronet
     public void testQuicLoadUrl_LegacyAPI() throws Exception {
         String[] commandLineArgs = {
                 CronetTestFramework.LIBRARY_INIT_KEY, CronetTestFramework.LibraryInitType.LEGACY};
         mTestFramework = new CronetTestFramework(null, commandLineArgs, getContext(), mBuilder);
         registerHostResolver(mTestFramework, true);
         String quicURL = QuicTestServer.getServerURL() + "/simple.txt";
@@ skipping 86 matching lines @@
     @SuppressFBWarnings("OBL_UNSATISFIED_OBLIGATION_EXCEPTION_EDGE")
     private boolean fileContainsString(String filename, String content) throws IOException {
         File file =
                 new File(CronetTestFramework.getTestStorage(getContext()) + "/prefs/" + 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);
     }
+
+    @LargeTest
+    @Feature({"Cronet"})
+    @OnlyRunNativeCronet
+    @SuppressWarnings("deprecation")
+    public void testRealTimeNetworkQualityObservationsWithQuic() throws Exception {
+        mTestFramework = startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mBuilder);
+        registerHostResolver(mTestFramework);
+        String quicURL = QuicTestServer.getServerURL() + "/simple.txt";

[bengr, 2016/06/07 20:53:16]

quicUrl? Shouldn't getServerURL be getServerUrl? I'm not clear on java style for
this.

[tbansal1, 2016/06/07 21:37:17]

May be, may be not :) I am not sure about Java style either. But this is same as
Lines 123 and 149 above, so keeping it as such.

+
+        ConditionVariable waitForThroughput = new ConditionVariable();
+        TestNetworkQualityListener networkQualityListener =
+                new TestNetworkQualityListener(waitForThroughput);
+        mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
+        mTestFramework.mCronetEngine.addRttListener(networkQualityListener);
+        mTestFramework.mCronetEngine.addThroughputListener(networkQualityListener);
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+
+        // Although the native stack races QUIC and SPDY for the first request,
+        // since there is no http server running on the corresponding TCP port,
+        // QUIC will always succeed with a 200 (see
+        // net::HttpStreamFactoryImpl::Request::OnStreamFailed).
+        UrlRequest.Builder requestBuilder = new UrlRequest.Builder(
+                quicURL, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        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());
+
+        // Throughput observation is posted to the network quality estimator on the network thread
+        // after the UrlRequest is completed. The observations are then eventually posted to
+        // throughput listeners on the executor provided to network quality.
+        waitForThroughput.block();
+        assertTrue(networkQualityListener.throughputObservationCount() > 0);
+
+        // Check RTT observation count after throughput observation has been received. This ensures
+        // that executor has finished posting the RTT observation to the RTT listeners.
+        // NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST
+        assertTrue(networkQualityListener.rttObservationCount(0) > 0);
+
+        // NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC
+        assertTrue(networkQualityListener.rttObservationCount(2) > 0);
+
+        mTestFramework.mCronetEngine.shutdown();
+    }
 }