NQE: Allow algorithm to be set using variation params

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 304 matching lines @@
   virtual const std::vector<base::TimeDelta>& GetAccuracyRecordingIntervals()
       const;
 
   // Overrides the tick clock used by |this| for testing.
   void SetTickClockForTesting(std::unique_ptr<base::TickClock> tick_clock);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, StoreObservations);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestAddObservation);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, ObtainOperatingParams);
+  FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
+                           ObtainAlgorithmToUseFromParams);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, HalfLifeParam);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, ComputedPercentiles);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestCaching);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            TestLRUCacheMaximumSize);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestGetMetricsSince);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            TestExternalEstimateProviderMergeEstimates);
 
   // Value of round trip time observations is in base::TimeDelta.
   typedef nqe::internal::Observation<base::TimeDelta> RttObservation;
   typedef nqe::internal::ObservationBuffer<base::TimeDelta>
       RttObservationBuffer;
 
   // Value of throughput observations is in kilobits per second.
   typedef nqe::internal::Observation<int32_t> ThroughputObservation;
   typedef nqe::internal::ObservationBuffer<int32_t> ThroughputObservationBuffer;
 
   // 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,
+    EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST
+  };
+
+  // Map from algorithm names to EffectiveConnectionTypeAlgorithm.
+  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
   // milliseconds) values.
   static const int kMinimumRTTVariationParameterMsec = 1;
 
   // Minimum valid value of the variation parameter that holds throughput (in
   // kilobits per second) values.
   static const int kMinimumThroughputVariationParameterKbps = 1;
 
   // Maximum size of the cache that holds network quality estimates.
   // Smaller size may reduce the cache hit rate due to frequent evictions.
@@ skipping 77 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;
+
   // 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,
     EXTERNAL_ESTIMATE_PROVIDER_STATUS_RTT_AVAILABLE,
@@ skipping 10 matching lines @@
   const bool use_localhost_requests_;
 
   // Determines if the responses smaller than |kMinTransferSizeInBytes|
   // or shorter than |kMinTransferSizeInBytes| can be used in estimating the
   // network quality. Set to true only for tests.
   const bool use_small_responses_;
 
   // The factor by which the weight of an observation reduces every second.
   const double weight_multiplier_per_second_;
 
+  // Algorithm to use for computing effective connection type. The value is
+  // obtained from field trial parameters. If the value from field trial
+  // parameters is unavailable, it is set to
+  // kDefaultEffectiveConnectionTypeAlgorithm.
+  const EffectiveConnectionTypeAlgorithm effective_connection_type_algorithm_;
+
   // Tick clock used by the network quality estimator.
   std::unique_ptr<base::TickClock> tick_clock_;
 
   // Minimum duration between two consecutive computations of effective
   // connection type. Set to non-zero value as a performance optimization.
   const base::TimeDelta effective_connection_type_recomputation_interval_;
 
   // Time when the effective connection type was last computed.
   base::TimeTicks last_effective_connection_type_computation_;
 
@@ skipping 74 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_