Expose RTT and throughput estimates from Cronet

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 android.content.Context;
 import android.content.ContextWrapper;
 import android.os.ConditionVariable;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.StrictMode;
 import android.test.suitebuilder.annotation.SmallTest;
 
+import org.json.JSONObject;

[RyanSturm, 2016/10/14 21:21:32]

Should this import be alphabetical (i.e., after java.io.FileReader) or is there
some limitation? 

[tbansal1, 2016/10/14 21:50:29]

This is the new alphabetical order. See
https://codereview.chromium.org/2052823002.

[RyanSturm, 2016/10/14 22:19:13]

Acknowledged. This breaks my brain a little, but I guess it's the same as
chromium c++ include order having 3 distinct groupings, except this is 10
groupings.

+
 import org.chromium.base.FileUtils;
 import org.chromium.base.PathUtils;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.MetricsTestUtil.TestExecutor;
 import org.chromium.net.TestUrlRequestCallback.ResponseStep;
 import org.chromium.net.impl.CronetLibraryLoader;
 import org.chromium.net.impl.CronetUrlRequestContext;
 import org.chromium.net.test.EmbeddedTestServer;
-import org.json.JSONObject;
 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.net.URL;
 import java.util.Arrays;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicReference;
@@ skipping 238 matching lines @@
         callback.blockForDone();
         networkQualityExecutor.runAllTasks();
         assertEquals(0, rttListener.rttObservationCount());
         testFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testRealTimeNetworkQualityObservationsQuicDisabled() throws Exception {
         CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        assert CronetEngine.INVALID_RTT_THROUGHPUT < 0;
+
+        // The invalid value for the estimates used by Cronet should match the invalid value for
+        // the estimates used by the native.
+        assertEquals(CronetEngine.INVALID_RTT_THROUGHPUT,
+                RttThroughputValues.INVALID_RTT_THROUGHPUT_VALUE);
         Executor listenersExecutor = Executors.newSingleThreadExecutor(new ExecutorThreadFactory());
         ConditionVariable waitForThroughput = new ConditionVariable();
         TestNetworkQualityRttListener rttListener =
                 new TestNetworkQualityRttListener(listenersExecutor);
         TestNetworkQualityThroughputListener throughputListener =
                 new TestNetworkQualityThroughputListener(listenersExecutor, waitForThroughput);
         mCronetEngineBuilder.enableHttp2(true).enableQuic(false).enableNetworkQualityEstimator(
                 true);
         final CronetTestFramework testFramework =
                 startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
@@ skipping 30 matching lines @@
 
         // Verify that the listeners were notified on the expected thread.
         assertEquals(mNetworkQualityThread, rttListener.getThread());
         assertEquals(mNetworkQualityThread, throughputListener.getThread());
 
         // Verify that effective connection type callback is received and
         // effective connection type is correctly set.
         assertTrue(testFramework.mCronetEngine.getEffectiveConnectionType()
                 != EffectiveConnectionType.TYPE_UNKNOWN);
 
+        // Verify that the HTTP RTT, transport RTT and downstream throughput
+        // estimates are available.
+        if (testFramework.mCronetEngine.getEffectiveConnectionType()
+                != EffectiveConnectionType.TYPE_OFFLINE) {
+            assertTrue(testFramework.mCronetEngine.getHttpRttMsec() > 0);
+            assertTrue(testFramework.mCronetEngine.getTransportRttMsec() > 0);
+            assertTrue(testFramework.mCronetEngine.getDownstreamThroughputKbps() > 0);
+        } else {
+            assertEquals(CronetEngine.INVALID_RTT_THROUGHPUT,
+                    testFramework.mCronetEngine.getHttpRttMsec());
+            assertEquals(CronetEngine.INVALID_RTT_THROUGHPUT,
+                    testFramework.mCronetEngine.getTransportRttMsec());
+            assertEquals(CronetEngine.INVALID_RTT_THROUGHPUT,
+                    testFramework.mCronetEngine.getDownstreamThroughputKbps());
+        }
+
         testFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     // TODO: Remove the annotation after fixing http://crbug.com/637979 & http://crbug.com/637972
     @OnlyRunNativeCronet
     public void testShutdown() throws Exception {
         final CronetTestFramework testFramework = startCronetTestFramework();
         ShutdownTestUrlRequestCallback callback =
@@ skipping 1104 matching lines @@
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         URL requestUrl =
                 new URL("http", resolverTestHostname, testUrl.getPort(), testUrl.getFile());
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(requestUrl.toString(),
                 callback, callback.getExecutor(), testFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
     }
 }