NQE: Change GetEffectiveConnectionType to return last ECT

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 98 matching lines @@
   std::unique_ptr<test_server::HttpResponse> HandleRequest(
       const test_server::HttpRequest& request) {
     std::unique_ptr<test_server::BasicHttpResponse> http_response(
         new test_server::BasicHttpResponse());
     http_response->set_code(HTTP_OK);
     http_response->set_content("hello");
     http_response->set_content_type("text/plain");
     return std::move(http_response);
   }
 
+  // Runs one URL request to completion.
+  void RunOneRequest() {
+    TestDelegate test_delegate;
+    TestURLRequestContext context(true);
+    context.set_network_quality_estimator(this);
+    context.Init();
+    std::unique_ptr<URLRequest> request(
+        context.CreateRequest(GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
+    request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME);
+    request->Start();
+    base::RunLoop().Run();
+  }
+
   // Returns a GURL hosted at embedded test server.
   const GURL GetEchoURL() const {
     return embedded_test_server_.GetURL("/echo.html");
   }
 
   void set_effective_connection_type(EffectiveConnectionType type) {
     effective_connection_type_set_ = true;
     effective_connection_type_ = type;
   }
 
@@ skipping 682 matching lines @@
       {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_recent_http_rtt(
         base::TimeDelta::FromMilliseconds(test.rtt_msec));
     estimator.set_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.
 TEST(NetworkQualityEstimatorTest, DefaultTransportRTTBasedThresholds) {
   const struct {
     bool override_defaults_using_variation_params;
     int32_t transport_rtt_msec;
@@ skipping 34 matching lines @@
     // does not return Offline if the device is offline.
     estimator.SimulateNetworkChangeTo(NetworkChangeNotifier::CONNECTION_WIFI,
                                       "test");
 
     estimator.set_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_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.
 TEST(NetworkQualityEstimatorTest, DefaultHttpRTTBasedThresholds) {
   const struct {
     bool override_defaults_using_variation_params;
     int32_t http_rtt_msec;
@@ skipping 32 matching lines @@
     // does not return Offline if the device is offline.
     estimator.SimulateNetworkChangeTo(NetworkChangeNotifier::CONNECTION_WIFI,
                                       "test");
 
     estimator.set_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_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.
 TEST(NetworkQualityEstimatorTest, ObtainThresholdsOnlyTransportRTT) {
   std::map<std::string, std::string> variation_params;
   variation_params["effective_connection_type_algorithm"] =
       "TransportRTTOrDownstreamThroughput";
@@ skipping 30 matching lines @@
       {20, EFFECTIVE_CONNECTION_TYPE_4G},
   };
 
   for (const auto& test : tests) {
     estimator.set_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_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
 // params.
 TEST(NetworkQualityEstimatorTest, ObtainThresholdsHttpRTTandThroughput) {
   std::map<std::string, std::string> variation_params;
 
@@ skipping 40 matching lines @@
       {700, 25000, EFFECTIVE_CONNECTION_TYPE_3G},
   };
 
   for (const auto& test : tests) {
     estimator.set_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_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
 // both transport RTT and throughput thresholds are specified in the variation
 // params.
 TEST(NetworkQualityEstimatorTest, ObtainThresholdsTransportRTTandThroughput) {
   std::map<std::string, std::string> variation_params;
   variation_params["effective_connection_type_algorithm"] =
@@ skipping 43 matching lines @@
   };
 
   for (const auto& test : tests) {
     estimator.set_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_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
 // values of half life parameter.
 TEST(NetworkQualityEstimatorTest, HalfLifeParam) {
   std::map<std::string, std::string> variation_params;
 
   const struct {
@@ skipping 441 matching lines @@
   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_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_2G);
+  estimator.set_recent_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_2G);
   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);
   request->Start();
   base::RunLoop().Run();
   EXPECT_EQ(1U, observer.effective_connection_types().size());
   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);
   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_recent_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_3G);
   estimator.SimulateNetworkChangeTo(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_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_3G);
+  estimator.set_recent_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_3G);
   EXPECT_EQ(2U, observer.effective_connection_types().size());
 }
 
 // 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();
 
   TestEffectiveConnectionTypeObserver observer;
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
   estimator.SetTickClockForTesting(std::move(tick_clock));
   estimator.AddEffectiveConnectionTypeObserver(&observer);
   tick_clock_ptr->Advance(base::TimeDelta::FromMinutes(60));
 
   size_t expected_effective_connection_type_notifications = 0;
-  estimator.set_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
+  estimator.set_recent_effective_connection_type(
+      EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
+  // Run one main frame request to force recomputation of effective connection
+  // type.
+  estimator.RunOneRequest();
   estimator.SimulateNetworkChangeTo(NetworkChangeNotifier::CONNECTION_WIFI,
                                     "test");
 
   NetworkQualityEstimator::RttObservation rtt_observation(
       base::TimeDelta::FromSeconds(5), tick_clock_ptr->NowTicks(),
       NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST);
 
   for (size_t i = 0; i < 10; ++i) {
     estimator.NotifyObserversOfRTT(rtt_observation);
     EXPECT_EQ(expected_effective_connection_type_notifications,
               observer.effective_connection_types().size());
   }
-  estimator.set_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
+  estimator.set_recent_effective_connection_type(
+      EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   // Even though there are 10 RTT samples already available, the addition of one
   // more RTT sample should trigger recomputation of the effective connection
   // type since the last computed effective connection type was unknown.
   estimator.NotifyObserversOfRTT(NetworkQualityEstimator::RttObservation(
       base::TimeDelta::FromSeconds(5), tick_clock_ptr->NowTicks(),
       NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
   ++expected_effective_connection_type_notifications;
   EXPECT_EQ(expected_effective_connection_type_notifications,
             observer.effective_connection_types().size());
 }
@@ skipping 15 matching lines @@
                                     "test");
   estimator.AddEffectiveConnectionTypeObserver(&observer);
 
   TestDelegate test_delegate;
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
   EXPECT_EQ(0U, observer.effective_connection_types().size());
 
-  estimator.set_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_2G);
+  estimator.set_recent_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_2G);
   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);
   request->Start();
   base::RunLoop().Run();
   EXPECT_EQ(1U, observer.effective_connection_types().size());
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType.WiFi",
       EFFECTIVE_CONNECTION_TYPE_2G, 1);
 
   size_t expected_effective_connection_type_notifications = 1;
   EXPECT_EQ(expected_effective_connection_type_notifications,
             observer.effective_connection_types().size());
 
   EXPECT_EQ(expected_effective_connection_type_notifications,
             estimator.rtt_observations_.Size());
 
   // Increase the number of RTT observations. Every time the number of RTT
   // observations is more than doubled, effective connection type must be
   // recomputed and notified to observers.
   for (size_t repetition = 0; repetition < 2; ++repetition) {
     // Change the effective connection type so that the observers are
     // notified when the effective connection type is recomputed.
     if (repetition % 2 == 0) {
-      estimator.set_effective_connection_type(
+      estimator.set_recent_effective_connection_type(
           EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
     } else {
-      estimator.set_effective_connection_type(EFFECTIVE_CONNECTION_TYPE_3G);
+      estimator.set_recent_effective_connection_type(
+          EFFECTIVE_CONNECTION_TYPE_3G);
     }
-    size_t rtt_observations_count = estimator.rtt_observations_.Size();
+    size_t rtt_observations_count = estimator.rtt_observations_.Size() * 0.5;
     // Increase the number of RTT observations to more than twice the number
     // of current observations. This should trigger recomputation of
     // effective connection type.
     for (size_t i = 0; i < rtt_observations_count + 1; ++i) {
       estimator.rtt_observations_.AddObservation(
           NetworkQualityEstimator::RttObservation(
               base::TimeDelta::FromSeconds(5), tick_clock_ptr->NowTicks(),
               NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
 
       estimator.NotifyObserversOfRTT(NetworkQualityEstimator::RttObservation(
@@ skipping 508 matching lines @@
 
     // Get the bits at index 18-24 which contain the resource fetch time.
     EXPECT_LE(0, (buckets.at(0).min >> kBitsPerMetric) % 128);
 
     // Get the bits at index 25-31 which contain the resource load size.
     EXPECT_LE(0, (buckets.at(0).min) % 128);
   }
 }
 
 }  // namespace net