Added Network Quality Estimator Real-time interface to Cronet

net/base/network_quality_estimator.cc

Index: net/base/network_quality_estimator.cc
diff --git a/net/base/network_quality_estimator.cc b/net/base/network_quality_estimator.cc
index fdd2212adfb1b4c4853d6be76456ce0e990ef8a7..03cbb44abfda5db9d28471616c9caa377f54d355 100644
--- a/net/base/network_quality_estimator.cc
+++ b/net/base/network_quality_estimator.cc
@@ -140,7 +140,10 @@ NetworkQualityEstimator::NetworkQualityEstimator(
       downstream_throughput_kbps_observations_(
           GetWeightMultiplierPerSecond(variation_params)),
       rtt_msec_observations_(GetWeightMultiplierPerSecond(variation_params)),
-      external_estimates_provider_(external_estimates_provider.Pass()) {
+      external_estimates_provider_(external_estimates_provider.Pass()),
+      rtt_observer_list_(new base::ObserverListThreadSafe<RTTObserver>()),
+      throughput_observer_list_(
+          new base::ObserverListThreadSafe<ThroughputObserver>()) {
   static_assert(kMinRequestDurationMicroseconds > 0,
                 "Minimum request duration must be > 0");
   static_assert(kDefaultHalfLifeSeconds > 0,
@@ -205,22 +208,29 @@ void NetworkQualityEstimator::ObtainOperatingParams(
 void NetworkQualityEstimator::AddDefaultEstimates() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (default_observations_[current_network_id_.type].rtt() != InvalidRTT()) {
-    rtt_msec_observations_.AddObservation(Observation(
+    Observation rtt_observation(
         default_observations_[current_network_id_.type].rtt().InMilliseconds(),
-        base::TimeTicks::Now()));
+        base::TimeTicks::Now(), OBSERVATION_SOURCE_DEFAULT_FROM_PLATFORM);
+    rtt_msec_observations_.AddObservation(rtt_observation);
+    NotifyObserversOfRTT(rtt_observation);
   }
   if (default_observations_[current_network_id_.type]
           .downstream_throughput_kbps() != kInvalidThroughput) {
+    Observation throughput_observation(
+        default_observations_[current_network_id_.type]
+            .downstream_throughput_kbps(),
+        base::TimeTicks::Now(), OBSERVATION_SOURCE_DEFAULT_FROM_PLATFORM);
     downstream_throughput_kbps_observations_.AddObservation(
-        Observation(default_observations_[current_network_id_.type]
-                        .downstream_throughput_kbps(),
-                    base::TimeTicks::Now()));
+        throughput_observation);
+    NotifyObserversOfThroughput(throughput_observation);
   }
 }
 
 NetworkQualityEstimator::~NetworkQualityEstimator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
+  rtt_observer_list_->AssertEmpty();
+  throughput_observer_list_->AssertEmpty();
 }
 
 void NetworkQualityEstimator::NotifyHeadersReceived(const URLRequest& request) {
@@ -262,8 +272,10 @@ void NetworkQualityEstimator::NotifyHeadersReceived(const URLRequest& request) {
           observed_rtt, peak_network_quality_.downstream_throughput_kbps());
     }
 
-    rtt_msec_observations_.AddObservation(
-        Observation(observed_rtt.InMilliseconds(), now));
+    Observation rtt_observation(observed_rtt.InMilliseconds(), now,
+                                OBSERVATION_SOURCE_URL_REQUEST);
+    rtt_msec_observations_.AddObservation(rtt_observation);
+    NotifyObserversOfRTT(rtt_observation);
 
     // Compare the RTT observation with the estimated value and record it.
     if (estimated_median_network_quality_.rtt() != InvalidRTT()) {
@@ -330,8 +342,35 @@ void NetworkQualityEstimator::NotifyRequestCompleted(
     peak_network_quality_ =
         NetworkQuality(peak_network_quality_.rtt(), downstream_kbps_as_integer);
 
+  Observation throughput_observation(downstream_kbps_as_integer, now,
+                                     OBSERVATION_SOURCE_URL_REQUEST);
   downstream_throughput_kbps_observations_.AddObservation(
-      Observation(downstream_kbps_as_integer, now));
+      throughput_observation);
+  NotifyObserversOfThroughput(throughput_observation);
+}
+
+void NetworkQualityEstimator::AddRTTObserver(RTTObserver* rtt_observer) {
+  rtt_observer_list_->AddObserver(rtt_observer);
+}
+
+void NetworkQualityEstimator::RemoveRTTObserver(RTTObserver* rtt_observer) {
+  rtt_observer_list_->RemoveObserver(rtt_observer);
+}
+
+void NetworkQualityEstimator::AddThroughputObserver(
+    ThroughputObserver* throughput_observer) {
+  throughput_observer_list_->AddObserver(throughput_observer);
+}
+
+void NetworkQualityEstimator::RemoveThroughputObserver(
+    ThroughputObserver* throughput_observer) {
+  throughput_observer_list_->RemoveObserver(throughput_observer);
+}
+
+void NetworkQualityEstimator::Configure(bool allow_local_host_requests,
+                                        bool allow_smaller_responses) {
+  allow_localhost_requests_ = allow_local_host_requests,
+  allow_small_responses_ = allow_smaller_responses;
 }
 
 void NetworkQualityEstimator::RecordRTTUMA(int32_t estimated_value_msec,
@@ -549,8 +588,9 @@ bool NetworkQualityEstimator::GetRecentMedianDownlinkThroughputKbps(
 }
 
 NetworkQualityEstimator::Observation::Observation(int32_t value,
-                                                  base::TimeTicks timestamp)
-    : value(value), timestamp(timestamp) {
+                                                  base::TimeTicks timestamp,
+                                                  ObservationSource source)
+    : value(value), timestamp(timestamp), source(source) {
   DCHECK_GE(value, 0);
   DCHECK(!timestamp.is_null());
 }
@@ -765,10 +805,19 @@ bool NetworkQualityEstimator::ReadCachedNetworkQualityEstimate() {
   DCHECK_NE(InvalidRTT(), network_quality.rtt());
   DCHECK_NE(kInvalidThroughput, network_quality.downstream_throughput_kbps());
 
-  downstream_throughput_kbps_observations_.AddObservation(Observation(
-      network_quality.downstream_throughput_kbps(), base::TimeTicks::Now()));
-  rtt_msec_observations_.AddObservation(Observation(
-      network_quality.rtt().InMilliseconds(), base::TimeTicks::Now()));
+  Observation througphput_observation(
+      network_quality.downstream_throughput_kbps(), base::TimeTicks::Now(),
+      OBSERVATION_SOURCE_CACHED_ESTIMATE);
+  downstream_throughput_kbps_observations_.AddObservation(
+      througphput_observation);
+  NotifyObserversOfThroughput(througphput_observation);
+
+  Observation rtt_observation(network_quality.rtt().InMilliseconds(),
+                              base::TimeTicks::Now(),
+                              OBSERVATION_SOURCE_CACHED_ESTIMATE);
+  rtt_msec_observations_.AddObservation(rtt_observation);
+  NotifyObserversOfRTT(rtt_observation);
+
   return true;
 }
 
@@ -817,6 +866,20 @@ void NetworkQualityEstimator::CacheNetworkQualityEstimate() {
             static_cast<size_t>(kMaximumNetworkQualityCacheSize));
 }
 
+void NetworkQualityEstimator::NotifyObserversOfRTT(
+    const Observation& observation) {
+  rtt_observer_list_->Notify(FROM_HERE, &RTTObserver::OnRTTObservation,
+                             observation.value, observation.timestamp,
+                             observation.source);
+}
+
+void NetworkQualityEstimator::NotifyObserversOfThroughput(
+    const Observation& observation) {
+  throughput_observer_list_->Notify(
+      FROM_HERE, &ThroughputObserver::OnThroughputObservation,
+      observation.value, observation.timestamp, observation.source);
+}
+
 NetworkQualityEstimator::CachedNetworkQuality::CachedNetworkQuality(
     const NetworkQuality& network_quality)
     : last_update_time_(base::TimeTicks::Now()),