Added Network Quality Estimator Real-time interface to Cronet

net/base/network_quality_estimator.cc

 // 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.
 
 #include "net/base/network_quality_estimator.h"
 
 #include <float.h>
 #include <algorithm>
 #include <cmath>
 #include <limits>
@@ skipping 173 matching lines @@
       default_observations_[i] =
           NetworkQuality(default_observations_[i].rtt(), variations_value);
     }
   }
 }
 
 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);
   }
 }
 
 NetworkQualityEstimator::~NetworkQualityEstimator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
 void NetworkQualityEstimator::NotifyDataReceived(
     const URLRequest& request,
@@ skipping 39 matching lines @@
   if (cumulative_prefilter_bytes_read == prefiltered_bytes_read) {
     // Duration between when the resource was requested and when response
     // headers were received.
     base::TimeDelta observed_rtt = headers_received_time - request_start_time;
     DCHECK_GE(observed_rtt, base::TimeDelta());
     if (observed_rtt < peak_network_quality_.rtt()) {
       peak_network_quality_ = NetworkQuality(
           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() !=
         NetworkQuality::InvalidRTT()) {
       RecordRTTUMA(estimated_median_network_quality_.rtt().InMilliseconds(),
                    observed_rtt.InMilliseconds());
     }
   }
 
   // Time since the resource was requested.
@@ skipping 22 matching lines @@
     // when there is no connection.
     if (kbps_f > 0.0 && kbps == 0)
       kbps = 1;
 
     if (kbps > 0) {
       if (kbps > peak_network_quality_.downstream_throughput_kbps()) {
         peak_network_quality_ =
             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());
 
   // Record the difference between the actual and the estimated value.
   if (estimated_value_msec >= actual_value_msec) {
     base::HistogramBase* difference_rtt =
         GetHistogram("DifferenceRTTEstimatedAndActual.",
                      current_network_id_.type, 10 * 1000);  // 10 seconds
     difference_rtt->Add(estimated_value_msec - actual_value_msec);
@@ skipping 157 matching lines @@
 bool NetworkQualityEstimator::GetEstimate(NetworkQuality* median) const {
   if (kbps_observations_.Size() == 0 || rtt_msec_observations_.Size() == 0) {
     *median = NetworkQuality();
     return false;
   }
   *median = GetEstimate(50);
   return true;
 }
 
 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());
 }
 
 NetworkQualityEstimator::Observation::~Observation() {
 }
 
 NetworkQualityEstimator::ObservationBuffer::ObservationBuffer(
     double weight_multiplier_per_second)
     : weight_multiplier_per_second_(weight_multiplier_per_second) {
@@ skipping 159 matching lines @@
 
   if (it == cached_network_qualities_.end())
     return false;
 
   NetworkQuality network_quality(it->second.network_quality());
 
   DCHECK_NE(NetworkQuality::InvalidRTT(), network_quality.rtt());
   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;
 }
 
 void NetworkQualityEstimator::CacheNetworkQualityEstimate() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_LE(cached_network_qualities_.size(),
             static_cast<size_t>(kMaximumNetworkQualityCacheSize));
 
   // If the network name is unavailable, caching should not be performed.
   if (current_network_id_.id.empty())
@@ skipping 22 matching lines @@
   }
   DCHECK_LT(cached_network_qualities_.size(),
             static_cast<size_t>(kMaximumNetworkQualityCacheSize));
 
   cached_network_qualities_.insert(std::make_pair(
       current_network_id_, CachedNetworkQuality(network_quality)));
   DCHECK_LE(cached_network_qualities_.size(),
             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()),
       network_quality_(network_quality) {
 }
 
 NetworkQualityEstimator::CachedNetworkQuality::CachedNetworkQuality(
     const CachedNetworkQuality& other)
     : last_update_time_(other.last_update_time_),
       network_quality_(other.network_quality_) {
 }
 
 NetworkQualityEstimator::CachedNetworkQuality::~CachedNetworkQuality() {
 }
 
 bool NetworkQualityEstimator::CachedNetworkQuality::OlderThan(
     const CachedNetworkQuality& cached_network_quality) const {
   return last_update_time_ < cached_network_quality.last_update_time_;
 }
 
 }  // namespace net