Expose typical network quality from NQE

Add an API that exposes typical network
quality for a given effective connection type. This API
would be used to set RTT and throughput values when
effective connection type value is overridden
due to holdback experiment, or otherwise.

Bug: 880545
Change-Id: If83593e31e44e2e0e9ab8357a673300e032cea9e
Reviewed-on: https://chromium-review.googlesource.com/1249962Reviewed-by: Ryan Sturm <ryansturm@chromium.org>
Commit-Queue: Tarun Bansal <tbansal@chromium.org>
Cr-Commit-Position: refs/heads/master@{#595247}

net/nqe/network_quality_estimator_params.cc

@@ -238,6 +238,24 @@ void ObtainDefaultObservations(
   }
 }
 
+// Typical HTTP RTT value corresponding to a given WebEffectiveConnectionType
+// value. Taken from
+// https://cs.chromium.org/chromium/src/net/nqe/network_quality_estimator_params.cc.
+const base::TimeDelta kTypicalHttpRttEffectiveConnectionType
+    [net::EFFECTIVE_CONNECTION_TYPE_LAST] = {
+        base::TimeDelta::FromMilliseconds(0),
+        base::TimeDelta::FromMilliseconds(0),
+        base::TimeDelta::FromMilliseconds(3600),
+        base::TimeDelta::FromMilliseconds(1800),
+        base::TimeDelta::FromMilliseconds(450),
+        base::TimeDelta::FromMilliseconds(175)};
+
+// Typical downlink throughput (in Mbps) value corresponding to a given
+// WebEffectiveConnectionType value. Taken from
+// https://cs.chromium.org/chromium/src/net/nqe/network_quality_estimator_params.cc.
+const int32_t kTypicalDownlinkKbpsEffectiveConnectionType
+    [net::EFFECTIVE_CONNECTION_TYPE_LAST] = {0, 0, 40, 75, 400, 1600};
+
 // Sets |typical_network_quality| to typical network quality for different
 // effective connection types.
 void ObtainTypicalNetworkQualities(
@@ -257,30 +275,39 @@ void ObtainTypicalNetworkQualities(
           // Set to the 77.5th percentile of 2G RTT observations on Android.
           // This corresponds to the median RTT observation when effective
           // connection type is Slow 2G.
-          base::TimeDelta::FromMilliseconds(3600),
-          base::TimeDelta::FromMilliseconds(3000), 40);
+          kTypicalHttpRttEffectiveConnectionType
+              [EFFECTIVE_CONNECTION_TYPE_SLOW_2G],
+          base::TimeDelta::FromMilliseconds(3000),
+          kTypicalDownlinkKbpsEffectiveConnectionType
+              [EFFECTIVE_CONNECTION_TYPE_SLOW_2G]);
 
   typical_network_quality[EFFECTIVE_CONNECTION_TYPE_2G] =
       nqe::internal::NetworkQuality(
           // Set to the 58th percentile of 2G RTT observations on Android. This
           // corresponds to the median RTT observation when effective connection
           // type is 2G.
-          base::TimeDelta::FromMilliseconds(1800),
-          base::TimeDelta::FromMilliseconds(1500), 75);
+          kTypicalHttpRttEffectiveConnectionType[EFFECTIVE_CONNECTION_TYPE_2G],
+          base::TimeDelta::FromMilliseconds(1500),
+          kTypicalDownlinkKbpsEffectiveConnectionType
+              [EFFECTIVE_CONNECTION_TYPE_2G]);
 
   typical_network_quality[EFFECTIVE_CONNECTION_TYPE_3G] =
       nqe::internal::NetworkQuality(
           // Set to the 75th percentile of 3G RTT observations on Android. This
           // corresponds to the median RTT observation when effective connection
           // type is 3G.
-          base::TimeDelta::FromMilliseconds(450),
-          base::TimeDelta::FromMilliseconds(400), 400);
+          kTypicalHttpRttEffectiveConnectionType[EFFECTIVE_CONNECTION_TYPE_3G],
+          base::TimeDelta::FromMilliseconds(400),
+          kTypicalDownlinkKbpsEffectiveConnectionType
+              [EFFECTIVE_CONNECTION_TYPE_3G]);
 
   // Set to the 25th percentile of 3G RTT observations on Android.
   typical_network_quality[EFFECTIVE_CONNECTION_TYPE_4G] =
-      nqe::internal::NetworkQuality(base::TimeDelta::FromMilliseconds(175),
-                                    base::TimeDelta::FromMilliseconds(125),
-                                    1600);
+      nqe::internal::NetworkQuality(
+          kTypicalHttpRttEffectiveConnectionType[EFFECTIVE_CONNECTION_TYPE_4G],
+          base::TimeDelta::FromMilliseconds(125),
+          kTypicalDownlinkKbpsEffectiveConnectionType
+              [EFFECTIVE_CONNECTION_TYPE_4G]);
 
   static_assert(
       EFFECTIVE_CONNECTION_TYPE_4G + 1 == EFFECTIVE_CONNECTION_TYPE_LAST,
@@ -518,6 +545,18 @@ bool NetworkQualityEstimatorParams::use_small_responses() const {
   return use_small_responses_;
 };
 
+// static
+base::TimeDelta NetworkQualityEstimatorParams::GetDefaultTypicalHttpRtt(
+    EffectiveConnectionType effective_connection_type) {
+  return kTypicalHttpRttEffectiveConnectionType[effective_connection_type];
+}
+
+// static
+int32_t NetworkQualityEstimatorParams::GetDefaultTypicalDownlinkKbps(
+    EffectiveConnectionType effective_connection_type) {
+  return kTypicalDownlinkKbpsEffectiveConnectionType[effective_connection_type];
+}
+
 void NetworkQualityEstimatorParams::SetForcedEffectiveConnectionTypeForTesting(
     EffectiveConnectionType type) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

net/nqe/network_quality_estimator_params.h

@@ -174,6 +174,18 @@ class NET_EXPORT NetworkQualityEstimatorParams {
   // network quality. Set to true only for tests.
   bool use_small_responses() const;
 
+  // Returns the typical HTTP RTT that maps to the given
+  // |effective_connection_type|. May return invalid value if
+  // |effective_connection_type| is less than Slow2G or faster than 4G,
+  static base::TimeDelta GetDefaultTypicalHttpRtt(
+      EffectiveConnectionType effective_connection_type);
+
+  // Returns the typical downslink throughput (in kbps) that maps to the given
+  // |effective_connection_type|. May return invalid value if
+  // |effective_connection_type| is less than Slow2G or faster than 4G,
+  static int32_t GetDefaultTypicalDownlinkKbps(
+      EffectiveConnectionType effective_connection_type);
+
   // |use_small_responses| should only be true when testing.
   // Allows the responses smaller than |kMinTransferSizeInBits| to be used for
   // network quality estimation.

net/nqe/network_quality_estimator_params_unittest.cc

@@ -83,6 +83,12 @@ TEST(NetworkQualityEstimatorParamsTest, TypicalNetworkQualities) {
               params.TypicalNetworkQuality(ect).downstream_throughput_kbps());
     EXPECT_EQ(nqe::internal::INVALID_RTT_THROUGHPUT,
               params.ConnectionThreshold(ect).downstream_throughput_kbps());
+
+    EXPECT_EQ(params.TypicalNetworkQuality(ect).http_rtt(),
+              NetworkQualityEstimatorParams::GetDefaultTypicalHttpRtt(ect));
+    EXPECT_EQ(
+        params.TypicalNetworkQuality(ect).downstream_throughput_kbps(),
+        NetworkQualityEstimatorParams::GetDefaultTypicalDownlinkKbps(ect));
   }
 
   // The typical network quality of 4G connection should be at least as fast