Add Network Quality observer to NQE

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 66 matching lines @@
         EffectiveConnectionType type) = 0;
 
    protected:
     EffectiveConnectionTypeObserver() {}
     virtual ~EffectiveConnectionTypeObserver() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(EffectiveConnectionTypeObserver);
   };
 
+  // Observes changes in the network quality.
+  class NET_EXPORT RTTAndThroughputEstimatesObserver {
+   public:
+    // Notifies the observer when estimated HTTP RTT, estimated transport RTT or
+    // estimated downstream throughput is computed. NetworkQualityEstimator
+    // computes the RTT and throughput estimates at regular intervals.
+    // Additionally, when there is a change in the connection type of the
+    // device, then the estimates are immediately computed. The observer must
+    // register and unregister itself on the IO thread. All the observers would
+    // be notified on the IO thread.
+    //
+    // |http_rtt|, |transport_rtt| and |downstream_throughput_kbps| are the
+    // computed estimates of the HTTP RTT, transport RTT and downstream
+    // throughput (in kilobits per second), respectively. If an estimate of the
+    // HTTP or transport RTT is unavailable, it will be set to
+    // nqe::internal::InvalidRTT(). If the throughput estimate is unavailable,
+    // it will be set to nqe::internal::kInvalidThroughput.
+    virtual void OnRTTOrThroughputEstimatesComputed(
+        base::TimeDelta http_rtt,
+        base::TimeDelta transport_rtt,
+        int32_t downstream_throughput_kbps) = 0;
+
+   protected:
+    RTTAndThroughputEstimatesObserver() {}
+    virtual ~RTTAndThroughputEstimatesObserver() {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(RTTAndThroughputEstimatesObserver);
+  };
+
   // Observes measurements of round trip time.
   class NET_EXPORT_PRIVATE RTTObserver {
    public:
     // Will be called when a new RTT observation is available. The round trip
     // time is specified in milliseconds. The time when the observation was
     // taken and the source of the observation are provided.
     virtual void OnRTTObservation(int32_t rtt_ms,
                                   const base::TimeTicks& timestamp,
                                   NetworkQualityObservationSource source) = 0;
 
@@ skipping 81 matching lines @@
   // Adds |observer| to the list of effective connection type observers. Must be
   // called on the IO thread.
   void AddEffectiveConnectionTypeObserver(
       EffectiveConnectionTypeObserver* observer);
 
   // Removes |observer| from the list of effective connection type observers.
   // Must be called on the IO thread.
   void RemoveEffectiveConnectionTypeObserver(
       EffectiveConnectionTypeObserver* observer);
 
+  // Adds |observer| to the list of RTT and throughput estimate observers. Must
+  // be called on the IO thread.
+  void AddRTTAndThroughputEstimatesObserver(
+      RTTAndThroughputEstimatesObserver* observer);
+
+  // Removes |observer| from the list of RTT and throughput estimate observers.
+  // Must be called on the IO thread.
+  void RemoveRTTAndThroughputEstimatesObserver(
+      RTTAndThroughputEstimatesObserver* observer);
+
   // Notifies NetworkQualityEstimator that the response header of |request| has
   // been received.
   void NotifyHeadersReceived(const URLRequest& request);
 
   // Notifies NetworkQualityEstimator that the headers of |request| are about to
   // be sent.
   void NotifyStartTransaction(const URLRequest& request);
 
   // Notifies NetworkQualityEstimator that the response body of |request| has
   // been received.
@@ skipping 103 matching lines @@
   // 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);
 
   // Returns a random double in the range [0.0, 1.0). Virtualized for testing.
   virtual double RandDouble() const;
 
+  // Returns the effective type of the current connection based on only the
+  // observations received after |start_time|. |http_rtt|, |transport_rtt| and
+  // |downstream_throughput_kbps| must be non-null. |http_rtt|, |transport_rtt|
+  // and |downstream_throughput_kbps| are set to the expected HTTP RTT,
+  // transport RTT and downstream throughput (in kilobits per second) based on
+  // observations taken since |start_time|. Virtualized for testing.
+  virtual EffectiveConnectionType
+  GetRecentEffectiveConnectionTypeAndNetworkQuality(
+      const base::TimeTicks& start_time,
+      base::TimeDelta* http_rtt,
+      base::TimeDelta* transport_rtt,
+      int32_t* downstream_throughput_kbps) const;
+
  private:
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            AdaptiveRecomputationEffectiveConnectionType);
   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);
@@ skipping 122 matching lines @@
 
   void NotifyObserversOfThroughput(const ThroughputObservation& observation);
 
   // 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 MaybeComputeEffectiveConnectionType();
 
-  // Notify observers of a change in effective connection type.
+  // Notifies observers of a change in effective connection type.
   void NotifyObserversOfEffectiveConnectionTypeChanged();
 
+  // Notifies the observers of RTT or throughput estimates computation.
+  void NotifyObserversOfRTTOrThroughputComputed() const;
+
   // 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;
 
   // Obtains the current cellular signal strength value and updates
   // |min_signal_strength_since_connection_change_| and
   // |max_signal_strength_since_connection_change_|.
   void UpdateSignalStrength();
 
   // Returns the effective type of the current connection based on only the
   // 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.
+  // |downstream_throughput_kbps_metric|, respectively. |http_rtt|,
+  // |transport_rtt| and |downstream_throughput_kbps| must be non-null.
+  // |http_rtt|, |transport_rtt| and |downstream_throughput_kbps| are
+  // set to the expected HTTP RTT, transport RTT and downstream throughput (in
+  // kilobits per second) based on observations taken since |start_time|.
   EffectiveConnectionType GetRecentEffectiveConnectionTypeUsingMetrics(
       const base::TimeTicks& start_time,
       MetricUsage http_rtt_metric,
       MetricUsage transport_rtt_metric,
-      MetricUsage downstream_throughput_kbps_metric) const;
+      MetricUsage downstream_throughput_kbps_metric,
+      base::TimeDelta* http_rtt,
+      base::TimeDelta* transport_rtt,
+      int32_t* downstream_throughput_kbps) 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 100 matching lines @@
   nqe::internal::NetworkQuality external_estimate_provider_quality_;
 
   // 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 list for RTT or throughput estimates.
+  base::ObserverList<RTTAndThroughputEstimatesObserver>
+      rtt_and_throughput_estimates_observer_list_;
+
   // Observer lists for round trip times and throughput measurements.
   base::ObserverList<RTTObserver> rtt_observer_list_;
   base::ObserverList<ThroughputObserver> throughput_observer_list_;
 
   std::unique_ptr<SocketPerformanceWatcherFactory> watcher_factory_;
 
   // Takes throughput measurements, and passes them back to |this| through the
   // provided callback. |this| stores the throughput observations in
   // |downstream_throughput_kbps_observations_|, which are later used for
   // estimating the throughput.
   std::unique_ptr<nqe::internal::ThroughputAnalyzer> throughput_analyzer_;
 
   // 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_;
 
   // Number of RTT and bandwidth samples available when effective connection
   // type was last recomputed.
   size_t rtt_observations_size_at_last_ect_computation_;
   size_t throughput_observations_size_at_last_ect_computation_;
 
+  // Current estimates of the HTTP RTT, transport RTT and downstream throughput
+  // (in kilobits per second).
+  base::TimeDelta http_rtt_;
+  base::TimeDelta transport_rtt_;
+  int32_t downstream_throughput_kbps_;
+
   // Current effective connection type. It is updated on connection change
   // events. It is also updated every time there is network traffic (provided
   // the last computation was more than
   // |effective_connection_type_recomputation_interval_| ago).
   EffectiveConnectionType effective_connection_type_;
 
   // Minimum and Maximum signal strength (in dbM) observed since last connection
   // change. Updated on connection change and main frame requests.
   int32_t min_signal_strength_since_connection_change_;
   int32_t max_signal_strength_since_connection_change_;
@@ 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_