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 235 matching lines @@
         variations_value >= kMinimumThroughputVariationParameterKbps) {
       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() != InvalidRTT()) {
-    rtt_msec_observations_.AddObservation(Observation(
+    Observation rtt_observation(
         default_observations_[current_network_id_.type].rtt().InMilliseconds(),
-        base::TimeTicks::Now()));
+        base::TimeTicks::Now(), 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(), 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);
 }
 
 void NetworkQualityEstimator::NotifyHeadersReceived(const URLRequest& request) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 27 matching lines @@
 
   // 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,
+                                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()) {
       RecordRTTUMA(estimated_median_network_quality_.rtt().InMilliseconds(),
                    observed_rtt.InMilliseconds());
     }
 }
 
 void NetworkQualityEstimator::NotifyRequestCompleted(
     const URLRequest& request) {
@@ skipping 46 matching lines @@
   // connection.
   if (downstream_kbps - downstream_kbps_as_integer > 0)
     downstream_kbps_as_integer++;
 
   DCHECK_GT(downstream_kbps_as_integer, 0.0);
   if (downstream_kbps_as_integer >
       peak_network_quality_.downstream_throughput_kbps())
     peak_network_quality_ =
         NetworkQuality(peak_network_quality_.rtt(), downstream_kbps_as_integer);
 
+  Observation throughput_observation(downstream_kbps_as_integer, now,
+                                     URL_REQUEST);
   downstream_throughput_kbps_observations_.AddObservation(
-      Observation(downstream_kbps_as_integer, now));
+      throughput_observation);
+  NotifyObserversOfThroughput(throughput_observation);
+}
+
+void NetworkQualityEstimator::AddRTTObserver(RTTObserver* rtt_observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  rtt_observer_list_.AddObserver(rtt_observer);
+}
+
+void NetworkQualityEstimator::RemoveRTTObserver(RTTObserver* rtt_observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  rtt_observer_list_.RemoveObserver(rtt_observer);
+}
+
+void NetworkQualityEstimator::AddThroughputObserver(
+    ThroughputObserver* throughput_observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  throughput_observer_list_.AddObserver(throughput_observer);
+}
+
+void NetworkQualityEstimator::RemoveThroughputObserver(
+    ThroughputObserver* throughput_observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  throughput_observer_list_.RemoveObserver(throughput_observer);
 }
 
 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.",
@@ skipping 205 matching lines @@
 bool NetworkQualityEstimator::GetRecentMedianDownlinkThroughputKbps(
     const base::TimeTicks& begin_timestamp,
     int32_t* kbps) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(kbps);
   *kbps = GetDownlinkThroughputKbpsEstimateInternal(begin_timestamp, 50);
   return (*kbps != kInvalidThroughput);
 }
 
 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 194 matching lines @@
       cached_network_qualities_.find(current_network_id_);
 
   if (it == cached_network_qualities_.end())
     return false;
 
   NetworkQuality network_quality(it->second.network_quality());
 
   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(),
+      CACHED_ESTIMATE);
+  downstream_throughput_kbps_observations_.AddObservation(
+      througphput_observation);
+  NotifyObserversOfThroughput(througphput_observation);

[pauljensen, 2015/10/06 19:10:29]

This is a little odd.  We didn't really observe a new measurement, we just read
the last estimate out of cache.  I guess it's fine.

+
+  Observation rtt_observation(network_quality.rtt().InMilliseconds(),
+                              base::TimeTicks::Now(), CACHED_ESTIMATE);
+  rtt_msec_observations_.AddObservation(rtt_observation);
+  NotifyObserversOfRTT(rtt_observation);
+
   return true;
 }
 
 void NetworkQualityEstimator::OnUpdatedEstimateAvailable() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(external_estimate_provider_);
 
   RecordExternalEstimateProviderMetrics(
       EXTERNAL_ESTIMATE_PROVIDER_STATUS_CALLBACK);
   QueryExternalEstimateProvider();
@@ skipping 20 matching lines @@
     // updates estimates are available, OnUpdatedEstimateAvailable() will be
     // called.
     external_estimate_provider_->Update();
     return;
   }
 
   RecordExternalEstimateProviderMetrics(
       EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERY_SUCCESSFUL);
   base::TimeDelta rtt;
   if (external_estimate_provider_->GetRTT(&rtt)) {
-    rtt_msec_observations_.AddObservation(
-        Observation(rtt.InMilliseconds(), base::TimeTicks::Now()));
+    rtt_msec_observations_.AddObservation(Observation(
+        rtt.InMilliseconds(), base::TimeTicks::Now(), EXTERNAL_ESTIMATE));
   }
 
   int32_t downstream_throughput_kbps;
   if (external_estimate_provider_->GetDownstreamThroughputKbps(
           &downstream_throughput_kbps)) {
-    downstream_throughput_kbps_observations_.AddObservation(
-        Observation(downstream_throughput_kbps, base::TimeTicks::Now()));
+    downstream_throughput_kbps_observations_.AddObservation(Observation(
+        downstream_throughput_kbps, base::TimeTicks::Now(), EXTERNAL_ESTIMATE));
   }
 }
 
 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 36 matching lines @@
       new SocketPerformanceWatcherTCP());
 }
 
 scoped_ptr<SocketPerformanceWatcher>
 NetworkQualityEstimator::CreateUDPSocketPerformanceWatcher() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return scoped_ptr<SocketPerformanceWatcher>(
       new SocketPerformanceWatcherUDP());
 }
 
+void NetworkQualityEstimator::NotifyObserversOfRTT(
+    const Observation& observation) {
+  FOR_EACH_OBSERVER(RTTObserver, rtt_observer_list_,
+                    OnRTTObservation(observation.value, observation.timestamp,
+                                     observation.source));
+}
+
+void NetworkQualityEstimator::NotifyObserversOfThroughput(
+    const Observation& observation) {
+  FOR_EACH_OBSERVER(
+      ThroughputObserver, throughput_observer_list_,
+      OnThroughputObservation(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_) {
@@ skipping 27 matching lines @@
 
 NetworkQualityEstimator::NetworkQuality&
     NetworkQualityEstimator::NetworkQuality::
     operator=(const NetworkQuality& other) {
   rtt_ = other.rtt_;
   downstream_throughput_kbps_ = other.downstream_throughput_kbps_;
   return *this;
 }
 
 }  // namespace net