Expose NQE::OnEffectiveConnectionTypeChanged API

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 14 matching lines @@
 #include "net/nqe/cached_network_quality.h"
 #include "net/nqe/external_estimate_provider.h"
 #include "net/nqe/network_quality.h"
 #include "net/nqe/network_quality_observation.h"
 #include "net/nqe/network_quality_observation_source.h"
 #include "net/nqe/observation_buffer.h"
 #include "net/socket/socket_performance_watcher_factory.h"
 
 namespace base {
 class SingleThreadTaskRunner;
+class TickClock;
 }  // namespace base
 
 namespace net {
 
 namespace nqe {
 namespace internal {
 class ThroughputAnalyzer;
 }
 }
 
@@ skipping 24 matching lines @@
     EFFECTIVE_CONNECTION_TYPE_UNKNOWN = 0,
     EFFECTIVE_CONNECTION_TYPE_OFFLINE,
     EFFECTIVE_CONNECTION_TYPE_SLOW_2G,
     EFFECTIVE_CONNECTION_TYPE_2G,
     EFFECTIVE_CONNECTION_TYPE_3G,
     EFFECTIVE_CONNECTION_TYPE_4G,
     EFFECTIVE_CONNECTION_TYPE_BROADBAND,
     EFFECTIVE_CONNECTION_TYPE_LAST,
   };
 
+  // Observes changes in effective connection type.
+  class NET_EXPORT_PRIVATE EffectiveConnectionTypeObserver {
+   public:
+    // Notifies the observer of a change in the effective connection type.
+    // NetworkQualityEstimator computes the effective connection type 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
+    // effective connection type is immediately recomputed. The observer must
+    // register and unregister itself on the IO thread. All the observers would
+    // be notified on the IO thread.
+    //
+    // If the computed effective connection type is different from the
+    // previously notified effective connection type, then all the registered
+    // observers are notified of the new effective connection type.
+    virtual void OnEffectiveConnectionTypeChanged(
+        EffectiveConnectionType type) = 0;
+
+   protected:
+    EffectiveConnectionTypeObserver() {}
+    virtual ~EffectiveConnectionTypeObserver() {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(EffectiveConnectionTypeObserver);
+  };
+
   // 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 48 matching lines @@
       const std::map<std::string, std::string>& variation_params,
       bool use_local_host_requests_for_tests,
       bool use_smaller_responses_for_tests);
 
   ~NetworkQualityEstimator() override;
 
   // Returns the effective type of the current connection. Virtualized for
   // testing.
   virtual EffectiveConnectionType GetEffectiveConnectionType() const;
 
+  // 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);
+
   // 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.
@@ skipping 109 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;
 
+  // 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);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            TestLRUCacheMaximumSize);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestGetMetricsSince);
@@ skipping 99 matching lines @@
 
   void NotifyObserversOfThroughput(const ThroughputObservation& observation);
 
   // Records the UMA related to the RTT at the HTTP layer.
   void RecordHttpRTTUMA(int32_t estimated_value_msec,
                         int32_t actual_value_msec) const;
 
   // 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();
+
   // 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 10 matching lines @@
   const bool use_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 use_small_responses_;
 
   // The factor by which the weight of an observation reduces every second.
   const double weight_multiplier_per_second_;
 
+  // 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_;
+
   // 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 24 matching lines @@
   nqe::internal::NetworkQuality
       connection_thresholds_[EFFECTIVE_CONNECTION_TYPE_LAST];
 
   // Estimated network quality. Updated on mainframe requests.
   nqe::internal::NetworkQuality estimated_median_network_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 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_;
 
+  // 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_;
+
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<NetworkQualityEstimator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkQualityEstimator);
 };
 
 }  // namespace net
 
 #endif  // NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_