Added Network Quality Estimator Real-time interface to Cronet

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>
 #include <map>
 #include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/network_quality.h"
 
 namespace net {
 
 // NetworkQualityEstimator provides network quality estimates (quality of the
 // full paths to all origins that have been connected to).
 // The estimates are based on the observed organic traffic.
 // A NetworkQualityEstimator instance is attached to URLRequestContexts and
 // observes the traffic of URLRequests spawned from the URLRequestContexts.
 // A single instance of NQE can be attached to multiple URLRequestContexts,
 // thereby increasing the single NQE instance's accuracy by providing more
 // observed traffic characteristics.
 class NET_EXPORT_PRIVATE NetworkQualityEstimator
     : public NetworkChangeNotifier::ConnectionTypeObserver {
  public:
+  enum ObservationType { DOWNLINK_BANDWIDTH, RTT };
+
+  // On Android, a Java counterpart will be generated for this enum.
+  // GENERATED_JAVA_ENUM_PACKAGE: org.chromium.net
+  // GENERATED_JAVA_CLASS_NAME_OVERRIDE: NetworkQualityObservationSource
+  // GENERATED_JAVA_PREFIX_TO_STRIP: OBSERVATION_SOURCE_
+  enum ObservationSource {
+    OBSERVATION_SOURCE_URL_REQUEST,
+    OBSERVATION_SOURCE_TCP,
+    OBSERVATION_SOURCE_QUIC,
+    OBSERVATION_SOURCE_CACHED_ESTIMATE,
+    OBSERVATION_SOURCE_DEFAULT_FROM_PLATFORM,
+    OBSERVATION_SOURCE_EXTERNAL_ESTIMATE
+  };
+
+  class NET_EXPORT RTTObserver {

[mef, 2015/08/11 17:16:27]

Why is this class NET_EXPORT but parent is NET_EXPORT_PRIVATE?

[bengr, 2015/08/25 23:43:34]

Done.

+   public:
+    // Will be called when a new RTT observation is available.
+    virtual void OnRTTObservation(int32_t value,

[mef, 2015/08/11 17:16:27]

Need to specify units of |value|. Also below.

[bengr, 2015/08/25 23:43:34]

Done.

+                                  const base::TimeTicks& timestamp,
+                                  ObservationSource source) = 0;
+
+   protected:
+    RTTObserver() {}
+    virtual ~RTTObserver() {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(RTTObserver);
+  };
+
+  class NET_EXPORT BandwidthObserver {

[mef, 2015/08/11 17:16:27]

add class comment?

[bengr, 2015/08/25 23:43:34]

Done.

+   public:
+    // Will be called when a new Bandwidth observation is available.
+    virtual void OnBandwidthObservation(int32_t value,
+                                        const base::TimeTicks& timestamp,
+                                        ObservationSource source) = 0;
+
+   protected:
+    BandwidthObserver() {}
+    virtual ~BandwidthObserver() {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(BandwidthObserver);
+  };
+
   // Creates a new NetworkQualityEstimator.
   // |variation_params| is the map containing all field trial parameters
   // related to NetworkQualityEstimator field trial.
   explicit NetworkQualityEstimator(
       const std::map<std::string, std::string>& variation_params);
 
   ~NetworkQualityEstimator() override;
 
   // Returns the peak estimates (fastest RTT and peak throughput) of the
   // current network.
@@ skipping 12 matching lines @@
   // Notifies NetworkQualityEstimator that a response has been received.
   // |cumulative_prefilter_bytes_read| is the count of the bytes received prior
   // to applying filters (e.g. decompression, SDCH) from request creation time
   // until now.
   // |prefiltered_bytes_read| is the count of the bytes received prior
   // to applying filters in the most recent read.
   void NotifyDataReceived(const URLRequest& request,
                           int64_t cumulative_prefilter_bytes_read,
                           int64_t prefiltered_bytes_read);
 
+  void AddRTTObserver(RTTObserver* rtt_observer);
+  void RemoveRTTObserver(RTTObserver* rtt_observer);
+  void AddBandwidthObserver(BandwidthObserver* bandwidth_observer);
+  void RemoveBandwidthObserver(BandwidthObserver* bandwidth_observer);
+
+  void Configure(bool allow_local_host_requests, bool allow_smaller_responses);
+
  protected:
   // NetworkID is used to uniquely identify a network.
   // For the purpose of network quality estimation and caching, a network is
   // uniquely identified by a combination of |type| and
   // |id|. This approach is unable to distinguish networks with
   // same name (e.g., different Wi-Fi networks with same SSID).
   // This is a protected member to expose it to tests.
   struct NET_EXPORT_PRIVATE NetworkID {
     NetworkID(NetworkChangeNotifier::ConnectionType type, const std::string& id)
         : type(type), id(id) {}
@@ skipping 85 matching lines @@
     // Quality of this cached network.
     const NetworkQuality network_quality_;
 
    private:
     DISALLOW_ASSIGN(CachedNetworkQuality);
   };
 
   // Records the round trip time or throughput observation, along with the time
   // the observation was made.
   struct NET_EXPORT_PRIVATE Observation {
-    Observation(int32_t value, base::TimeTicks timestamp);
+    Observation(int32_t value,
+                base::TimeTicks timestamp,
+                ObservationSource source);
     ~Observation();
 
     // Value of the observation.
     const int32_t value;
 
     // Time when the observation was taken.
     const base::TimeTicks timestamp;
+
+    // The source of the observation.
+    ObservationSource source;
   };
 
   // Holds an observation and its weight.
   struct NET_EXPORT_PRIVATE WeightedObservation {
     WeightedObservation(int32_t value, double weight)
         : value(value), weight(weight) {}
     WeightedObservation(const WeightedObservation& other)
         : WeightedObservation(other.value, other.weight) {}
 
     WeightedObservation& operator=(const WeightedObservation& other) {
@@ skipping 107 matching lines @@
   // be slower than the returned estimate with 0.1 probability.
   NetworkQuality GetEstimate(int percentile) const;
 
   // Returns the current network ID checking by calling the platform APIs.
   // Virtualized for testing.
   virtual NetworkID GetCurrentNetworkID() const;
 
   // Writes the estimated quality of the current network to the cache.
   void CacheNetworkQualityEstimate();
 
+  void NotifyObserversOfRTT(const Observation& observation);
+
+  void NotifyObserversOfBandwidth(const Observation& observation);
+
   // Records the UMA related to RTT.
   void RecordRTTUMA(int32_t estimated_value_msec,
                     int32_t actual_value_msec) 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_;
+  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_;
+  bool allow_small_responses_;
 
   // 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.
@@ skipping 13 matching lines @@
 
   // Default network quality observations obtained from the network quality
   // 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_;
 
+  base::ObserverList<RTTObserver> rtt_observer_list_;
+  base::ObserverList<BandwidthObserver> bandwidth_observer_list_;
+
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkQualityEstimator);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NETWORK_QUALITY_ESTIMATOR_H_