NQE: Add Transport RTT based GetECT algorithm

net/nqe/network_quality_estimator.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 <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
@@ skipping 75 matching lines @@
 // parameter for Wi-Fi would be "WiFi.DefaultMedianKbps".
 const char kDefaultKbpsObservationSuffix[] = ".DefaultMedianKbps";
 
 // Suffix of the name of the variation parameter that contains the threshold
 // HTTP RTTs (in milliseconds) for different effective connection types.
 // Complete name of the variation parameter would be
 // |EffectiveConnectionType|.|kThresholdURLRTTMsecSuffix|.
 const char kThresholdURLRTTMsecSuffix[] = ".ThresholdMedianHttpRTTMsec";
 
 // Suffix of the name of the variation parameter that contains the threshold
+// transport RTTs (in milliseconds) for different effective connection types.
+// Complete name of the variation parameter would be
+// |EffectiveConnectionType|.|kThresholdTransportRTTMsecSuffix|.
+const char kThresholdTransportRTTMsecSuffix[] =
+    ".ThresholdMedianTransportRTTMsec";
+
+// Suffix of the name of the variation parameter that contains the threshold
 // downlink throughput (in kbps) for different effective connection types.
 // Complete name of the variation parameter would be
 // |EffectiveConnectionType|.|kThresholdKbpsSuffix|.
 const char kThresholdKbpsSuffix[] = ".ThresholdMedianKbps";
 
 // Computes and returns the weight multiplier per second.
 // |variation_params| is the map containing all field trial parameters
 // related to NetworkQualityEstimator field trial.
 double GetWeightMultiplierPerSecond(
     const std::map<std::string, std::string>& variation_params) {
@@ skipping 114 matching lines @@
                               false,
                               false) {}
 
 NetworkQualityEstimator::NetworkQualityEstimator(
     std::unique_ptr<ExternalEstimateProvider> external_estimates_provider,
     const std::map<std::string, std::string>& variation_params,
     bool use_local_host_requests_for_tests,
     bool use_smaller_responses_for_tests)
     : algorithm_name_to_enum_({{"HttpRTTAndDownstreamThroughput",
                                 EffectiveConnectionTypeAlgorithm::
-                                    HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT}}),
+                                    HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT},
+                               {"TransportRTTOrDownstreamThroughput",
+                                EffectiveConnectionTypeAlgorithm::
+                                    TRANSPORT_RTT_OR_DOWNSTREAM_THROUGHOUT}}),
       use_localhost_requests_(use_local_host_requests_for_tests),
       use_small_responses_(use_smaller_responses_for_tests),
       weight_multiplier_per_second_(
           GetWeightMultiplierPerSecond(variation_params)),
       effective_connection_type_algorithm_(
           algorithm_name_to_enum_.find(GetEffectiveConnectionTypeAlgorithm(
               variation_params)) == algorithm_name_to_enum_.end()
               ? kDefaultEffectiveConnectionTypeAlgorithm
               : algorithm_name_to_enum_
                     .find(GetEffectiveConnectionTypeAlgorithm(variation_params))
@@ skipping 125 matching lines @@
       continue;
 
     std::string connection_type_name = std::string(
         GetNameForEffectiveConnectionType(effective_connection_type));
 
     int32_t variations_value = kMinimumRTTVariationParameterMsec - 1;
     if (GetValueForVariationParam(
             variation_params, connection_type_name + kThresholdURLRTTMsecSuffix,
             &variations_value) &&
         variations_value >= kMinimumRTTVariationParameterMsec) {
-      base::TimeDelta rtt(base::TimeDelta::FromMilliseconds(variations_value));
-      connection_thresholds_[i] = nqe::internal::NetworkQuality(
-          rtt, connection_thresholds_[i].transport_rtt(),
-          connection_thresholds_[i].downstream_throughput_kbps());
+      connection_thresholds_[i].set_http_rtt(
+          base::TimeDelta(base::TimeDelta::FromMilliseconds(variations_value)));
 
       // Verify that the RTT values are in decreasing order as the network
       // quality improves.
       DCHECK(i == 0 ||
              connection_thresholds_[i - 1].http_rtt() ==
                  nqe::internal::InvalidRTT() ||
-             rtt <= connection_thresholds_[i - 1].http_rtt());
+             connection_thresholds_[i].http_rtt() <=
+                 connection_thresholds_[i - 1].http_rtt());
+    }
+
+    variations_value = kMinimumRTTVariationParameterMsec - 1;
+    if (GetValueForVariationParam(
+            variation_params,
+            connection_type_name + kThresholdTransportRTTMsecSuffix,
+            &variations_value) &&
+        variations_value >= kMinimumRTTVariationParameterMsec) {
+      connection_thresholds_[i].set_transport_rtt(
+          base::TimeDelta(base::TimeDelta::FromMilliseconds(variations_value)));
+
+      // Verify that the transport RTT values are in decreasing order as the
+      // network quality improves.
+      DCHECK(i == 0 ||
+             connection_thresholds_[i - 1].transport_rtt() ==
+                 nqe::internal::InvalidRTT() ||
+             connection_thresholds_[i].transport_rtt() <=
+                 connection_thresholds_[i - 1].transport_rtt());
     }
 
     variations_value = kMinimumThroughputVariationParameterKbps - 1;
     if (GetValueForVariationParam(variation_params,
                                   connection_type_name + kThresholdKbpsSuffix,
                                   &variations_value) &&
         variations_value >= kMinimumThroughputVariationParameterKbps) {
-      int32_t throughput_kbps = variations_value;
-      connection_thresholds_[i] = nqe::internal::NetworkQuality(
-          connection_thresholds_[i].http_rtt(),
-          connection_thresholds_[i].transport_rtt(), throughput_kbps);
+      connection_thresholds_[i].set_downstream_throughput_kbps(
+          variations_value);
 
       // Verify that the throughput values are in increasing order as the
       // network quality improves.
       DCHECK(i == 0 ||
              connection_thresholds_[i - 1].downstream_throughput_kbps() ==
                  kMinimumThroughputVariationParameterKbps ||
-             throughput_kbps >=
+             connection_thresholds_[i].downstream_throughput_kbps() >=
                  connection_thresholds_[i - 1].downstream_throughput_kbps());
     }
   }
 }
 
 void NetworkQualityEstimator::AddDefaultEstimates() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (default_observations_[current_network_id_.type].http_rtt() !=
       nqe::internal::InvalidRTT()) {
@@ skipping 467 matching lines @@
   return GetRecentEffectiveConnectionType(base::TimeTicks());
 }
 
 NetworkQualityEstimator::EffectiveConnectionType
 NetworkQualityEstimator::GetRecentEffectiveConnectionType(
     const base::TimeTicks& start_time) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (effective_connection_type_algorithm_ ==
       EffectiveConnectionTypeAlgorithm::HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT) {
-    return GetRecentEffectiveConnectionTypeHttpRTTAndDownstreamThroughput(
-        start_time);
+    return GetRecentEffectiveConnectionTypeUsingMetrics(
+        start_time, NetworkQualityEstimator::MetricUsage::
+                        MUST_BE_USED /* http_rtt_metric */,
+        NetworkQualityEstimator::MetricUsage::
+            DO_NOT_USE /* transport_rtt_metric */,
+        NetworkQualityEstimator::MetricUsage::
+            MUST_BE_USED /* downstream_throughput_kbps_metric */);
+  }
+  if (effective_connection_type_algorithm_ ==
+      EffectiveConnectionTypeAlgorithm::
+          TRANSPORT_RTT_OR_DOWNSTREAM_THROUGHOUT) {
+    return GetRecentEffectiveConnectionTypeUsingMetrics(
+        start_time,
+        NetworkQualityEstimator::MetricUsage::DO_NOT_USE /* http_rtt_metric */,
+        NetworkQualityEstimator::MetricUsage::
+            USE_IF_AVAILABLE /* transport_rtt_metric */,
+        NetworkQualityEstimator::MetricUsage::
+            USE_IF_AVAILABLE /* downstream_throughput_kbps_metric */);
   }
   // Add additional algorithms here.
   NOTREACHED();
   return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
 }
 
-NetworkQualityEstimator::EffectiveConnectionType NetworkQualityEstimator::
-    GetRecentEffectiveConnectionTypeHttpRTTAndDownstreamThroughput(
-        const base::TimeTicks& start_time) const {
+NetworkQualityEstimator::EffectiveConnectionType
+NetworkQualityEstimator::GetRecentEffectiveConnectionTypeUsingMetrics(
+    const base::TimeTicks& start_time,
+    NetworkQualityEstimator::MetricUsage http_rtt_metric,
+    NetworkQualityEstimator::MetricUsage transport_rtt_metric,
+    NetworkQualityEstimator::MetricUsage downstream_throughput_kbps_metric)
+    const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If the device is currently offline, then return
   // EFFECTIVE_CONNECTION_TYPE_OFFLINE.
   if (GetCurrentNetworkID().type == NetworkChangeNotifier::CONNECTION_NONE)
     return EFFECTIVE_CONNECTION_TYPE_OFFLINE;
 
   base::TimeDelta http_rtt = nqe::internal::InvalidRTT();
-  if (!GetRecentHttpRTTMedian(start_time, &http_rtt))
+  if (http_rtt_metric != NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
+      !GetRecentHttpRTTMedian(start_time, &http_rtt)) {
     http_rtt = nqe::internal::InvalidRTT();
+  }
+
+  base::TimeDelta transport_rtt = nqe::internal::InvalidRTT();
+  if (transport_rtt_metric !=
+          NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
+      !GetRecentTransportRTTMedian(start_time, &transport_rtt)) {
+    transport_rtt = nqe::internal::InvalidRTT();
+  }
 
   int32_t kbps = nqe::internal::kInvalidThroughput;
-  if (!GetRecentMedianDownlinkThroughputKbps(start_time, &kbps))
+  if (downstream_throughput_kbps_metric !=
+          NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
+      !GetRecentMedianDownlinkThroughputKbps(start_time, &kbps)) {
     kbps = nqe::internal::kInvalidThroughput;
+  }
 
-  if (http_rtt == nqe::internal::InvalidRTT() ||
-      kbps == nqe::internal::kInvalidThroughput) {
-    // Quality of the current network is unknown.
+  if (http_rtt == nqe::internal::InvalidRTT() &&
+      http_rtt_metric == NetworkQualityEstimator::MetricUsage::MUST_BE_USED) {
     return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
   }
 
+  if (transport_rtt == nqe::internal::InvalidRTT() &&
+      transport_rtt_metric ==
+          NetworkQualityEstimator::MetricUsage::MUST_BE_USED) {
+    return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
+  }
+
+  if (kbps == nqe::internal::kInvalidThroughput &&
+      downstream_throughput_kbps_metric ==
+          NetworkQualityEstimator::MetricUsage::MUST_BE_USED) {
+    return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
+  }
+
+  if (http_rtt == nqe::internal::InvalidRTT() &&
+      transport_rtt == nqe::internal::InvalidRTT() &&
+      kbps == nqe::internal::kInvalidThroughput) {
+    // None of the metrics are available.
+    return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
+  }
+
   // Search from the slowest connection type to the fastest to find the
   // EffectiveConnectionType that best matches the current connection's
   // performance. The match is done by comparing RTT and throughput.
   for (size_t i = 0; i < EFFECTIVE_CONNECTION_TYPE_LAST; ++i) {
     EffectiveConnectionType type = static_cast<EffectiveConnectionType>(i);
     if (i == EFFECTIVE_CONNECTION_TYPE_UNKNOWN)
       continue;
-    bool estimated_http_rtt_is_higher_than_threshold =
+
+    const bool estimated_http_rtt_is_higher_than_threshold =
         http_rtt != nqe::internal::InvalidRTT() &&
         connection_thresholds_[i].http_rtt() != nqe::internal::InvalidRTT() &&
         http_rtt >= connection_thresholds_[i].http_rtt();
-    bool estimated_throughput_is_lower_than_threshold =
+
+    const bool estimated_transport_rtt_is_higher_than_threshold =
+        transport_rtt != nqe::internal::InvalidRTT() &&
+        connection_thresholds_[i].transport_rtt() !=
+            nqe::internal::InvalidRTT() &&
+        transport_rtt >= connection_thresholds_[i].transport_rtt();
+
+    const bool estimated_throughput_is_lower_than_threshold =
         kbps != nqe::internal::kInvalidThroughput &&
         connection_thresholds_[i].downstream_throughput_kbps() !=
             nqe::internal::kInvalidThroughput &&
         kbps <= connection_thresholds_[i].downstream_throughput_kbps();
 
-    // Return |type| as the effective connection type if the current network's
-    // RTT is worse than the threshold RTT for |type|, or if the current
-    // network's throughput is lower than the threshold throughput for |type|.
     if (estimated_http_rtt_is_higher_than_threshold ||
+        estimated_transport_rtt_is_higher_than_threshold ||
         estimated_throughput_is_lower_than_threshold) {
       return type;
     }
   }
   // Return the fastest connection type.
   return static_cast<EffectiveConnectionType>(EFFECTIVE_CONNECTION_TYPE_LAST -
                                               1);
 }
 
 void NetworkQualityEstimator::AddEffectiveConnectionTypeObserver(
@@ skipping 405 matching lines @@
     NotifyObserversOfEffectiveConnectionTypeChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(tbansal): Add hysteresis in the notification.
   FOR_EACH_OBSERVER(
       EffectiveConnectionTypeObserver, effective_connection_type_observer_list_,
       OnEffectiveConnectionTypeChanged(effective_connection_type_));
 }
 
 }  // namespace net