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 NetworkQualityObserver {
+   public:
+    // Notifies the observer of a change in the network quality (estimated HTTP
+    // RTT, estimated transport RTT and estimated downstream throughput).
+    // NetworkQualityEstimator computes the network quality once in
+    // every interval of duration
+    // |effective_connection_type_recomputation_interval_|. Additionally, when
+    // there is a change in the connection type of the device, then the
+    // network quality is immediately recomputed. The observer must
+    // register and unregister itself on the IO thread. All the observers would
+    // be notified on the IO thread.

[RyanSturm, 2016/10/11 01:46:26]

nit: I feel like this comment could be reformatted (i.e. register in lline 97
might fit on the previous line). I didn't count characters or anything, so I
might be wrong.

[tbansal1, 2016/10/11 17:46:12]

Done.

+    //
+    // If the computed network quality is different from the previously notified

[RyanSturm, 2016/10/11 01:46:26]

nit: Can you say something like "If any of the three components of network
quality are different" ? I imagine in practice it is rare one changes and
another stays the same, but it sounds like network quality is a metric from
which rtt and kbps are derived as opposed to rtt and kbps being components of
network quality.

[tbansal1, 2016/10/11 17:46:12]

Done.

+    // network quality, then all the registered observers are notified of the
+    // new network quality. |http_rtt|, |transport_rtt| and
+    // |downstream_throughput_kbps| are the current 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 is
+    // unavailable, it will be set to nqe::internal::kInvalidThroughput.
+    virtual void OnNetworkQualityChanged(
+        base::TimeDelta http_rtt,
+        base::TimeDelta transport_rtt,
+        int32_t downstream_throughput_kbps) = 0;
+
+   protected:
+    NetworkQualityObserver() {}
+    virtual ~NetworkQualityObserver() {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(NetworkQualityObserver);
+  };
+
   // 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 network quality observers. Must be
+  // called on the IO thread.
+  void AddNetworkQualityObserver(NetworkQualityObserver* observer);
+
+  // Removes |observer| from the list of network quality observers.
+  // Must be called on the IO thread.
+  void RemoveNetworkQualityObserver(NetworkQualityObserver* 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|. May use HTTP RTT, transport RTT
+  // and downstream throughput to compute the effective connection type based on
+  // |http_rtt_metric|, |transport_rtt_metric| and

[RyanSturm, 2016/10/11 01:46:26]

Are the "|*_metric|" variables relevant to this method?

[tbansal1, 2016/10/11 17:46:12]

Done.

+  // |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|.
+  // 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 140 matching lines @@
 
   // 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 96 matching lines @@
   EffectiveConnectionType effective_connection_type_at_last_main_frame_;
 
   // Estimated network quality obtained from external estimate provider when the
   // external estimate provider was last queried.
   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.
+  // Observer list for changes in the effective connection type.

[RyanSturm, 2016/10/11 01:46:26]

nit: I don't think adding "the" here improves this comment. I prefer it the way
it was, but I don't think it makes a large difference.

[tbansal1, 2016/10/11 17:46:12]

Done.

   base::ObserverList<EffectiveConnectionTypeObserver>
       effective_connection_type_observer_list_;
 
+  // Observer list for changes in the network quality.
+  base::ObserverList<NetworkQualityObserver> network_quality_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_