NQE: Add Transport RTT based GetECT algorithm

net/nqe/network_quality_estimator.h

 // 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.
 
 #ifndef NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_
 #define NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 274 matching lines @@
   // ExternalEstimateProvider::UpdatedEstimateObserver implementation.
   void OnUpdatedEstimateAvailable(const base::TimeDelta& rtt,
                                   int32_t downstream_throughput_kbps,
                                   int32_t upstream_throughput_kbps) override;
 
   // Returns true if the RTT is available and sets |rtt| to the RTT estimated at
   // the HTTP layer. Virtualized for testing. |rtt| should not be null. The RTT
   // at the HTTP layer measures the time from when the request was sent (this
   // happens after the connection is established) to the time when the response
   // headers were received.
+  // TODO(tbansal): Change it to return HTTP RTT as base::TimeDelta.
   virtual bool GetHttpRTTEstimate(base::TimeDelta* rtt) const
       WARN_UNUSED_RESULT;
 
   // Returns true if the RTT is available and sets |rtt| to the RTT estimated at
   // the transport layer. |rtt| should not be null. Virtualized for testing.
+  // TODO(tbansal): Change it to return transport RTT as base::TimeDelta.
   virtual bool GetTransportRTTEstimate(base::TimeDelta* rtt) const
       WARN_UNUSED_RESULT;
 
   // Returns true if downlink throughput is available and sets |kbps| to
   // estimated downlink throughput (in kilobits per second).
   // Virtualized for testing. |kbps| should not be null.
+  // TODO(tbansal): Change it to return throughput as int32.
   virtual bool GetDownlinkThroughputKbpsEstimate(int32_t* kbps) const;
 
   // Returns true if median RTT at the HTTP layer is available and sets |rtt|
   // to the median of RTT observations since |start_time|.
   // Virtualized for testing. |rtt| should not be null. The RTT at the HTTP
   // layer measures the time from when the request was sent (this happens after
   // the connection is established) to the time when the response headers were
   // received.
+  // TODO(tbansal): Change it to return HTTP RTT as base::TimeDelta.
   virtual bool GetRecentHttpRTTMedian(const base::TimeTicks& start_time,
                                       base::TimeDelta* rtt) const
       WARN_UNUSED_RESULT;
 
   // Returns true if the median RTT at the transport layer is available and sets
   // |rtt| to the median of transport layer RTT observations since
   // |start_time|. |rtt| should not be null. Virtualized for testing.
+  // TODO(tbansal): Change it to return transport RTT as base::TimeDelta.
   virtual bool GetRecentTransportRTTMedian(const base::TimeTicks& start_time,
                                            base::TimeDelta* rtt) const
       WARN_UNUSED_RESULT;
 
   // Returns true if median downstream throughput is available and sets |kbps|
   // to the median of downstream throughput (in kilobits per second)
   // observations since |start_time|. Virtualized for testing. |kbps|
   // should not be null. Virtualized for testing.
+  // TODO(tbansal): Change it to return throughput as int32.
   virtual bool GetRecentMedianDownlinkThroughputKbps(
       const base::TimeTicks& start_time,
       int32_t* kbps) const WARN_UNUSED_RESULT;
 
   // Returns the list of intervals at which the accuracy of network quality
   // prediction should be recorded. Virtualized for testing.
   virtual const std::vector<base::TimeDelta>& GetAccuracyRecordingIntervals()
       const;
 
   // Overrides the tick clock used by |this| for testing.
@@ skipping 26 matching lines @@
   // This does not use a unordered_map or hash_map for code simplicity (key just
   // implements operator<, rather than hash and equality) and because the map is
   // tiny.
   typedef std::map<NetworkID, nqe::internal::CachedNetworkQuality>
       CachedNetworkQualities;
 
   // Algorithms supported by network quality estimator for computing effective
   // connection type.
   enum class EffectiveConnectionTypeAlgorithm {
     HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT = 0,
+    TRANSPORT_RTT_OR_DOWNSTREAM_THROUGHOUT,
     EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST
   };
 
+  // Defines how a metric (e.g, transport RTT) should be used when computing
+  // the effective connection type.
+  enum class MetricUsage {
+    // The metric should not be used when computing the effective connection
+    // type.
+    DO_NOT_USE = 0,
+    // If the metric is available, then it should be used when computing the
+    // effective connection type.
+    USE_IF_AVAILABLE,
+    // The metric is required when computing the effective connection type.
+    // If the value of the metric is unavailable, effective connection type
+    // should be set to |EFFECTIVE_CONNECTION_TYPE_UNKNOWN|.
+    MUST_BE_USED,
+  };
+
   // Map from algorithm names to EffectiveConnectionTypeAlgorithm.
+  // TODO(tbansal): Consider using an autogenerated enum using macros.
   const std::map<std::string, EffectiveConnectionTypeAlgorithm>
       algorithm_name_to_enum_;
 
   // The default algorithm to be used if the algorithm value is not available
   // through field trial parameters.
   static const EffectiveConnectionTypeAlgorithm
       kDefaultEffectiveConnectionTypeAlgorithm =
           EffectiveConnectionTypeAlgorithm::HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT;
 
   // Minimum valid value of the variation parameter that holds RTT (in
@@ skipping 82 matching lines @@
   // Notify observers of a change in effective connection type.
   void NotifyObserversOfEffectiveConnectionTypeChanged();
 
   // Records NQE accuracy metrics. |measuring_duration| should belong to the
   // vector returned by AccuracyRecordingIntervals().
   // RecordAccuracyAfterMainFrame should be called |measuring_duration| after a
   // main frame request is observed.
   void RecordAccuracyAfterMainFrame(base::TimeDelta measuring_duration) const;
 
   // Returns the effective type of the current connection based on only the
-  // samples observed after |start_time|. Uses HTTP RTT and downstream
-  // throughput to compute the effective connection type, and requires both of
-  // them to have a valid value.
-  EffectiveConnectionType
-  GetRecentEffectiveConnectionTypeHttpRTTAndDownstreamThroughput(
-      const base::TimeTicks& start_time) const;
+  // samples observed after |start_time|. May use HTTP RTT, transport RTT and
+  // downstream throughput to compute the effective connection type based on
+  // |http_rtt_metric|, |transport_rtt_metric| and
+  // |downstream_throughput_kbps_metric|, respectively.
+  EffectiveConnectionType GetRecentEffectiveConnectionTypeUsingMetrics(
+      const base::TimeTicks& start_time,
+      MetricUsage http_rtt_metric,
+      MetricUsage transport_rtt_metric,
+      MetricUsage downstream_throughput_kbps_metric) const;
 
   // Values of external estimate provider status. This enum must remain
   // synchronized with the enum of the same name in
   // metrics/histograms/histograms.xml.
   enum NQEExternalEstimateProviderStatus {
     EXTERNAL_ESTIMATE_PROVIDER_STATUS_NOT_AVAILABLE,
     EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE,
     EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED,
     EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERY_SUCCESSFUL,
     EXTERNAL_ESTIMATE_PROVIDER_STATUS_CALLBACK,
@@ skipping 112 matching lines @@
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<NetworkQualityEstimator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkQualityEstimator);
 };
 
 }  // namespace net
 
 #endif  // NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_