Expose a method GetRecentEffectiveConnectionType in NQE.

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 47 matching lines @@
   TestNetworkQualityEstimator(
       std::unique_ptr<net::ExternalEstimateProvider> external_estimate_provider,
       const std::map<std::string, std::string>& variation_params,
       bool allow_local_host_requests_for_tests,
       bool allow_smaller_responses_for_tests)
       : NetworkQualityEstimator(std::move(external_estimate_provider),
                                 variation_params,
                                 allow_local_host_requests_for_tests,
                                 allow_smaller_responses_for_tests),
         current_network_simulated_(false),
-        url_rtt_set_(false),
+        http_rtt_set_(false),
         downlink_throughput_kbps_set_(false) {
     // Set up embedded test server.
     embedded_test_server_.ServeFilesFromDirectory(
         base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
     EXPECT_TRUE(embedded_test_server_.Start());
     embedded_test_server_.RegisterRequestHandler(base::Bind(
         &TestNetworkQualityEstimator::HandleRequest, base::Unretained(this)));
   }
 
   explicit TestNetworkQualityEstimator(
@@ skipping 23 matching lines @@
     http_response->set_content("hello");
     http_response->set_content_type("text/plain");
     return std::move(http_response);
   }
 
   // Returns a GURL hosted at embedded test server.
   const GURL GetEchoURL() const {
     return embedded_test_server_.GetURL("/echo.html");
   }
 
-  void set_url_rtt(const base::TimeDelta& url_rtt) {
-    url_rtt_set_ = true;
-    url_rtt_ = url_rtt;
+  void set_http_rtt(const base::TimeDelta& http_rtt) {
+    http_rtt_set_ = true;
+    http_rtt_ = http_rtt;
   }
 
   bool GetHttpRTTEstimate(base::TimeDelta* rtt) const override {
-    if (url_rtt_set_) {
-      *rtt = url_rtt_;
+    if (http_rtt_set_) {
+      *rtt = http_rtt_;
       return true;
     }
     return NetworkQualityEstimator::GetHttpRTTEstimate(rtt);
   }
 
+  bool GetRecentHttpRTTMedian(const base::TimeTicks& start_time,
+                              base::TimeDelta* rtt) const override {
+    if (http_rtt_set_) {
+      *rtt = http_rtt_;
+      return true;
+    }
+    return NetworkQualityEstimator::GetRecentHttpRTTMedian(start_time, rtt);
+  }
+
   void set_downlink_throughput_kbps(int32_t downlink_throughput_kbps) {
     downlink_throughput_kbps_set_ = true;
     downlink_throughput_kbps_ = downlink_throughput_kbps;
   }
 
   bool GetDownlinkThroughputKbpsEstimate(int32_t* kbps) const override {
     if (downlink_throughput_kbps_set_) {
       *kbps = downlink_throughput_kbps_;
       return true;
     }
     return NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimate(kbps);
   }
 
+  bool GetRecentMedianDownlinkThroughputKbps(const base::TimeTicks& start_time,
+                                             int32_t* kbps) const override {
+    if (downlink_throughput_kbps_set_) {
+      *kbps = downlink_throughput_kbps_;
+      return true;
+    }
+    return NetworkQualityEstimator::GetRecentMedianDownlinkThroughputKbps(
+        start_time, kbps);
+  }
+
   using NetworkQualityEstimator::ReadCachedNetworkQualityEstimate;
   using NetworkQualityEstimator::OnConnectionTypeChanged;
 
  private:
   // True if the network type and network id are currently simulated. This
   // ensures that the correctness of the test does not depend on the
   // actual network type of the device on which the test is running.
   bool current_network_simulated_;
 
   // NetworkQualityEstimator implementation that returns the overridden network
   // id (instead of invoking platform APIs).
   NetworkQualityEstimator::NetworkID GetCurrentNetworkID() const override {
     // GetCurrentNetworkID should be called only if the network type is
     // currently simulated.
     EXPECT_TRUE(current_network_simulated_);
 
     return NetworkQualityEstimator::NetworkID(current_network_type_,
                                               current_network_id_);
   }
 
   NetworkChangeNotifier::ConnectionType current_network_type_;
   std::string current_network_id_;
 
-  bool url_rtt_set_;
-  base::TimeDelta url_rtt_;
+  bool http_rtt_set_;
+  base::TimeDelta http_rtt_;
 
   bool downlink_throughput_kbps_set_;
   int32_t downlink_throughput_kbps_;
 
   // Embedded server used for testing.
   EmbeddedTestServer embedded_test_server_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkQualityEstimator);
 };
 
@@ skipping 279 matching lines @@
 
   const struct {
     int32_t rtt_msec;
     NetworkQualityEstimator::EffectiveConnectionType expected_conn_type;
   } tests[] = {
       {5000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       {20, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
   };
 
   for (const auto& test : tests) {
-    estimator.set_url_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
+    estimator.set_http_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that |GetEffectiveConnectionType| returns
 // EFFECTIVE_CONNECTION_TYPE_OFFLINE when the device is currently offline.
 TEST(NetworkQualityEstimatorTest, Offline) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
@@ skipping 48 matching lines @@
       {700, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
       {500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
       {400, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
       {300, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
       {200, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       {100, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       {20, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
   };
 
   for (const auto& test : tests) {
-    estimator.set_url_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
+    estimator.set_http_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that |GetEffectiveConnectionType| returns correct connection type when
 // both RTT and throughput thresholds are specified in the variation params.
 TEST(NetworkQualityEstimatorTest, ObtainThresholdsRTTandThroughput) {
   std::map<std::string, std::string> variation_params;
 
   variation_params["Offline.ThresholdMedianHttpRTTMsec"] = "4000";
@@ skipping 38 matching lines @@
       {1, 2500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       // Set both RTT and throughput. RTT is the bottleneck.
       {3000, 25000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
       {700, 25000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
       // Set throughput to an invalid value.
       {3000, 0, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
       {700, 0, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
   };
 
   for (const auto& test : tests) {
-    estimator.set_url_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
+    estimator.set_http_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
     estimator.set_downlink_throughput_kbps(test.downlink_throughput_kbps);
     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;
 
@@ skipping 171 matching lines @@
 
   // Test that the cache is LRU by examining its contents. Networks in cache
   // must all be newer than the 100th network.
   for (NetworkQualityEstimator::CachedNetworkQualities::iterator it =
            estimator.cached_network_qualities_.begin();
        it != estimator.cached_network_qualities_.end(); ++it) {
     EXPECT_GE((it->second).last_update_time_, update_time_of_network_100);
   }
 }
 
-TEST(NetworkQualityEstimatorTest, TestGetMedianRTTSince) {
+TEST(NetworkQualityEstimatorTest, TestGetMetricsSince) {
   std::map<std::string, std::string> variation_params;
+
+  const base::TimeDelta rtt_threshold_4g =
+      base::TimeDelta::FromMilliseconds(30);
+  const base::TimeDelta rtt_threshold_broadband =
+      base::TimeDelta::FromMilliseconds(1);
+
+  variation_params["4G.ThresholdMedianHttpRTTMsec"] =
+      base::IntToString(rtt_threshold_4g.InMilliseconds());
+  variation_params["Broadband.ThresholdMedianHttpRTTMsec"] =
+      base::IntToString(rtt_threshold_broadband.InMilliseconds());
+  variation_params["HalfLifeSeconds"] = "300000";
+
   TestNetworkQualityEstimator estimator(variation_params);
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks old = now - base::TimeDelta::FromMilliseconds(1);
   ASSERT_NE(old, now);
 
+  estimator.SimulateNetworkChangeTo(
+      NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, "test");
+
+  const int32_t old_downlink_kbps = 1;
+  const base::TimeDelta old_url_rtt = base::TimeDelta::FromMilliseconds(1);
+  const base::TimeDelta old_tcp_rtt = base::TimeDelta::FromMilliseconds(10);
+
+  DCHECK_LT(old_url_rtt, rtt_threshold_4g);
+  DCHECK_LT(old_tcp_rtt, rtt_threshold_4g);
+
   // First sample has very old timestamp.
+  for (size_t i = 0; i < 2; ++i) {
+    estimator.downstream_throughput_kbps_observations_.AddObservation(
+        NetworkQualityEstimator::ThroughputObservation(
+            old_downlink_kbps, old,
+            NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
+    estimator.rtt_observations_.AddObservation(
+        NetworkQualityEstimator::RttObservation(
+            old_url_rtt, old, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
+    estimator.rtt_observations_.AddObservation(
+        NetworkQualityEstimator::RttObservation(
+            old_tcp_rtt, old, NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
+  }
+
+  const int32_t new_downlink_kbps = 100;
+  const base::TimeDelta new_url_rtt = base::TimeDelta::FromMilliseconds(100);
+  const base::TimeDelta new_tcp_rtt = base::TimeDelta::FromMilliseconds(1000);
+
+  DCHECK_NE(old_downlink_kbps, new_downlink_kbps);
+  DCHECK_NE(old_url_rtt, new_url_rtt);
+  DCHECK_NE(old_tcp_rtt, new_tcp_rtt);
+  DCHECK_GT(new_url_rtt, rtt_threshold_4g);
+  DCHECK_GT(new_tcp_rtt, rtt_threshold_4g);
+  DCHECK_GT(new_url_rtt, rtt_threshold_broadband);
+  DCHECK_GT(new_tcp_rtt, rtt_threshold_broadband);
+
   estimator.downstream_throughput_kbps_observations_.AddObservation(
       NetworkQualityEstimator::ThroughputObservation(
-          1, old, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
-  estimator.rtt_observations_.AddObservation(
-      NetworkQualityEstimator::RttObservation(
-          base::TimeDelta::FromMilliseconds(1), old,
+          new_downlink_kbps, now,
           NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
   estimator.rtt_observations_.AddObservation(
       NetworkQualityEstimator::RttObservation(
-          base::TimeDelta::FromMilliseconds(10), old,
-          NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
-
-  estimator.downstream_throughput_kbps_observations_.AddObservation(
-      NetworkQualityEstimator::ThroughputObservation(
-          100, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
+          new_url_rtt, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
   estimator.rtt_observations_.AddObservation(
       NetworkQualityEstimator::RttObservation(
-          base::TimeDelta::FromMilliseconds(100), now,
-          NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
-  estimator.rtt_observations_.AddObservation(
-      NetworkQualityEstimator::RttObservation(
-          base::TimeDelta::FromMilliseconds(1000), now,
-          NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
+          new_tcp_rtt, now, NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
 
   const struct {
     base::TimeTicks start_timestamp;
     bool expect_network_quality_available;
     base::TimeDelta expected_http_rtt;
     base::TimeDelta expected_transport_rtt;
     int32_t expected_downstream_throughput;
+    NetworkQualityEstimator::EffectiveConnectionType
+        expected_effective_connection_type;
   } tests[] = {
       {now + base::TimeDelta::FromSeconds(10), false,
        base::TimeDelta::FromMilliseconds(0),
-       base::TimeDelta::FromMilliseconds(0), 0},
-      {now, true, base::TimeDelta::FromMilliseconds(100),
-       base::TimeDelta::FromMilliseconds(1000), 100},
-      {now - base::TimeDelta::FromMicroseconds(500), true,
-       base::TimeDelta::FromMilliseconds(100),
-       base::TimeDelta::FromMilliseconds(1000), 100},
+       base::TimeDelta::FromMilliseconds(0), 0,
+       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {now, true, new_url_rtt, new_tcp_rtt, new_downlink_kbps,
+       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
+      {old - base::TimeDelta::FromMicroseconds(500), true, old_url_rtt,
+       old_tcp_rtt, old_downlink_kbps,
+       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
 
   };
-
   for (const auto& test : tests) {
     base::TimeDelta http_rtt;
     base::TimeDelta transport_rtt;
     int32_t downstream_throughput_kbps;
     EXPECT_EQ(
         test.expect_network_quality_available,
         estimator.GetRecentHttpRTTMedian(test.start_timestamp, &http_rtt));
     EXPECT_EQ(test.expect_network_quality_available,
               estimator.GetRecentTransportRTTMedian(test.start_timestamp,
                                                     &transport_rtt));
     EXPECT_EQ(test.expect_network_quality_available,
               estimator.GetRecentMedianDownlinkThroughputKbps(
                   test.start_timestamp, &downstream_throughput_kbps));
 
     if (test.expect_network_quality_available) {
       EXPECT_EQ(test.expected_http_rtt, http_rtt);
       EXPECT_EQ(test.expected_transport_rtt, transport_rtt);
       EXPECT_EQ(test.expected_downstream_throughput,
                 downstream_throughput_kbps);
+      EXPECT_EQ(
+          test.expected_effective_connection_type,
+          estimator.GetRecentEffectiveConnectionType(test.start_timestamp));
     }
   }
 }
 
 // An external estimate provider that does not have a valid RTT or throughput
 // estimate.
 class InvalidExternalEstimateProvider : public ExternalEstimateProvider {
  public:
   InvalidExternalEstimateProvider()
       : get_rtt_count_(0), get_downstream_throughput_count_(0) {}
@@ skipping 501 matching lines @@
   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",
                                     1);
 }
 
 }  // namespace net