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.

[bengr, 2016/05/27 19:46:01]

What is the contract? The consumer will be notified of an effective connection
type change no more than once every k seconds? Will the consumer be notified
immediately? Will consumers be notified of ect on actual connection changes?
Please document.

[tbansal1, 2016/05/28 01:20:42]

Done.

+  class NET_EXPORT_PRIVATE EffectiveConnectionTypeObserver {
+   public:
+    // Will be called when the effective connection type changes.
+    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 GetURLRequestRTTEstimate(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 107 matching lines @@
   void OnConnectionTypeChanged(
       NetworkChangeNotifier::ConnectionType type) override;
 
   // ExternalEstimateProvider::UpdatedEstimateObserver implementation.
   void OnUpdatedEstimateAvailable() override;
 
   // Return a string equivalent to |type|.
   const char* GetNameForEffectiveConnectionType(
       EffectiveConnectionType type) const;
 
+  void SetTickClockForTesting(std::unique_ptr<base::TickClock> tick_clock);

[bengr, 2016/05/27 19:46:02]

Add a comment.

[tbansal1, 2016/05/28 01:20:42]

Done.

+
  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, TestGetMedianRTTSince);
@@ skipping 100 matching lines @@
 
   void NotifyObserversOfThroughput(const ThroughputObservation& observation);
 
   // Records the UMA related to the RTT at the URLRequest layer.
   void RecordURLRequestRTTUMA(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;
 
+  void MaybeRecomputeEffectiveConnectionType();

[bengr, 2016/05/27 19:46:02]

Add a comment.

[tbansal1, 2016/05/28 01:20:42]

Done.

+
+  void NotifyObserversOfEffectiveConnectionTypeChanged();

[bengr, 2016/05/27 19:46:02]

Add a comment.

[tbansal1, 2016/05/28 01:20:42]

Done.

+
   // 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_;
 
+  std::unique_ptr<base::TickClock> tick_clock_;

[bengr, 2016/05/27 19:46:01]

Add a comment.

[tbansal1, 2016/05/28 01:20:42]

Done, but this one seems pretty self-explanatory.

+
+  // Minimum duration between two consecutive computations of effective
+  // connection type.
+  const base::TimeDelta effective_connection_type_recomputation_interval_;

[bengr, 2016/05/27 19:46:02]

Is this for hysteresis or performance or both?

[tbansal1, 2016/05/28 01:20:42]

Performance. Hysteresis means we notify observers only if we are definitely sure
that connection type has changed.

+
   // 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_;
 
+  // Time when the effective connection type was last computed.
+  base::TimeTicks last_effective_connection_type_computation_;

[bengr, 2016/05/27 19:46:01]

Should this be listed together with line 460?

[tbansal1, 2016/05/28 01:20:42]

Done.

+
+  // 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_