NQE: Store the current network quality in a single variable

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 144 matching lines @@
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN, "test");
   histogram_tester.ExpectUniqueSample("NQE.CachedNetworkQualityAvailable",
                                       false, 1);
 
   base::TimeDelta rtt;
   int32_t kbps;
-  EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 
   TestDelegate test_delegate;
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
   std::unique_ptr<URLRequest> request(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
   request->Start();
   base::RunLoop().Run();
 
   // Both RTT and downstream throughput should be updated.
-  EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&kbps));
-  EXPECT_FALSE(estimator.GetTransportRTT(&rtt));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
+  EXPECT_FALSE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
 
   // Check UMA histograms.
   histogram_tester.ExpectTotalCount("NQE.PeakKbps.Unknown", 0);
   histogram_tester.ExpectTotalCount("NQE.FastestRTT.Unknown", 0);
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType",
       EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_UNKNOWN, 1);
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType.Unknown",
       EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_UNKNOWN, 1);
@@ skipping 17 matching lines @@
   histogram_tester.ExpectTotalCount("NQE.RatioMedianRTT.WiFi", 0);
 
   histogram_tester.ExpectTotalCount("NQE.RTT.Percentile0.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.RTT.Percentile10.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.RTT.Percentile50.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.RTT.Percentile90.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.RTT.Percentile100.Unknown", 1);
 
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile50.Unknown", 0);
 
-  EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 
   // Verify that metrics are logged correctly on main-frame requests.
   histogram_tester.ExpectTotalCount("NQE.MainFrame.RTT.Percentile50", 1);
   histogram_tester.ExpectTotalCount("NQE.MainFrame.RTT.Percentile50.Unknown",
                                     1);
   histogram_tester.ExpectTotalCount("NQE.MainFrame.TransportRTT.Percentile50",
                                     0);
   histogram_tester.ExpectTotalCount(
       "NQE.MainFrame.TransportRTT.Percentile50.Unknown", 0);
   histogram_tester.ExpectTotalCount("NQE.MainFrame.Kbps.Percentile50", 1);
   histogram_tester.ExpectTotalCount("NQE.MainFrame.Kbps.Percentile50.Unknown",
                                     1);
 
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, std::string());
   histogram_tester.ExpectUniqueSample("NQE.CachedNetworkQualityAvailable",
                                       false, 3);
   histogram_tester.ExpectTotalCount("NQE.PeakKbps.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.FastestRTT.Unknown", 1);
 
-  EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 
   std::unique_ptr<URLRequest> request3(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request3->SetLoadFlags(request2->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
   request3->Start();
   base::RunLoop().Run();
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType.WiFi",
       EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_UNKNOWN, 1);
   histogram_tester.ExpectTotalCount("NQE.MainFrame.EffectiveConnectionType", 3);
@@ skipping 13 matching lines @@
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_2G, "test");
   histogram_tester.ExpectUniqueSample("NQE.CachedNetworkQualityAvailable",
                                       false, 1);
 
   base::TimeDelta rtt;
   int32_t kbps;
-  EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 
   TestDelegate test_delegate;
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
   // Start two requests so that the network quality is added to cache store at
   // the beginning of the second request from the network traffic observed from
   // the first request.
   for (size_t i = 0; i < 2; ++i) {
     std::unique_ptr<URLRequest> request(context.CreateRequest(
         estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
     request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
     request->Start();
     base::RunLoop().Run();
   }
 
   base::RunLoop().RunUntilIdle();
 
   // Both RTT and downstream throughput should be updated.
-  EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   EXPECT_NE(EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
             estimator.GetEffectiveConnectionType());
-  EXPECT_FALSE(estimator.GetTransportRTT(&rtt));
+  EXPECT_FALSE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
 
   histogram_tester.ExpectBucketCount("NQE.CachedNetworkQualityAvailable", false,
                                      1);
 
   // Add the observers before changing the network type.
   TestEffectiveConnectionTypeObserver observer;
   estimator.AddEffectiveConnectionTypeObserver(&observer);
   TestRTTObserver rtt_observer;
   estimator.AddRTTObserver(&rtt_observer);
   TestThroughputObserver throughput_observer;
@@ skipping 12 matching lines @@
   EXPECT_EQ(1U, rtt_observer.observations().size());
   EXPECT_EQ(1U, throughput_observer.observations().size());
 }
 
 TEST(NetworkQualityEstimatorTest, StoreObservations) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
   base::TimeDelta rtt;
   int32_t kbps;
-  EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 
   TestDelegate test_delegate;
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
   // Push more observations than the maximum buffer size.
   const size_t kMaxObservations = 1000;
   for (size_t i = 0; i < kMaxObservations; ++i) {
     std::unique_ptr<URLRequest> request(context.CreateRequest(
         estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
     request->Start();
     base::RunLoop().Run();
-    EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
-    EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&kbps));
+    EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+    EXPECT_TRUE(
+        estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   }
 
   // Verify that the stored observations are cleared on network change.
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, "test-2");
-  EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 }
 
 // This test notifies NetworkQualityEstimator of received data. Next,
 // throughput and RTT percentiles are checked for correctness by doing simple
 // verifications.
 TEST(NetworkQualityEstimatorTest, ComputedPercentiles) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
   std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
@@ skipping 54 matching lines @@
   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);
 
   base::TimeDelta rtt;
-  EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
   int32_t kbps;
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 
   EXPECT_EQ(100, kbps);
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(1000), rtt);
 
-  EXPECT_FALSE(estimator.GetTransportRTT(&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.GetHttpRTT(&rtt));
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   EXPECT_EQ(200, kbps);
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(2000), rtt);
-  EXPECT_FALSE(estimator.GetTransportRTT(&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.GetHttpRTT(&rtt));
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   EXPECT_EQ(300, kbps);
 
   // Simulate network change to 3G. Default estimates should be unavailable.
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_3G, "test-3");
 
-  EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 }
 
 TEST(NetworkQualityEstimatorTest, ObtainAlgorithmToUseFromParams) {
   const struct {
     bool set_variation_param;
     std::string algorithm;
     NetworkQualityEstimator::EffectiveConnectionTypeAlgorithm
         expected_algorithm;
   } tests[] = {
       {false, "", NetworkQualityEstimator::EffectiveConnectionTypeAlgorithm::
@@ skipping 91 matching lines @@
       {700, EFFECTIVE_CONNECTION_TYPE_3G},
       {500, EFFECTIVE_CONNECTION_TYPE_3G},
       {400, EFFECTIVE_CONNECTION_TYPE_4G},
       {300, EFFECTIVE_CONNECTION_TYPE_4G},
       {200, EFFECTIVE_CONNECTION_TYPE_4G},
       {100, EFFECTIVE_CONNECTION_TYPE_4G},
       {20, EFFECTIVE_CONNECTION_TYPE_4G},
   };
 
   for (const auto& test : tests) {
-    estimator.set_http_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
+    estimator.set_start_time_null_http_rtt(
+        base::TimeDelta::FromMilliseconds(test.rtt_msec));
     estimator.set_recent_http_rtt(
         base::TimeDelta::FromMilliseconds(test.rtt_msec));
-    estimator.set_downlink_throughput_kbps(INT32_MAX);
+    estimator.set_start_time_null_downlink_throughput_kbps(INT32_MAX);
     estimator.set_recent_downlink_throughput_kbps(INT32_MAX);
     // Run one main frame request to force recomputation of effective connection
     // type.
     estimator.RunOneRequest();
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that default transport RTT thresholds for different effective
 // connection types are correctly set.
@@ skipping 33 matching lines @@
       variation_params["2G.ThresholdMedianTransportRTTMsec"] = "1000";
     }
 
     TestNetworkQualityEstimator estimator(variation_params);
 
     // Simulate the connection type as Wi-Fi so that GetEffectiveConnectionType
     // does not return Offline if the device is offline.
     estimator.SimulateNetworkChange(NetworkChangeNotifier::CONNECTION_WIFI,
                                     "test");
 
-    estimator.set_transport_rtt(
+    estimator.set_start_time_null_transport_rtt(
         base::TimeDelta::FromMilliseconds(test.transport_rtt_msec));
     estimator.set_recent_transport_rtt(
         base::TimeDelta::FromMilliseconds(test.transport_rtt_msec));
-    estimator.set_downlink_throughput_kbps(INT32_MAX);
+    estimator.set_start_time_null_downlink_throughput_kbps(INT32_MAX);
     estimator.set_recent_downlink_throughput_kbps(INT32_MAX);
     // Run one main frame request to force recomputation of effective connection
     // type.
     estimator.RunOneRequest();
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that default HTTP RTT thresholds for different effective
 // connection types are correctly set.
@@ skipping 31 matching lines @@
       variation_params["2G.ThresholdMedianHttpRTTMsec"] = "1000";
     }
 
     TestNetworkQualityEstimator estimator(variation_params);
 
     // Simulate the connection type as Wi-Fi so that GetEffectiveConnectionType
     // does not return Offline if the device is offline.
     estimator.SimulateNetworkChange(NetworkChangeNotifier::CONNECTION_WIFI,
                                     "test");
 
-    estimator.set_http_rtt(
+    estimator.set_start_time_null_http_rtt(
         base::TimeDelta::FromMilliseconds(test.http_rtt_msec));
     estimator.set_recent_http_rtt(
         base::TimeDelta::FromMilliseconds(test.http_rtt_msec));
-    estimator.set_downlink_throughput_kbps(INT32_MAX);
+    estimator.set_start_time_null_downlink_throughput_kbps(INT32_MAX);
     estimator.set_recent_downlink_throughput_kbps(INT32_MAX);
     // Run one main frame request to force recomputation of effective connection
     // type.
     estimator.RunOneRequest();
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that |GetEffectiveConnectionType| returns correct connection type when
 // only transport RTT thresholds are specified in the variation params.
@@ skipping 28 matching lines @@
       {700, EFFECTIVE_CONNECTION_TYPE_3G},
       {500, EFFECTIVE_CONNECTION_TYPE_3G},
       {400, EFFECTIVE_CONNECTION_TYPE_4G},
       {300, EFFECTIVE_CONNECTION_TYPE_4G},
       {200, EFFECTIVE_CONNECTION_TYPE_4G},
       {100, EFFECTIVE_CONNECTION_TYPE_4G},
       {20, EFFECTIVE_CONNECTION_TYPE_4G},
   };
 
   for (const auto& test : tests) {
-    estimator.set_transport_rtt(
+    estimator.set_start_time_null_transport_rtt(
         base::TimeDelta::FromMilliseconds(test.transport_rtt_msec));
     estimator.set_recent_transport_rtt(
         base::TimeDelta::FromMilliseconds(test.transport_rtt_msec));
-    estimator.set_downlink_throughput_kbps(INT32_MAX);
+    estimator.set_start_time_null_downlink_throughput_kbps(INT32_MAX);
     estimator.set_recent_downlink_throughput_kbps(INT32_MAX);
     // Run one main frame request to force recomputation of effective connection
     // type.
     estimator.RunOneRequest();
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that |GetEffectiveConnectionType| returns correct connection type when
 // both HTTP RTT and throughput thresholds are specified in the variation
@@ skipping 38 matching lines @@
       {1, 700, EFFECTIVE_CONNECTION_TYPE_4G},
       {1, 1000, EFFECTIVE_CONNECTION_TYPE_4G},
       {1, 1500, EFFECTIVE_CONNECTION_TYPE_4G},
       {1, 2500, EFFECTIVE_CONNECTION_TYPE_4G},
       // Set both RTT and throughput. RTT is the bottleneck.
       {3000, 25000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
       {700, 25000, EFFECTIVE_CONNECTION_TYPE_3G},
   };
 
   for (const auto& test : tests) {
-    estimator.set_http_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
+    estimator.set_start_time_null_http_rtt(
+        base::TimeDelta::FromMilliseconds(test.rtt_msec));
     estimator.set_recent_http_rtt(
         base::TimeDelta::FromMilliseconds(test.rtt_msec));
-    estimator.set_downlink_throughput_kbps(test.downlink_throughput_kbps);
+    estimator.set_start_time_null_downlink_throughput_kbps(
+        test.downlink_throughput_kbps);
     estimator.set_recent_downlink_throughput_kbps(
         test.downlink_throughput_kbps);
     // Run one main frame request to force recomputation of effective connection
     // type.
     estimator.RunOneRequest();
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that |GetEffectiveConnectionType| returns correct connection type when
@@ skipping 41 matching lines @@
       {1, 700, EFFECTIVE_CONNECTION_TYPE_4G},
       {1, 1000, EFFECTIVE_CONNECTION_TYPE_4G},
       {1, 1500, EFFECTIVE_CONNECTION_TYPE_4G},
       {1, 2500, EFFECTIVE_CONNECTION_TYPE_4G},
       // Set both RTT and throughput. RTT is the bottleneck.
       {3000, 25000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
       {700, 25000, EFFECTIVE_CONNECTION_TYPE_3G},
   };
 
   for (const auto& test : tests) {
-    estimator.set_transport_rtt(
+    estimator.set_start_time_null_transport_rtt(
         base::TimeDelta::FromMilliseconds(test.transport_rtt_msec));
     estimator.set_recent_transport_rtt(
         base::TimeDelta::FromMilliseconds(test.transport_rtt_msec));
-    estimator.set_downlink_throughput_kbps(test.downlink_throughput_kbps);
+    estimator.set_start_time_null_downlink_throughput_kbps(
+        test.downlink_throughput_kbps);
     estimator.set_recent_downlink_throughput_kbps(
         test.downlink_throughput_kbps);
     // Run one main frame request to force recomputation of effective connection
     // type.
     estimator.RunOneRequest();
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests if |weight_multiplier_per_second_| is set to correct value for various
@@ skipping 182 matching lines @@
       invalid_external_estimate_provider);
 
   TestNetworkQualityEstimator estimator(std::map<std::string, std::string>(),
                                         std::move(external_estimate_provider));
   estimator.SimulateNetworkChange(net::NetworkChangeNotifier::CONNECTION_WIFI,
                                   "test");
 
   base::TimeDelta rtt;
   int32_t kbps;
   EXPECT_EQ(1U, invalid_external_estimate_provider->update_count());
-  EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   histogram_tester.ExpectTotalCount("NQE.ExternalEstimateProviderStatus", 2);
 
   histogram_tester.ExpectBucketCount(
       "NQE.ExternalEstimateProviderStatus",
       1 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE */, 1);
   histogram_tester.ExpectBucketCount(
       "NQE.ExternalEstimateProviderStatus",
       2 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED */, 1);
   histogram_tester.ExpectTotalCount("NQE.ExternalEstimateProvider.RTT", 0);
   histogram_tester.ExpectTotalCount(
@@ skipping 80 matching lines @@
           external_estimate_provider_downstream_throughput);
   std::unique_ptr<ExternalEstimateProvider> external_estimate_provider(
       test_external_estimate_provider);
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params,
                                         std::move(external_estimate_provider));
   estimator.SimulateNetworkChange(net::NetworkChangeNotifier::CONNECTION_WIFI,
                                   "test");
   base::TimeDelta rtt;
   int32_t kbps;
-  EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetTransportRTT(&rtt));
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 
   histogram_tester.ExpectTotalCount("NQE.ExternalEstimateProviderStatus", 5);
 
   histogram_tester.ExpectBucketCount(
       "NQE.ExternalEstimateProviderStatus",
       1 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE */, 1);
   histogram_tester.ExpectBucketCount(
       "NQE.ExternalEstimateProviderStatus",
       2 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED */, 1);
   histogram_tester.ExpectBucketCount(
       "NQE.ExternalEstimateProviderStatus",
       4 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_CALLBACK */, 1);
   histogram_tester.ExpectBucketCount(
       "NQE.ExternalEstimateProviderStatus",
       5 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_RTT_AVAILABLE */, 1);
   histogram_tester.ExpectBucketCount(
       "NQE.ExternalEstimateProviderStatus",
       6 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_DOWNLINK_BANDWIDTH_AVAILABLE */,
       1);
   histogram_tester.ExpectUniqueSample("NQE.ExternalEstimateProvider.RTT", 1, 1);
   histogram_tester.ExpectUniqueSample(
       "NQE.ExternalEstimateProvider.DownlinkBandwidth", 100, 1);
 
   EXPECT_EQ(1U, test_external_estimate_provider->update_count());
 
   // Change network type to WiFi. Number of queries to External estimate
   // provider must increment.
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, "test-1");
-  EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   EXPECT_EQ(2U, test_external_estimate_provider->update_count());
 
   test_external_estimate_provider->set_should_notify_delegate(false);
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_2G, "test-2");
   EXPECT_EQ(3U, test_external_estimate_provider->update_count());
   // Estimates are unavailable because external estimate provider never
   // notifies network quality estimator of the updated estimates.
-  EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 }
 
 // Tests if the estimate from the external estimate provider is merged with the
 // observations collected from the HTTP requests.
 TEST(NetworkQualityEstimatorTest, TestExternalEstimateProviderMergeEstimates) {
   const base::TimeDelta external_estimate_provider_rtt =
       base::TimeDelta::FromMilliseconds(10 * 1000);
   const int32_t external_estimate_provider_downstream_throughput = 100 * 1000;
   TestExternalEstimateProvider* test_external_estimate_provider =
       new TestExternalEstimateProvider(
           external_estimate_provider_rtt,
           external_estimate_provider_downstream_throughput);
   std::unique_ptr<ExternalEstimateProvider> external_estimate_provider(
       test_external_estimate_provider);
 
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params,
                                         std::move(external_estimate_provider));
   estimator.SimulateNetworkChange(net::NetworkChangeNotifier::CONNECTION_WIFI,
                                   "test");
 
   base::TimeDelta rtt;
   // Estimate provided by network quality estimator should match the estimate
   // provided by external estimate provider.
-  EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
   EXPECT_EQ(external_estimate_provider_rtt, rtt);
 
   int32_t kbps;
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   EXPECT_EQ(external_estimate_provider_downstream_throughput, kbps);
 
   TestDelegate test_delegate;
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
   std::unique_ptr<URLRequest> request(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request->Start();
   base::RunLoop().Run();
 
-  EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
   EXPECT_NE(external_estimate_provider_rtt, rtt);
 
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&kbps));
+  EXPECT_TRUE(
+      estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   EXPECT_NE(external_estimate_provider_downstream_throughput, kbps);
 }
 
 // Tests if the throughput observation is taken correctly when local and network
 // requests do not overlap.
 TEST(NetworkQualityEstimatorTest, TestThroughputNoRequestOverlap) {
   base::HistogramTester histogram_tester;
   std::map<std::string, std::string> variation_params;
 
   static const struct {
     bool allow_small_localhost_requests;
   } tests[] = {
       {
           false,
       },
       {
           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);
 
     base::TimeDelta rtt;
-    EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
+    EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
     int32_t kbps;
-    EXPECT_FALSE(estimator.GetDownlinkThroughputKbps(&kbps));
+    EXPECT_FALSE(
+        estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
 
     TestDelegate test_delegate;
     TestURLRequestContext context(true);
     context.set_network_quality_estimator(&estimator);
     context.Init();
 
     std::unique_ptr<URLRequest> request(context.CreateRequest(
         estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
     request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
     request->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(test.allow_small_localhost_requests, estimator.GetHttpRTT(&rtt));
     EXPECT_EQ(test.allow_small_localhost_requests,
-              estimator.GetDownlinkThroughputKbps(&kbps));
+              estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+    EXPECT_EQ(
+        test.allow_small_localhost_requests,
+        estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
   }
 }
 
 // Tests that the effective connection type is computed at the specified
 // interval, and that the observers are notified of any change.
 TEST(NetworkQualityEstimatorTest, TestEffectiveConnectionTypeObserver) {
   base::HistogramTester histogram_tester;
   std::unique_ptr<base::SimpleTestTickClock> tick_clock(
       new base::SimpleTestTickClock());
   base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
 
   TestEffectiveConnectionTypeObserver observer;
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
   estimator.AddEffectiveConnectionTypeObserver(&observer);
   estimator.SetTickClockForTesting(std::move(tick_clock));
 
   TestDelegate test_delegate;
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
   EXPECT_EQ(0U, observer.effective_connection_types().size());
 
-  estimator.set_recent_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_2G);
+  estimator.set_start_time_null_http_rtt(
+      base::TimeDelta::FromMilliseconds(1500));
+  estimator.set_start_time_null_downlink_throughput_kbps(100000);
+
   tick_clock_ptr->Advance(base::TimeDelta::FromMinutes(60));
 
   std::unique_ptr<URLRequest> request(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
   request->Start();
   base::RunLoop().Run();
   EXPECT_EQ(1U, observer.effective_connection_types().size());
   histogram_tester.ExpectUniqueSample("NQE.MainFrame.EffectiveConnectionType",
                                       EFFECTIVE_CONNECTION_TYPE_2G, 1);
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType.Unknown",
       EFFECTIVE_CONNECTION_TYPE_2G, 1);
 
   // Next request should not trigger recomputation of effective connection type
   // since there has been no change in the clock.
   std::unique_ptr<URLRequest> request2(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request2->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
   request2->Start();
   base::RunLoop().Run();
   EXPECT_EQ(1U, observer.effective_connection_types().size());
 
   // Change in connection type should send out notification to the observers.
-  estimator.set_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_3G);
+  estimator.set_start_time_null_http_rtt(
+      base::TimeDelta::FromMilliseconds(500));
   estimator.SimulateNetworkChange(NetworkChangeNotifier::CONNECTION_WIFI,
                                   "test");
   EXPECT_EQ(2U, observer.effective_connection_types().size());
 
   // A change in effective connection type does not trigger notification to the
   // observers, since it is not accompanied by any new observation or a network
   // change event.
-  estimator.set_recent_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_3G);
+  estimator.set_start_time_null_http_rtt(
+      base::TimeDelta::FromMilliseconds(100));
   EXPECT_EQ(2U, observer.effective_connection_types().size());
 }
 
 // Tests that the network quality is computed at the specified interval, and
 // that the network quality observers are notified of any change.
 TEST(NetworkQualityEstimatorTest, TestRTTAndThroughputEstimatesObserver) {
   base::HistogramTester histogram_tester;
   std::unique_ptr<base::SimpleTestTickClock> tick_clock(
       new base::SimpleTestTickClock());
   base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
@@ skipping 12 matching lines @@
   EXPECT_EQ(nqe::internal::InvalidRTT(), observer.http_rtt());
   EXPECT_EQ(nqe::internal::InvalidRTT(), observer.transport_rtt());
   EXPECT_EQ(nqe::internal::kInvalidThroughput,
             observer.downstream_throughput_kbps());
   int notifications_received = observer.notifications_received();
   EXPECT_EQ(0, notifications_received);
 
   base::TimeDelta http_rtt(base::TimeDelta::FromMilliseconds(100));
   base::TimeDelta transport_rtt(base::TimeDelta::FromMilliseconds(200));
   int32_t downstream_throughput_kbps(300);
-  estimator.set_recent_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_2G);
-  estimator.set_recent_http_rtt(http_rtt);
-  estimator.set_recent_transport_rtt(transport_rtt);
-  estimator.set_recent_downlink_throughput_kbps(downstream_throughput_kbps);
+  estimator.set_start_time_null_http_rtt(http_rtt);
+  estimator.set_start_time_null_transport_rtt(transport_rtt);
+  estimator.set_start_time_null_downlink_throughput_kbps(
+      downstream_throughput_kbps);
   tick_clock_ptr->Advance(base::TimeDelta::FromMinutes(60));
 
   std::unique_ptr<URLRequest> request(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request->Start();
   base::RunLoop().Run();
   EXPECT_EQ(http_rtt, observer.http_rtt());
   EXPECT_EQ(transport_rtt, observer.transport_rtt());
   EXPECT_EQ(downstream_throughput_kbps, observer.downstream_throughput_kbps());
   EXPECT_LE(1, observer.notifications_received() - notifications_received);
   notifications_received = observer.notifications_received();
 
   // The next request should not trigger recomputation of RTT or throughput
   // since there has been no change in the clock.
   std::unique_ptr<URLRequest> request2(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request2->Start();
   base::RunLoop().Run();
   EXPECT_LE(1, observer.notifications_received() - notifications_received);
   notifications_received = observer.notifications_received();
 
   // A change in the connection type should send out notification to the
   // observers.
-  estimator.set_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_3G);
   estimator.SimulateNetworkChange(NetworkChangeNotifier::CONNECTION_WIFI,
                                   "test");
+  EXPECT_EQ(http_rtt, observer.http_rtt());
+  EXPECT_EQ(transport_rtt, observer.transport_rtt());
+  EXPECT_EQ(downstream_throughput_kbps, observer.downstream_throughput_kbps());
   EXPECT_LE(1, observer.notifications_received() - notifications_received);
   notifications_received = observer.notifications_received();
 
   // A change in effective connection type does not trigger notification to the
   // observers, since it is not accompanied by any new observation or a network
   // change event.
-  estimator.set_recent_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_3G);
+  estimator.set_start_time_null_http_rtt(
+      base::TimeDelta::FromMilliseconds(10000));
+  estimator.set_start_time_null_http_rtt(base::TimeDelta::FromMilliseconds(1));
   EXPECT_EQ(0, observer.notifications_received() - notifications_received);
 }
 
 // Tests that the effective connection type is computed on every RTT
 // observation if the last computed effective connection type was unknown.
 TEST(NetworkQualityEstimatorTest, UnknownEffectiveConnectionType) {
   std::unique_ptr<base::SimpleTestTickClock> tick_clock(
       new base::SimpleTestTickClock());
   base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
 
@@ skipping 144 matching lines @@
   base::RunLoop().Run();
 
   std::unique_ptr<URLRequest> request2(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request2->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
   request2->Start();
   base::RunLoop().Run();
 
   // Both RTT and downstream throughput should be updated.
   base::TimeDelta rtt;
-  EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
 
   int32_t throughput;
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&throughput));
+  EXPECT_TRUE(estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(),
+                                                        &throughput));
 
   EXPECT_EQ(2U, rtt_observer.observations().size());
   EXPECT_EQ(2U, throughput_observer.observations().size());
   for (const auto& observation : rtt_observer.observations()) {
     EXPECT_LE(0, observation.rtt_ms);
     EXPECT_LE(0, (observation.timestamp - then).InMilliseconds());
     EXPECT_EQ(NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP, observation.source);
   }
   for (const auto& observation : throughput_observer.observations()) {
     EXPECT_LE(0, observation.throughput_kbps);
     EXPECT_LE(0, (observation.timestamp - then).InMilliseconds());
     EXPECT_EQ(NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP, observation.source);
   }
 
-  EXPECT_FALSE(estimator.GetTransportRTT(&rtt));
+  EXPECT_FALSE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
 
   // Verify that observations from TCP and QUIC are passed on to the observers.
   base::TimeDelta tcp_rtt(base::TimeDelta::FromMilliseconds(1));
   base::TimeDelta quic_rtt(base::TimeDelta::FromMilliseconds(2));
 
   std::unique_ptr<SocketPerformanceWatcher> tcp_watcher =
       estimator.GetSocketPerformanceWatcherFactory()
           ->CreateSocketPerformanceWatcher(
               SocketPerformanceWatcherFactory::PROTOCOL_TCP);
 
   std::unique_ptr<SocketPerformanceWatcher> quic_watcher =
       estimator.GetSocketPerformanceWatcherFactory()
           ->CreateSocketPerformanceWatcher(
               SocketPerformanceWatcherFactory::PROTOCOL_QUIC);
 
   tcp_watcher->OnUpdatedRTTAvailable(tcp_rtt);
   quic_watcher->OnUpdatedRTTAvailable(quic_rtt);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(4U, rtt_observer.observations().size());
   EXPECT_EQ(2U, throughput_observer.observations().size());
 
   EXPECT_EQ(tcp_rtt.InMilliseconds(), rtt_observer.observations().at(2).rtt_ms);
   EXPECT_EQ(quic_rtt.InMilliseconds(),
             rtt_observer.observations().at(3).rtt_ms);
 
-  EXPECT_TRUE(estimator.GetTransportRTT(&rtt));
+  EXPECT_TRUE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
 }
 
 // TestTCPSocketRTT requires kernel support for tcp_info struct, and so it is
 // enabled only on certain platforms.
 #if defined(TCP_INFO) || defined(OS_LINUX)
 #define MAYBE_TestTCPSocketRTT TestTCPSocketRTT
 #else
 #define MAYBE_TestTCPSocketRTT DISABLED_TestTCPSocketRTT
 #endif
 // Tests that the TCP socket notifies the Network Quality Estimator of TCP RTTs,
@@ skipping 12 matching lines @@
   std::unique_ptr<HttpNetworkSession::Params> params(
       new HttpNetworkSession::Params);
   // |estimator| should be notified of TCP RTT observations.
   params->socket_performance_watcher_factory =
       estimator.GetSocketPerformanceWatcherFactory();
   context.set_http_network_session_params(std::move(params));
   context.Init();
 
   EXPECT_EQ(0U, rtt_observer.observations().size());
   base::TimeDelta rtt;
-  EXPECT_FALSE(estimator.GetHttpRTT(&rtt));
-  EXPECT_FALSE(estimator.GetTransportRTT(&rtt));
+  EXPECT_FALSE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_FALSE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
 
   // Send two requests. Verify that the completion of each request generates at
   // least one TCP RTT observation.
   const size_t num_requests = 2;
   for (size_t i = 0; i < num_requests; ++i) {
     size_t before_count_tcp_rtt_observations = 0;
     for (const auto& observation : rtt_observer.observations()) {
       if (observation.source == NETWORK_QUALITY_OBSERVATION_SOURCE_TCP)
         ++before_count_tcp_rtt_observations;
     }
 
     std::unique_ptr<URLRequest> request(context.CreateRequest(
         estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
     request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
     request->Start();
     base::RunLoop().Run();
 
     size_t after_count_tcp_rtt_observations = 0;
     for (const auto& observation : rtt_observer.observations()) {
       if (observation.source == NETWORK_QUALITY_OBSERVATION_SOURCE_TCP)
         ++after_count_tcp_rtt_observations;
     }
     // At least one notification should be received per socket performance
     // watcher.
     EXPECT_LE(1U, after_count_tcp_rtt_observations -
                       before_count_tcp_rtt_observations)
         << i;
   }
-  EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
-  EXPECT_TRUE(estimator.GetTransportRTT(&rtt));
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  EXPECT_TRUE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
 
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, "test-1");
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile50.Unknown", 1);
   histogram_tester.ExpectBucketCount("NQE.TransportRTT.Percentile50.Unknown",
                                      rtt.InMilliseconds(), 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile10.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile50.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile90.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile100.Unknown",
@@ skipping 14 matching lines @@
 }
 
 #if defined(OS_IOS)
 // Flaky on iOS when |accuracy_recording_delay| is non-zero.
 #define MAYBE_RecordAccuracy DISABLED_RecordAccuracy
 #else
 #define MAYBE_RecordAccuracy RecordAccuracy
 #endif
 // Tests if the NQE accuracy metrics are recorded properly.
 TEST(NetworkQualityEstimatorTest, MAYBE_RecordAccuracy) {
-  const int expected_rtt_msec = 100;
-  const int expected_downstream_throughput_kbps = 200;
+  const int expected_rtt_msec = 500;
+  const int expected_downstream_throughput_kbps = 2000;
 
   const base::TimeDelta accuracy_recording_delays[] = {
       base::TimeDelta::FromSeconds(0), base::TimeDelta::FromSeconds(1),
   };
 
   const struct {
     base::TimeDelta rtt;
     base::TimeDelta recent_rtt;
     int32_t downstream_throughput_kbps;
     int32_t recent_downstream_throughput_kbps;
     EffectiveConnectionType effective_connection_type;
     EffectiveConnectionType recent_effective_connection_type;
   } tests[] = {
       {base::TimeDelta::FromMilliseconds(expected_rtt_msec),
        base::TimeDelta::FromMilliseconds(expected_rtt_msec),
        expected_downstream_throughput_kbps, expected_downstream_throughput_kbps,
-       EFFECTIVE_CONNECTION_TYPE_2G, EFFECTIVE_CONNECTION_TYPE_2G},
-
+       EFFECTIVE_CONNECTION_TYPE_3G, EFFECTIVE_CONNECTION_TYPE_3G},
       {
-          base::TimeDelta::FromMilliseconds(expected_rtt_msec + 1),
+          base::TimeDelta::FromMilliseconds(expected_rtt_msec + 1000),
+          base::TimeDelta::FromMilliseconds(expected_rtt_msec),
+          expected_downstream_throughput_kbps - 1,
+          expected_downstream_throughput_kbps, EFFECTIVE_CONNECTION_TYPE_2G,
+          EFFECTIVE_CONNECTION_TYPE_3G,
+      },
+      {
+          base::TimeDelta::FromMilliseconds(expected_rtt_msec - 400),
           base::TimeDelta::FromMilliseconds(expected_rtt_msec),
           expected_downstream_throughput_kbps + 1,
-          expected_downstream_throughput_kbps, EFFECTIVE_CONNECTION_TYPE_3G,
-          EFFECTIVE_CONNECTION_TYPE_2G,
-      },
-      {
-          base::TimeDelta::FromMilliseconds(expected_rtt_msec - 1),
-          base::TimeDelta::FromMilliseconds(expected_rtt_msec),
-          expected_downstream_throughput_kbps - 1,
-          expected_downstream_throughput_kbps,
-          EFFECTIVE_CONNECTION_TYPE_SLOW_2G, EFFECTIVE_CONNECTION_TYPE_2G,
+          expected_downstream_throughput_kbps, EFFECTIVE_CONNECTION_TYPE_4G,
+          EFFECTIVE_CONNECTION_TYPE_3G,
       },
   };
 
   for (const auto& accuracy_recording_delay : accuracy_recording_delays) {
     for (const auto& test : tests) {
       std::unique_ptr<base::SimpleTestTickClock> tick_clock(
           new base::SimpleTestTickClock());
       base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
       tick_clock_ptr->Advance(base::TimeDelta::FromSeconds(1));
 
       std::unique_ptr<ExternalEstimateProvider> external_estimate_provider(
           new TestExternalEstimateProvider(test.rtt, 0));
 
       std::map<std::string, std::string> variation_params;
       TestNetworkQualityEstimator estimator(
           variation_params, std::move(external_estimate_provider));
 
       estimator.SetTickClockForTesting(std::move(tick_clock));
       estimator.SimulateNetworkChange(
           NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, "test-1");
       tick_clock_ptr->Advance(base::TimeDelta::FromSeconds(1));
 
       std::vector<base::TimeDelta> accuracy_recording_intervals;
       accuracy_recording_intervals.push_back(accuracy_recording_delay);
       estimator.SetAccuracyRecordingIntervals(accuracy_recording_intervals);
 
       // RTT is higher than threshold. Network is slow.
       // Network was predicted to be slow and actually was slow.
-      estimator.set_http_rtt(test.rtt);
+      estimator.set_start_time_null_http_rtt(test.rtt);
       estimator.set_recent_http_rtt(test.recent_rtt);
-      estimator.set_transport_rtt(test.rtt);
+      estimator.set_start_time_null_transport_rtt(test.rtt);
       estimator.set_recent_transport_rtt(test.recent_rtt);
-      estimator.set_downlink_throughput_kbps(test.downstream_throughput_kbps);
+      estimator.set_start_time_null_downlink_throughput_kbps(
+          test.downstream_throughput_kbps);
       estimator.set_recent_downlink_throughput_kbps(
           test.recent_downstream_throughput_kbps);
-      estimator.set_effective_connection_type(test.effective_connection_type);
-      estimator.set_recent_effective_connection_type(
-          test.recent_effective_connection_type);
 
       base::HistogramTester histogram_tester;
 
       TestDelegate test_delegate;
       TestURLRequestContext context(true);
       context.set_network_quality_estimator(&estimator);
       context.Init();
 
       // Start a main-frame request which should cause network quality estimator
       // to record accuracy UMA.
       std::unique_ptr<URLRequest> request(context.CreateRequest(
           estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
       request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
       request->Start();
       base::RunLoop().Run();
 
       if (accuracy_recording_delay != base::TimeDelta()) {
         tick_clock_ptr->Advance(accuracy_recording_delay);
 
         // Sleep for some time to ensure that the delayed task is posted.
         base::PlatformThread::Sleep(accuracy_recording_delay * 2);
         base::RunLoop().RunUntilIdle();
       }
 
-      const int diff = std::abs(test.rtt.InMilliseconds() -
-                                test.recent_rtt.InMilliseconds());
-      const std::string sign_suffix_with_one_sample =
-          test.rtt.InMilliseconds() - test.recent_rtt.InMilliseconds() >= 0
-              ? "Positive"
-              : "Negative";
-      const std::string sign_suffix_with_zero_samples =
+      const int rtt_diff = std::abs(test.rtt.InMilliseconds() -
+                                    test.recent_rtt.InMilliseconds());
+      const int kbps_diff = std::abs(test.downstream_throughput_kbps -
+                                     test.recent_downstream_throughput_kbps);
+      const int ect_diff = std::abs(test.effective_connection_type -
+                                    test.recent_effective_connection_type);
+
+      const std::string rtt_sign_suffix_with_zero_samples =
           test.rtt.InMilliseconds() - test.recent_rtt.InMilliseconds() >= 0
               ? "Negative"
               : "Positive";
+      const std::string kbps_sign_suffix_with_zero_samples =
+          test.downstream_throughput_kbps -
+                      test.recent_downstream_throughput_kbps >=
+                  0
+              ? "Negative"
+              : "Positive";
+
+      const std::string rtt_sign_suffix_with_one_sample =
+          rtt_sign_suffix_with_zero_samples == "Positive" ? "Negative"
+                                                          : "Positive";
+      const std::string ect_sign_suffix_with_zero_samples =
+          test.rtt.InMilliseconds() - test.recent_rtt.InMilliseconds() > 0
+              ? "Positive"
+              : "Negative";
+
+      const std::string kbps_sign_suffix_with_one_sample =
+          kbps_sign_suffix_with_zero_samples == "Positive" ? "Negative"
+                                                           : "Positive";
+      const std::string ect_sign_suffix_with_one_sample =
+          ect_sign_suffix_with_zero_samples == "Positive" ? "Negative"
+                                                          : "Positive";
       const std::string interval_value =
           base::IntToString(accuracy_recording_delay.InSeconds());
 
       histogram_tester.ExpectUniqueSample(
           "NQE.Accuracy.DownstreamThroughputKbps.EstimatedObservedDiff." +
-              sign_suffix_with_one_sample + "." + interval_value + ".140_300",
-          diff, 1);
+              kbps_sign_suffix_with_one_sample + "." + interval_value +
+              ".1260_2540",
+          kbps_diff, 1);
       histogram_tester.ExpectTotalCount(
           "NQE.Accuracy.DownstreamThroughputKbps.EstimatedObservedDiff." +
-              sign_suffix_with_zero_samples + "." + interval_value + ".140_300",
+              kbps_sign_suffix_with_zero_samples + "." + interval_value +
+              ".1260_2540",
           0);
 
       histogram_tester.ExpectUniqueSample(
           "NQE.Accuracy.EffectiveConnectionType.EstimatedObservedDiff." +
-              sign_suffix_with_one_sample + "." + interval_value + ".2G",
-          diff, 1);
+              ect_sign_suffix_with_one_sample + "." + interval_value + ".3G",
+          ect_diff, 1);
       histogram_tester.ExpectTotalCount(
           "NQE.Accuracy.EffectiveConnectionType.EstimatedObservedDiff." +
-              sign_suffix_with_zero_samples + "." + interval_value + ".2G",
+              ect_sign_suffix_with_zero_samples + "." + interval_value + ".3G",
           0);
 
       histogram_tester.ExpectUniqueSample(
           "NQE.Accuracy.HttpRTT.EstimatedObservedDiff." +
-              sign_suffix_with_one_sample + "." + interval_value + ".60_140",
-          diff, 1);
+              rtt_sign_suffix_with_one_sample + "." + interval_value +
+              ".300_620",
+          rtt_diff, 1);
       histogram_tester.ExpectTotalCount(
           "NQE.Accuracy.HttpRTT.EstimatedObservedDiff." +
-              sign_suffix_with_zero_samples + "." + interval_value + ".60_140",
+              rtt_sign_suffix_with_zero_samples + "." + interval_value +
+              ".300_620",
           0);
       histogram_tester.ExpectUniqueSample(
           "NQE.Accuracy.TransportRTT.EstimatedObservedDiff." +
-              sign_suffix_with_one_sample + "." + interval_value + ".60_140",
-          diff, 1);
+              rtt_sign_suffix_with_one_sample + "." + interval_value +
+              ".300_620",
+          rtt_diff, 1);
       histogram_tester.ExpectTotalCount(
           "NQE.Accuracy.TransportRTT.EstimatedObservedDiff." +
-              sign_suffix_with_zero_samples + "." + interval_value + ".60_140",
+              rtt_sign_suffix_with_zero_samples + "." + interval_value +
+              ".300_620",
           0);
 
       histogram_tester.ExpectUniqueSample(
           "NQE.ExternalEstimateProvider.RTT.Accuracy.EstimatedObservedDiff." +
-              sign_suffix_with_one_sample + "." + interval_value + ".60_140",
-          diff, 1);
+              rtt_sign_suffix_with_one_sample + "." + interval_value +
+              ".300_620",
+          rtt_diff, 1);
       histogram_tester.ExpectTotalCount(
           "NQE.ExternalEstimateProvider.RTT.Accuracy.EstimatedObservedDiff." +
-              sign_suffix_with_zero_samples + "." + interval_value + ".60_140",
+              rtt_sign_suffix_with_zero_samples + "." + interval_value +
+              ".300_620",
           0);
     }
   }
 }
 
 TEST(NetworkQualityEstimatorTest, TestRecordNetworkIDAvailability) {
   base::HistogramTester histogram_tester;
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
@@ skipping 96 matching lines @@
 
     std::map<std::string, std::string> variation_params;
     variation_params["correlation_logging_probability"] =
         base::DoubleToString(test.correlation_logging_probability);
     if (test.use_transport_rtt) {
       variation_params["effective_connection_type_algorithm"] =
           "TransportRTTOrDownstreamThroughput";
     }
     TestNetworkQualityEstimator estimator(variation_params);
 
-    estimator.set_transport_rtt(test.transport_rtt);
+    estimator.set_start_time_null_transport_rtt(test.transport_rtt);
     estimator.set_recent_transport_rtt(test.transport_rtt);
-    estimator.set_http_rtt(test.http_rtt);
+    estimator.set_start_time_null_http_rtt(test.http_rtt);
     estimator.set_recent_http_rtt(test.http_rtt);
-    estimator.set_downlink_throughput_kbps(test.downstream_throughput_kbps);
+    estimator.set_start_time_null_downlink_throughput_kbps(
+        test.downstream_throughput_kbps);
     estimator.set_rand_double(test.rand_double);
 
     TestDelegate test_delegate;
     TestURLRequestContext context(true);
     context.set_network_quality_estimator(&estimator);
     context.Init();
 
     // Start a main-frame request that should cause network quality estimator to
     // record the network quality at the last main frame request.
     std::unique_ptr<URLRequest> request_1(context.CreateRequest(
@@ skipping 161 matching lines @@
     if (expected_count == 1) {
       EffectiveConnectionType last_notified_type =
           observer.effective_connection_types().at(
               observer.effective_connection_types().size() - 1);
       EXPECT_EQ(i, last_notified_type);
     }
   }
 }
 
 }  // namespace net