Record NQE accuracy at main frame requests

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 171 matching lines @@
 
   // 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.
   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.
-  bool GetTransportRTTEstimate(base::TimeDelta* rtt) const WARN_UNUSED_RESULT;
+  // the transport layer. |rtt| should not be null. Virtualized for testing.
+  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.
   virtual bool GetDownlinkThroughputKbpsEstimate(int32_t* kbps) const;
 
   // Notifies NetworkQualityEstimator that the response header of |request| has
   // been received.
   void NotifyHeadersReceived(const URLRequest& request);
 
@@ skipping 13 matching lines @@
   // 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.
   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.
-  bool GetRecentTransportRTTMedian(const base::TimeTicks& start_time,
-                                   base::TimeDelta* rtt) const
+  // |start_time|. |rtt| should not be null. Virtualized for testing.
+  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.
+  // should not be null. Virtualized for testing.
   virtual bool GetRecentMedianDownlinkThroughputKbps(
       const base::TimeTicks& start_time,
       int32_t* kbps) const WARN_UNUSED_RESULT;
 
   // Adds |rtt_observer| to the list of round trip time observers. Must be
   // called on the IO thread.
   void AddRTTObserver(RTTObserver* rtt_observer);
 
   // Removes |rtt_observer| from the list of round trip time observers if it
   // is on the list of observers. Must be called on the IO thread.
@@ skipping 56 matching lines @@
 
   // ExternalEstimateProvider::UpdatedEstimateObserver implementation.
   void OnUpdatedEstimateAvailable(const base::TimeDelta& rtt,
                                   int32_t downstream_throughput_kbps,
                                   int32_t upstream_throughput_kbps) override;
 
   // Return a string equivalent to |type|.
   const char* GetNameForEffectiveConnectionType(
       EffectiveConnectionType type) const;
 
+  // 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.
   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, HalfLifeParam);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, ComputedPercentiles);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestCaching);
@@ skipping 106 matching lines @@
   // Returns true only if the |request| can be used for RTT estimation.
   bool RequestProvidesRTTObservation(const URLRequest& request) const;
 
   // Recomputes effective connection type, if it was computed more than the
   // specified duration ago, or if there has been a connection change recently.
   void MaybeRecomputeEffectiveConnectionType();
 
   // 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;
+
   // 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 20 matching lines @@
   // 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_;
 
+  // Intervals after the main frame request arrives at which accuracy of network
+  // quality prediction is recorded.
+  std::vector<base::TimeDelta> accuracy_recording_intervals_;
+
   // Time when last connection change was observed.
   base::TimeTicks last_connection_change_;
 
   // ID of the current network.
   NetworkID current_network_id_;
 
   // Peak network quality (fastest round-trip-time (RTT) and highest
   // downstream throughput) measured since last connectivity change. RTT is
   // measured from time the request is sent until the first byte received.
   // The accuracy is decreased by ignoring these factors:
@@ skipping 17 matching lines @@
   nqe::internal::NetworkQuality
       default_observations_[NetworkChangeNotifier::CONNECTION_LAST + 1];
 
   // Thresholds for different effective connection types obtained from field
   // trial variation params. These thresholds encode how different connection
   // types behave in general. In future, complex encodings (e.g., curve
   // fitting) may be used.
   nqe::internal::NetworkQuality
       connection_thresholds_[EFFECTIVE_CONNECTION_TYPE_LAST];
 
-  // Estimated network quality. Updated on mainframe requests.
-  nqe::internal::NetworkQuality estimated_median_network_quality_;
+  // Latest time when the headers for a main frame request were received.
+  base::TimeTicks last_main_frame_request_;
+
+  // Estimated network quality when the response headers for the last mainframe
+  // request were received.
+  nqe::internal::NetworkQuality estimated_quality_at_last_main_frame_;
 
   // ExternalEstimateProvider that provides network quality using operating
   // system APIs. May be NULL.
   const std::unique_ptr<ExternalEstimateProvider> external_estimate_provider_;
 
   // Observer list for changes in effective connection type.
   base::ObserverList<EffectiveConnectionTypeObserver>
       effective_connection_type_observer_list_;
 
   // Observer lists for round trip times and throughput measurements.
@@ skipping 17 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_