Populate EEP estimate in NQE

net/base/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_BASE_NETWORK_QUALITY_ESTIMATOR_H_
 #define NET_BASE_NETWORK_QUALITY_ESTIMATOR_H_
 
 #include <stdint.h>
 
 #include <deque>
@@ skipping 33 matching lines @@
   // related to NetworkQualityEstimator field trial.
   // |external_estimates_provider| may be NULL.
   NetworkQualityEstimator(
       scoped_ptr<ExternalEstimateProvider> external_estimates_provider,
       const std::map<std::string, std::string>& variation_params);
 
   ~NetworkQualityEstimator() override;
 
   // Returns true if RTT is available and sets |rtt| to estimated RTT.
   // Virtualized for testing. |rtt| should not be null.
-  virtual bool GetRTTEstimate(base::TimeDelta* rtt) const;
+  virtual bool GetRTTEstimate(base::TimeDelta* rtt);
 
   // 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.
-  virtual bool GetDownlinkThroughputKbpsEstimate(int32_t* kbps) const;
+  virtual bool GetDownlinkThroughputKbpsEstimate(int32_t* kbps);
 
   // Notifies NetworkQualityEstimator that the response header of |request| has
   // been received.
   void NotifyHeadersReceived(const URLRequest& request);
 
   // Notifies NetworkQualityEstimator that the response body of |request| has
   // been received.
   void NotifyRequestCompleted(const URLRequest& request);
 
   // Returns true if median RTT is available and sets |rtt| to the median of
   // RTT observations since |begin_timestamp|.
   // Virtualized for testing. |rtt| should not be null.
   virtual bool GetRecentMedianRTT(const base::TimeTicks& begin_timestamp,
-                                  base::TimeDelta* rtt) const;
+                                  base::TimeDelta* rtt);
 
   // Returns true if median downstream throughput is available and sets |kbps|
   // to the median of downstream Kbps observations since |begin_timestamp|.
   // Virtualized for testing. |kbps| should not be null.
   virtual bool GetRecentMedianDownlinkThroughputKbps(
       const base::TimeTicks& begin_timestamp,
-      int32_t* kbps) const;
+      int32_t* kbps);
 
   // SocketPerformanceWatcherFactory implementation:
   scoped_ptr<SocketPerformanceWatcher> CreateTCPSocketPerformanceWatcher()
       const override;
   scoped_ptr<SocketPerformanceWatcher> CreateUDPSocketPerformanceWatcher()
       const override;
 
  protected:
   // NetworkID is used to uniquely identify a network.
   // For the purpose of network quality estimation and caching, a network is
@@ skipping 51 matching lines @@
       bool allow_local_host_requests_for_tests,
       bool allow_smaller_responses_for_tests);
 
   // Returns true if the cached network quality estimate was successfully read.
   bool ReadCachedNetworkQualityEstimate();
 
   // NetworkChangeNotifier::ConnectionTypeObserver implementation:
   void OnConnectionTypeChanged(
       NetworkChangeNotifier::ConnectionType type) override;
 
+  // ExternalEstimateProvider::UpdatedEstimateObserver implementation.
+  void OnUpdatedEstimateAvailable() override;
+
  private:
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, StoreObservations);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestKbpsRTTUpdates);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestAddObservation);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, ObtainOperatingParams);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, HalfLifeParam);
   FRIEND_TEST_ALL_PREFIXES(URLRequestTestHTTP, NetworkQualityEstimator);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            PercentileSameTimestamps);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            PercentileDifferentTimestamps);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, ComputedPercentiles);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestCaching);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            TestLRUCacheMaximumSize);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestGetMedianRTTSince);
+  FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
+                           TestExternalEstimateProvider);
 
   // NetworkQuality is used to cache the quality of a network connection.
   class NET_EXPORT_PRIVATE NetworkQuality {
    public:
     NetworkQuality();
     // |rtt| is the estimate of the round trip time.
     // |downstream_throughput_kbps| is the estimate of the downstream
     // throughput.
     NetworkQuality(const base::TimeDelta& rtt,
                    int32_t downstream_throughput_kbps);
@@ skipping 167 matching lines @@
   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.
   // Larger size may affect performance.
   static const size_t kMaximumNetworkQualityCacheSize = 10;
 
   // Maximum number of observations that can be held in the ObservationBuffer.
   static const size_t kMaximumObservationsBufferSize = 300;
 
+  // Minimum time duration (in milliseconds) between consecutive queries to
+  // external estimate provider.
+  static const int kExternalEstimateProviderQueryIntervalMsec = 5 * 60 * 1000;
+
+  // Time duration (in milliseconds) after which the estimate provided by
+  // external estimate provider is considered stale.
+  static const int kExternalEstimateProviderFreshnessDurationMsec =
+      5 * 60 * 1000;
+
   // Returns the RTT value to be used when the valid RTT is unavailable. Readers
   // should discard RTT if it is set to the value returned by |InvalidRTT()|.
   static const base::TimeDelta InvalidRTT();
 
-  // ExternalEstimateProvider::UpdatedEstimateObserver implementation:
-  void OnUpdatedEstimateAvailable() override;
+  // May call |QueryExternalEstimateProvider| if the most recent call to
+  // external estimate provider was more than
+  // |kExternalEstimateProviderQueryIntervalMsec| back.
+  void MaybeQueryExternalEstimateProvider();
+
+  // Queries the external estimate provider for the latest network quality
+  // estimates, and adds those estimates to the current observation buffer.
+  void QueryExternalEstimateProvider();
 
   // Obtains operating parameters from the field trial parameters.
   void ObtainOperatingParams(
       const std::map<std::string, std::string>& variation_params);
 
   // Adds the default median RTT and downstream throughput estimate for the
   // current connection type to the observation buffer.
   void AddDefaultEstimates();
 
   // Returns an estimate of network quality at the specified |percentile|.
@@ skipping 18 matching lines @@
 
   // Records the UMA related to RTT.
   void RecordRTTUMA(int32_t estimated_value_msec,
                     int32_t actual_value_msec) const;
 
   // Returns true only if |request| can be used for network quality estimation.
   // Only the requests that go over network are considered to provide useful
   // observations.
   bool RequestProvidesUsefulObservations(const URLRequest& request) 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_BOUNDARY
+  };
+
+  // Records the metrics related to external estimate provider.
+  void RecordExternalEstimateProviderMetrics(
+      NQEExternalEstimateProviderStatus status) const;
+
   // Determines if the requests to local host can be used in estimating the
   // network quality. Set to true only for tests.
   const bool allow_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 allow_small_responses_;
 
   // Time when last connection change was observed.
@@ skipping 23 matching lines @@
   // estimator field trial parameters. The observations are indexed by
   // ConnectionType.
   NetworkQuality
       default_observations_[NetworkChangeNotifier::CONNECTION_LAST + 1];
 
   // Estimated network quality. Updated on mainframe requests.
   NetworkQuality estimated_median_network_quality_;
 
   // ExternalEstimateProvider that provides network quality using operating
   // system APIs. May be NULL.
-  const scoped_ptr<ExternalEstimateProvider> external_estimates_provider_;
+  const scoped_ptr<ExternalEstimateProvider> external_estimate_provider_;
+
+  // Time when the external estimate provider was last queried.
+  base::TimeTicks external_estimate_request_time_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkQualityEstimator);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NETWORK_QUALITY_ESTIMATOR_H_