NQE: Add default RTT and throughput observations

net/nqe/network_quality_estimator_unittest.cc

 // 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.
 
 #include "net/nqe/network_quality_estimator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 433 matching lines @@
 
       // RTT percentiles are in increasing order.
       EXPECT_GE(estimator.GetRTTEstimateInternal(disallowed_observation_sources,
                                                  base::TimeTicks(), i),
                 estimator.GetRTTEstimateInternal(disallowed_observation_sources,
                                                  base::TimeTicks(), i - 1));
     }
   }
 }
 
-TEST(NetworkQualityEstimatorTest, ObtainOperatingParams) {
+// Verifies that the default observations are added to the set of observations.
+// If default observations are overridden using field trial parameters, verify
+// that the overriding values are used.
+TEST(NetworkQualityEstimatorTest, DefaultObservationsOverridden) {
   std::map<std::string, std::string> variation_params;
   variation_params["Unknown.DefaultMedianKbps"] = "100";
   variation_params["WiFi.DefaultMedianKbps"] = "200";
   variation_params["2G.DefaultMedianKbps"] = "300";
 
   variation_params["Unknown.DefaultMedianRTTMsec"] = "1000";
   variation_params["WiFi.DefaultMedianRTTMsec"] = "2000";
   // Negative variation value should not be used.
   variation_params["2G.DefaultMedianRTTMsec"] = "-5";
 
-  TestNetworkQualityEstimator estimator(variation_params);
+  variation_params["Unknown.DefaultMedianTransportRTTMsec"] = "500";
+  variation_params["WiFi.DefaultMedianTransportRTTMsec"] = "1000";
+  // Negative variation value should not be used.
+  variation_params["2G.DefaultMedianTransportRTTMsec"] = "-5";
+
+  TestNetworkQualityEstimator estimator(nullptr, variation_params, false, false,
+                                        true /* use_default_platform_values */);
 
   base::TimeDelta rtt;
+  int32_t kbps;
+
   EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
-  int32_t kbps;
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(1000), rtt);
+  EXPECT_TRUE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(500), rtt);
   EXPECT_TRUE(
       estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
-
   EXPECT_EQ(100, kbps);
-  EXPECT_EQ(base::TimeDelta::FromMilliseconds(1000), rtt);
-
-  EXPECT_FALSE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
 
   // Simulate network change to Wi-Fi.
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, "test-1");
-
   EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(2000), rtt);
+  EXPECT_TRUE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(1000), rtt);
   EXPECT_TRUE(
       estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   EXPECT_EQ(200, kbps);
-  EXPECT_EQ(base::TimeDelta::FromMilliseconds(2000), rtt);
-  EXPECT_FALSE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
 
   // Peak network quality should not be affected by the network quality
   // estimator field trial.
   EXPECT_EQ(nqe::internal::InvalidRTT(),
             estimator.peak_network_quality_.http_rtt());
   EXPECT_EQ(nqe::internal::kInvalidThroughput,
             estimator.peak_network_quality_.downstream_throughput_kbps());
 
   // Simulate network change to 2G. Only the Kbps default estimate should be
   // available.
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_2G, "test-2");
-
-  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  // Taken from network_quality_estimator_params.cc.
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(1726), rtt);
+  EXPECT_TRUE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
+  // Taken from network_quality_estimator_params.cc.
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(1531), rtt);
   EXPECT_TRUE(
       estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   EXPECT_EQ(300, kbps);
 
-  // Simulate network change to 3G. Default estimates should be unavailable.
+  // Simulate network change to 3G. Default estimates should be available.
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_3G, "test-3");
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  // Taken from network_quality_estimator_params.cc.
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(272), rtt);
+  EXPECT_TRUE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
+  // Taken from network_quality_estimator_params.cc.
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(209), rtt);
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
+  // Taken from network_quality_estimator_params.cc.
+  EXPECT_EQ(749, kbps);
+}
 
-  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
-  EXPECT_FALSE(
+// Verify that the observers receive the notifications when default estimates
+// are added to the observations.
+TEST(NetworkQualityEstimatorTest, DefaultObservations) {

[RyanSturm, 2016/11/28 21:10:03]

nit: Can you switch the order of these tests? It makes more sense to have
DefaultObservations before DefaultObservationsOverridden IMO.

[tbansal1, 2016/11/28 22:50:57]

Done.

+  TestEffectiveConnectionTypeObserver effective_connection_type_observer;
+  TestRTTAndThroughputEstimatesObserver rtt_throughput_estimates_observer;
+  TestRTTObserver rtt_observer;
+  TestThroughputObserver throughput_observer;
+  std::map<std::string, std::string> variation_params;
+  TestNetworkQualityEstimator estimator(nullptr, variation_params, false, false,
+                                        true /* use_default_platform_values */);
+  base::TimeDelta rtt;
+  int32_t kbps;
+
+  // Default estimates should be available.
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(115), rtt);
+  EXPECT_TRUE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(55), rtt);
+  EXPECT_TRUE(
       estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
+  EXPECT_EQ(1961, kbps);
+
+  estimator.AddEffectiveConnectionTypeObserver(
+      &effective_connection_type_observer);
+  estimator.AddRTTAndThroughputEstimatesObserver(
+      &rtt_throughput_estimates_observer);
+  estimator.AddRTTObserver(&rtt_observer);
+  estimator.AddThroughputObserver(&throughput_observer);
+
+  // Simulate network change to 3G. Default estimates should be available.
+  estimator.SimulateNetworkChange(
+      NetworkChangeNotifier::ConnectionType::CONNECTION_3G, "test-3");
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  // Taken from network_quality_estimator_params.cc.
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(272), rtt);
+  EXPECT_TRUE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
+  // Taken from network_quality_estimator_params.cc.
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(209), rtt);
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
+  // Taken from network_quality_estimator_params.cc.
+  EXPECT_EQ(749, kbps);
+
+  EXPECT_NE(EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
+            estimator.GetEffectiveConnectionType());
+  EXPECT_EQ(
+      1U,
+      effective_connection_type_observer.effective_connection_types().size());
+  EXPECT_NE(
+      EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
+      effective_connection_type_observer.effective_connection_types().front());
+
+  EXPECT_EQ(3, rtt_throughput_estimates_observer.notifications_received());
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(272),
+            rtt_throughput_estimates_observer.http_rtt());
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(209),
+            rtt_throughput_estimates_observer.transport_rtt());
+  EXPECT_EQ(749,
+            rtt_throughput_estimates_observer.downstream_throughput_kbps());
+
+  EXPECT_EQ(2U, rtt_observer.observations().size());
+  EXPECT_EQ(272, rtt_observer.observations().at(0).rtt_ms);
+  EXPECT_EQ(NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_HTTP_FROM_PLATFORM,
+            rtt_observer.observations().at(0).source);
+  EXPECT_EQ(209, rtt_observer.observations().at(1).rtt_ms);
+  EXPECT_EQ(NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_TRANSPORT_FROM_PLATFORM,
+            rtt_observer.observations().at(1).source);
+
+  EXPECT_EQ(1U, throughput_observer.observations().size());
+  EXPECT_EQ(749, throughput_observer.observations().at(0).throughput_kbps);
+  EXPECT_EQ(NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_HTTP_FROM_PLATFORM,
+            throughput_observer.observations().at(0).source);
 }
 
 TEST(NetworkQualityEstimatorTest, ObtainAlgorithmToUseFromParams) {
   const struct {
     bool set_variation_param;
     std::string algorithm;
     NetworkQualityEstimator::EffectiveConnectionTypeAlgorithm
         expected_algorithm;
   } tests[] = {
       {false, "", NetworkQualityEstimator::EffectiveConnectionTypeAlgorithm::
@@ skipping 809 matching lines @@
       },
       {
           true,
       },
   };
 
   for (const auto& test : tests) {
     TestNetworkQualityEstimator estimator(
         std::unique_ptr<net::ExternalEstimateProvider>(), variation_params,
         test.allow_small_localhost_requests,
-        test.allow_small_localhost_requests);
+        test.allow_small_localhost_requests, false);
 
     base::TimeDelta rtt;
     EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
     int32_t kbps;
     EXPECT_FALSE(
         estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 
     TestDelegate test_delegate;
     TestURLRequestContext context(true);
     context.set_network_quality_estimator(&estimator);
@@ skipping 1113 matching lines @@
       request->Start();
       base::RunLoop().Run();
 
       EXPECT_EQ(effective_connection_type,
                 estimator.GetEffectiveConnectionType());
     }
   }
 }
 
 }  // namespace net