NQE: Allow algorithm to be set using variation params

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 554 matching lines @@
   EXPECT_EQ(300, kbps);
 
   // Simulate network change to 3G. Default estimates should be unavailable.
   estimator.SimulateNetworkChangeTo(
       NetworkChangeNotifier::ConnectionType::CONNECTION_3G, "test-3");
 
   EXPECT_FALSE(estimator.GetHttpRTTEstimate(&rtt));
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 }
 
+TEST(NetworkQualityEstimatorTest, ObtainAlgorithmToUseFromParams) {
+  const struct {
+    bool set_variation_param;
+    std::string algorithm;
+    NetworkQualityEstimator::EffectiveConnectionTypeAlgorithm
+        expected_algorithm;
+  } tests[] = {
+      {false, "", NetworkQualityEstimator::EffectiveConnectionTypeAlgorithm::
+                      HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT},
+      {true, "", NetworkQualityEstimator::EffectiveConnectionTypeAlgorithm::
+                     HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT},
+      {true, "HttpRTTAndDownstreamThroughput",
+       NetworkQualityEstimator::EffectiveConnectionTypeAlgorithm::
+           HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT},
+  };
+
+  for (const auto& test : tests) {
+    std::map<std::string, std::string> variation_params;
+    if (test.set_variation_param)
+      variation_params["effective_connection_type_algorithm"] = test.algorithm;
+
+    TestNetworkQualityEstimator estimator(variation_params);
+    EXPECT_EQ(test.expected_algorithm,
+              estimator.effective_connection_type_algorithm_)
+        << test.algorithm;
+  }
+}
+
 // Tests that |GetEffectiveConnectionType| returns correct connection type when
 // no variation params are specified.
 TEST(NetworkQualityEstimatorTest, ObtainThresholdsNone) {
   std::map<std::string, std::string> variation_params;
 
   TestNetworkQualityEstimator estimator(variation_params);
 
   // Simulate the connection type as Wi-Fi so that GetEffectiveConnectionType
   // does not return Offline if the device is offline.
   estimator.SimulateNetworkChangeTo(NetworkChangeNotifier::CONNECTION_WIFI,
                                     "test");
 
   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_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);
     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 51 matching lines @@
       {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_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);
     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 32 matching lines @@
       {1, 300, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
       {1, 400, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
       {1, 500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
       {1, 700, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
       {1, 1000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
       {1, 1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       {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_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);
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
@@ skipping 910 matching lines @@
           diff, 1);
       histogram_tester.ExpectTotalCount(
           "NQE.Accuracy.TransportRTT.EstimatedObservedDiff." +
               sign_suffix_with_zero_samples + "." + interval_value + ".60_140",
           0);
     }
   }
 }
 
 }  // namespace net