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 aad1076b7f777fea257e471ac9d8f78d3714a782..db1a3801e3f2c95c6a4a283dc703b3ed4468e94f 100644
--- a/net/base/network_quality_estimator.cc
+++ b/net/base/network_quality_estimator.cc
@@ -191,16 +191,20 @@ void NetworkQualityEstimator::AddDefaultEstimates() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (default_observations_[current_network_id_.type].rtt() !=
       NetworkQuality::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() != NetworkQuality::kInvalidThroughput) {
-    kbps_observations_.AddObservation(
-        Observation(default_observations_[current_network_id_.type]
-                        .downstream_throughput_kbps(),
-                    base::TimeTicks::Now()));
+    Observation bandwidth_observation(
+        default_observations_[current_network_id_.type]
+            .downstream_throughput_kbps(),
+        base::TimeTicks::Now(), OBSERVATION_SOURCE_DEFAULT_FROM_PLATFORM);
+    kbps_observations_.AddObservation(bandwidth_observation);
+    NotifyObserversOfBandwidth(bandwidth_observation);
   }
 }
 
@@ -260,8 +264,10 @@ void NetworkQualityEstimator::NotifyDataReceived(
           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() !=
@@ -304,11 +310,38 @@ void NetworkQualityEstimator::NotifyDataReceived(
             NetworkQuality(peak_network_quality_.rtt(), kbps);
       }
 
-      kbps_observations_.AddObservation(Observation(kbps, now));
+      Observation bandwidth_observation(kbps, now,
+                                        OBSERVATION_SOURCE_URL_REQUEST);
+      kbps_observations_.AddObservation(bandwidth_observation);
+      NotifyObserversOfBandwidth(bandwidth_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::AddBandwidthObserver(
+    BandwidthObserver* bandwidth_observer) {
+  bandwidth_observer_list_.AddObserver(bandwidth_observer);
+}
+
+void NetworkQualityEstimator::RemoveBandwidthObserver(
+    BandwidthObserver* bandwidth_observer) {
+  bandwidth_observer_list_.RemoveObserver(bandwidth_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,
                                            int32_t actual_value_msec) const {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -486,8 +519,9 @@ bool NetworkQualityEstimator::GetEstimate(NetworkQuality* median) const {
 }
 
 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());
 }
@@ -667,10 +701,17 @@ bool NetworkQualityEstimator::ReadCachedNetworkQualityEstimate() {
   DCHECK_NE(NetworkQuality::kInvalidThroughput,
             network_quality.downstream_throughput_kbps());
 
-  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 bandwidth_observation(
+      network_quality.downstream_throughput_kbps(), base::TimeTicks::Now(),
+      OBSERVATION_SOURCE_CACHED_ESTIMATE);
+  Observation rtt_observation(network_quality.rtt().InMilliseconds(),
+                              base::TimeTicks::Now(),
+                              OBSERVATION_SOURCE_CACHED_ESTIMATE);
+  kbps_observations_.AddObservation(bandwidth_observation);

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

I think it will be a little cleaner if bandwidth_observation lines were separate
from rtt_observation lines.

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

Done.

+  rtt_msec_observations_.AddObservation(rtt_observation);
+  NotifyObserversOfBandwidth(bandwidth_observation);
+  NotifyObserversOfRTT(rtt_observation);
+
   return true;
 }
 
@@ -713,6 +754,21 @@ void NetworkQualityEstimator::CacheNetworkQualityEstimate() {
             static_cast<size_t>(kMaximumNetworkQualityCacheSize));
 }
 
+void NetworkQualityEstimator::NotifyObserversOfRTT(
+    const Observation& observation) {
+  FOR_EACH_OBSERVER(RTTObserver, rtt_observer_list_,
+                    OnRTTObservation(observation.value, observation.timestamp,
+                                     observation.source));
+}
+
+void NetworkQualityEstimator::NotifyObserversOfBandwidth(
+    const Observation& observation) {
+  FOR_EACH_OBSERVER(
+      BandwidthObserver, bandwidth_observer_list_,
+      OnBandwidthObservation(observation.value, observation.timestamp,
+                             observation.source));
+}
+
 NetworkQualityEstimator::CachedNetworkQuality::CachedNetworkQuality(
     const NetworkQuality& network_quality)
     : last_update_time_(base::TimeTicks::Now()),