Enable NQE when Cronet Engine is built

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

 // Copyright 2014 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.content.Context;
 import android.content.ContextWrapper;
 import android.os.ConditionVariable;
 import android.os.Handler;
 import android.os.Looper;
 import android.test.suitebuilder.annotation.SmallTest;
+import android.util.SparseIntArray;
 
 import org.chromium.base.PathUtils;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.test.util.Feature;
 import org.chromium.base.test.util.FlakyTest;
 import org.chromium.net.CronetEngine.UrlRequestInfo;
 import org.chromium.net.TestUrlRequestCallback.ResponseStep;
 import org.chromium.net.test.EmbeddedTestServer;
 
 import java.io.BufferedReader;
@@ skipping 100 matching lines @@
         }
     }
 
     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();
         private final ConditionVariable mWaitForThroughput;
         private int mRttObservationCount;
         private int mThroughputObservationCount;
+        // Holds the RTT observations counts indexed by source.
+        private SparseIntArray mRttObservationCountBySource = new SparseIntArray();
 
         TestNetworkQualityListener(ConditionVariable waitForThroughput) {
             mWaitForThroughput = waitForThroughput;
         }
 
         @Override
         public void onRttObservation(int rttMs, long when, int source) {
             synchronized (mLock) {
                 mRttObservationCount++;
+                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() {
             synchronized (mLock) {
                 return mRttObservationCount;
             }
         }
 
+        public int rttObservationCount(int source) {
+            synchronized (mLock) {
+                return mRttObservationCountBySource.get(source);
+            }
+        }
+
         public int throughputObservationCount() {
             synchronized (mLock) {
                 return mThroughputObservationCount;
             }
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testConfigUserAgent() throws Exception {
@@ skipping 60 matching lines @@
         // Proxy logic configured to use the test server as its proxy.
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(serverHostPort, callback.mResponseInfo.getProxyServer());
         assertEquals("http://DomainThatDoesnt.Resolve/datareductionproxysuccess.txt",
                 callback.mResponseInfo.getUrl());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testRealTimeNetworkQualityObservationsNotEnabled() throws Exception {
+        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        mCronetEngineBuilder.enableHTTP2(true).enableQUIC(false).enableNetworkQualityEstimator(

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

You shouldn't have to call enableNetworkQualityEstimator to *not* enable the
network quality estimator.

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

Done.

+                false, null);
+        mTestFramework =
+                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
+        TestNetworkQualityListener networkQualityListener = new TestNetworkQualityListener(null);
+        try {
+            mTestFramework.mCronetEngine.addRttListener(networkQualityListener);
+            fail("Should throw an exception.");
+        } catch (IllegalStateException e) {
+        }
+        try {
+            mTestFramework.mCronetEngine.addThroughputListener(networkQualityListener);
+            fail("Should throw an exception.");
+        } catch (IllegalStateException e) {
+        }
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        UrlRequest urlRequest =
+                mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
+        urlRequest.start();
+        callback.blockForDone();
+        assertEquals(0, networkQualityListener.rttObservationCount());
+        assertEquals(0, networkQualityListener.throughputObservationCount());
+        mTestFramework.mCronetEngine.shutdown();
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testRealTimeNetworkQualityObservationsNotEnabled_LegacyAPI() throws Exception {
         mTestFramework = startCronetTestFramework();
         TestNetworkQualityListener networkQualityListener = new TestNetworkQualityListener(null);
         try {
             mTestFramework.mCronetEngine.addRttListener(networkQualityListener);
             fail("Should throw an exception.");
         } catch (IllegalStateException e) {
         }
         try {
             mTestFramework.mCronetEngine.addThroughputListener(networkQualityListener);
             fail("Should throw an exception.");
         } catch (IllegalStateException e) {
         }
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest urlRequest =
                 mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
         urlRequest.start();
         callback.blockForDone();
         assertEquals(0, networkQualityListener.rttObservationCount());
         assertEquals(0, networkQualityListener.throughputObservationCount());
         mTestFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testRealTimeNetworkQualityObservationsListenerRemoved() throws Exception {
+        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        TestExecutor mNetworkQualityExecutor = new TestExecutor();
+        mCronetEngineBuilder.enableHTTP2(true).enableQUIC(false).enableNetworkQualityEstimator(
+                true, mNetworkQualityExecutor);
+        mTestFramework =
+                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
+        TestNetworkQualityListener networkQualityListener = new TestNetworkQualityListener(null);
+        mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
+        mTestFramework.mCronetEngine.addRttListener(networkQualityListener);
+        mTestFramework.mCronetEngine.addThroughputListener(networkQualityListener);
+        mTestFramework.mCronetEngine.removeRttListener(networkQualityListener);
+        mTestFramework.mCronetEngine.removeThroughputListener(networkQualityListener);
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        UrlRequest urlRequest =
+                mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
+        urlRequest.start();
+        callback.blockForDone();
+        mNetworkQualityExecutor.runAllTasks();
+        assertEquals(0, networkQualityListener.rttObservationCount());
+        assertEquals(0, networkQualityListener.throughputObservationCount());
+        mTestFramework.mCronetEngine.shutdown();
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testRealTimeNetworkQualityObservationsListenerRemoved_LegacyAPI() throws Exception {
         mTestFramework = startCronetTestFramework();
         TestExecutor testExecutor = new TestExecutor();
         TestNetworkQualityListener networkQualityListener = new TestNetworkQualityListener(null);
-        mTestFramework.mCronetEngine.enableNetworkQualityEstimatorForTesting(
-                true, true, testExecutor);
+        mTestFramework.mCronetEngine.enableNetworkQualityEstimator(testExecutor);
+        mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
         mTestFramework.mCronetEngine.addRttListener(networkQualityListener);
         mTestFramework.mCronetEngine.addThroughputListener(networkQualityListener);
         mTestFramework.mCronetEngine.removeRttListener(networkQualityListener);
         mTestFramework.mCronetEngine.removeThroughputListener(networkQualityListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest urlRequest =
                 mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
         urlRequest.start();
         callback.blockForDone();
         testExecutor.runAllTasks();
         assertEquals(0, networkQualityListener.rttObservationCount());
         assertEquals(0, networkQualityListener.throughputObservationCount());
         mTestFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
-    public void testRealTimeNetworkQualityObservations() throws Exception {
+    public void testRealTimeNetworkQualityObservationsWithoutQuic() throws Exception {
+        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        Executor networkQualityExecutor = Executors.newSingleThreadExecutor();
+        mCronetEngineBuilder.enableHTTP2(true).enableQUIC(false).enableNetworkQualityEstimator(
+                true, networkQualityExecutor);
+        mTestFramework =
+                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
+        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();
+        UrlRequest urlRequest =
+                mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
+        urlRequest.start();
+        callback.blockForDone();
+
+        // 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.
+        assertTrue(networkQualityListener.rttObservationCount() > 0);
+
+        // NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST
+        assertTrue(networkQualityListener.rttObservationCount(0) > 0);
+
+        // NETWORK_QUALITY_OBSERVATION_SOURCE_TCP
+        assertTrue(networkQualityListener.rttObservationCount(1) > 0);
+
+        // NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC
+        assertEquals(0, networkQualityListener.rttObservationCount(2));
+
+        mTestFramework.mCronetEngine.shutdown();
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testRealTimeNetworkQualityObservations_LegacyAPI() throws Exception {
         mTestFramework = startCronetTestFramework();
         Executor executor = Executors.newSingleThreadExecutor();
         ConditionVariable waitForThroughput = new ConditionVariable();
         TestNetworkQualityListener networkQualityListener =
                 new TestNetworkQualityListener(waitForThroughput);
-        mTestFramework.mCronetEngine.enableNetworkQualityEstimatorForTesting(true, true, executor);
+        mTestFramework.mCronetEngine.enableNetworkQualityEstimator(executor);
+        mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
         mTestFramework.mCronetEngine.addRttListener(networkQualityListener);
         mTestFramework.mCronetEngine.addThroughputListener(networkQualityListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest urlRequest =
                 mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
         urlRequest.start();
         callback.blockForDone();
 
         // 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
@@ skipping 17 matching lines @@
             assertNull("onRequestFinished called repeatedly", mRequestInfo);
             assertNotNull(requestInfo);
             mRequestInfo = requestInfo;
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @SuppressWarnings("deprecation")
     public void testRequestFinishedListener() throws Exception {
+        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        TestExecutor mNetworkQualityExecutor = new TestExecutor();
+        mCronetEngineBuilder.enableHTTP2(true).enableQUIC(false).enableNetworkQualityEstimator(
+                true, mNetworkQualityExecutor);
+        mTestFramework =
+                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
+        TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
+        mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
+                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        urlRequestBuilder.addRequestAnnotation("request annotation")
+                .addRequestAnnotation(this)
+                .build()
+                .start();
+        callback.blockForDone();
+        mNetworkQualityExecutor.runAllTasks();
+
+        CronetEngine.UrlRequestInfo requestInfo = requestFinishedListener.mRequestInfo;
+        assertNotNull("RequestFinishedListener must be called", requestInfo);
+        assertEquals(mUrl, requestInfo.getUrl());
+        assertNotNull(requestInfo.getResponseInfo());
+        assertEquals(newHashSet("request annotation", this), // Use sets for unordered comparison.
+                new HashSet<Object>(requestInfo.getAnnotations()));
+        CronetEngine.UrlRequestMetrics metrics = requestInfo.getMetrics();
+        assertNotNull("UrlRequestInfo.getMetrics() must not be null", metrics);
+        assertTrue(metrics.getTotalTimeMs() > 0);
+        assertTrue(metrics.getTotalTimeMs() >= metrics.getTtfbMs());
+        assertTrue(metrics.getReceivedBytesCount() > 0);
+        mTestFramework.mCronetEngine.shutdown();
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    @SuppressWarnings("deprecation")
+    public void testRequestFinishedListener_LegacyAPI() throws Exception {
         mTestFramework = startCronetTestFramework();
         TestExecutor testExecutor = new TestExecutor();
         TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
         mTestFramework.mCronetEngine.enableNetworkQualityEstimator(testExecutor);
         mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
                 mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
         urlRequestBuilder.addRequestAnnotation("request annotation")
                 .addRequestAnnotation(this)
@@ skipping 46 matching lines @@
         assertTrue(metrics.getTotalTimeMs() > 0);
         assertNull(metrics.getTtfbMs());
         assertTrue(metrics.getReceivedBytesCount() == null || metrics.getReceivedBytesCount() == 0);
         mTestFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @SuppressWarnings("deprecation")
     public void testRequestFinishedListenerRemoved() throws Exception {
+        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        TestExecutor mNetworkQualityExecutor = new TestExecutor();
+        mCronetEngineBuilder.enableHTTP2(true).enableQUIC(false).enableNetworkQualityEstimator(
+                true, mNetworkQualityExecutor);
+        mTestFramework =
+                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
+        TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
+        mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
+        mTestFramework.mCronetEngine.removeRequestFinishedListener(requestFinishedListener);
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
+                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        urlRequestBuilder.build().start();
+        callback.blockForDone();
+        mNetworkQualityExecutor.runAllTasks();
+
+        assertNull(
+                "RequestFinishedListener must not be called", requestFinishedListener.mRequestInfo);
+        mTestFramework.mCronetEngine.shutdown();
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    @SuppressWarnings("deprecation")
+    public void testRequestFinishedListenerRemoved_LegacyAPI() throws Exception {
         mTestFramework = startCronetTestFramework();
         TestExecutor testExecutor = new TestExecutor();
         TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
         mTestFramework.mCronetEngine.enableNetworkQualityEstimator(testExecutor);
         mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
         mTestFramework.mCronetEngine.removeRequestFinishedListener(requestFinishedListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
                 mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
         urlRequestBuilder.build().start();
@@ skipping 758 matching lines @@
                     }
                 }.start();
                 otherThreadDone.block();
                 builder.build().shutdown();
                 uiThreadDone.open();
             }
         });
         assertTrue(uiThreadDone.block(1000));
     }
 }