Add Network Quality observer to NQE

net/nqe/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/nqe/network_quality_estimator.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
@@ skipping 371 matching lines @@
           std::string())),
       downstream_throughput_kbps_observations_(weight_multiplier_per_second_),
       rtt_observations_(weight_multiplier_per_second_),
       effective_connection_type_at_last_main_frame_(
           EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       external_estimate_provider_(std::move(external_estimates_provider)),
       effective_connection_type_recomputation_interval_(
           base::TimeDelta::FromSeconds(10)),
       rtt_observations_size_at_last_ect_computation_(0),
       throughput_observations_size_at_last_ect_computation_(0),
+      http_rtt_(nqe::internal::InvalidRTT()),
+      transport_rtt_(nqe::internal::InvalidRTT()),
+      downstream_throughput_kbps_(nqe::internal::kInvalidThroughput),
       effective_connection_type_(EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       min_signal_strength_since_connection_change_(INT32_MAX),
       max_signal_strength_since_connection_change_(INT32_MIN),
       correlation_uma_logging_probability_(
           GetDoubleValueForVariationParamWithDefaultValue(
               variation_params,
               "correlation_logging_probability",
               0.0)),
       forced_effective_connection_type_set_(
           !GetStringValueForVariationParamWithDefaultValue(
@@ skipping 570 matching lines @@
 void NetworkQualityEstimator::SetUseSmallResponsesForTesting(
     bool use_small_responses) {
   DCHECK(thread_checker_.CalledOnValidThread());
   use_small_responses_ = use_small_responses;
   throughput_analyzer_->SetUseSmallResponsesForTesting(use_small_responses_);
 }
 
 void NetworkQualityEstimator::ReportEffectiveConnectionTypeForTesting(
     EffectiveConnectionType effective_connection_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  FOR_EACH_OBSERVER(
-      EffectiveConnectionTypeObserver, effective_connection_type_observer_list_,
-      OnEffectiveConnectionTypeChanged(effective_connection_type));
+  for (auto& observer : effective_connection_type_observer_list_)
+    observer.OnEffectiveConnectionTypeChanged(effective_connection_type);
 }
 
 bool NetworkQualityEstimator::RequestProvidesRTTObservation(
     const URLRequest& request) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return (use_localhost_requests_ || !IsLocalhost(request.url().host())) &&
          // Verify that response headers are received, so it can be ensured that
          // response is not cached.
          !request.response_info().response_time.is_null() &&
@@ skipping 30 matching lines @@
   if (NetworkChangeNotifier::IsConnectionCellular(current_network_id_.type)) {
     UMA_HISTOGRAM_BOOLEAN(
         "NQE.CellularSignalStrengthAvailable",
         min_signal_strength_since_connection_change_ != INT32_MAX &&
             max_signal_strength_since_connection_change_ != INT32_MIN);
   }
 #endif  // OS_ANDROID
   min_signal_strength_since_connection_change_ = INT32_MAX;
   max_signal_strength_since_connection_change_ = INT32_MIN;
   estimated_quality_at_last_main_frame_ = nqe::internal::NetworkQuality();
+  http_rtt_ = nqe::internal::InvalidRTT();
+  transport_rtt_ = nqe::internal::InvalidRTT();
+  downstream_throughput_kbps_ = nqe::internal::kInvalidThroughput;
   effective_connection_type_ = EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
   effective_connection_type_at_last_main_frame_ =
       EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
 
   // Update the local state as part of preparation for the new connection.
   current_network_id_ = GetCurrentNetworkID();
   RecordNetworkIDAvailability();
 
   MaybeQueryExternalEstimateProvider();
 
@@ skipping 160 matching lines @@
 
 void NetworkQualityEstimator::ComputeEffectiveConnectionType() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const base::TimeTicks now = tick_clock_->NowTicks();
 
   const EffectiveConnectionType past_type = effective_connection_type_;
   last_effective_connection_type_computation_ = now;
 
   effective_connection_type_ =
-      GetRecentEffectiveConnectionType(base::TimeTicks());
+      GetRecentEffectiveConnectionTypeAndNetworkQuality(
+          base::TimeTicks(), &http_rtt_, &transport_rtt_,
+          &downstream_throughput_kbps_);
+  NotifyObserversOfRTTOrThroughputComputed();
 
   if (past_type != effective_connection_type_)
     NotifyObserversOfEffectiveConnectionTypeChanged();
 
   rtt_observations_size_at_last_ect_computation_ = rtt_observations_.Size();
   throughput_observations_size_at_last_ect_computation_ =
       downstream_throughput_kbps_observations_.Size();
 }
 
 EffectiveConnectionType NetworkQualityEstimator::GetEffectiveConnectionType()
     const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return effective_connection_type_;
 }
 
 EffectiveConnectionType
 NetworkQualityEstimator::GetRecentEffectiveConnectionType(
     const base::TimeTicks& start_time) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  base::TimeDelta http_rtt;
+  base::TimeDelta transport_rtt;
+  int32_t downstream_throughput_kbps;
+
+  return GetRecentEffectiveConnectionTypeAndNetworkQuality(
+      start_time, &http_rtt, &transport_rtt, &downstream_throughput_kbps);
+}
+
+EffectiveConnectionType
+NetworkQualityEstimator::GetRecentEffectiveConnectionTypeAndNetworkQuality(
+    const base::TimeTicks& start_time,
+    base::TimeDelta* http_rtt,
+    base::TimeDelta* transport_rtt,
+    int32_t* downstream_throughput_kbps) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   if (effective_connection_type_algorithm_ ==
       EffectiveConnectionTypeAlgorithm::HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT) {
     return GetRecentEffectiveConnectionTypeUsingMetrics(
         start_time, NetworkQualityEstimator::MetricUsage::
                         MUST_BE_USED /* http_rtt_metric */,
         NetworkQualityEstimator::MetricUsage::
             DO_NOT_USE /* transport_rtt_metric */,
         NetworkQualityEstimator::MetricUsage::
-            MUST_BE_USED /* downstream_throughput_kbps_metric */);
+            MUST_BE_USED /* downstream_throughput_kbps_metric */,
+        http_rtt, transport_rtt, downstream_throughput_kbps);
   }
   if (effective_connection_type_algorithm_ ==
       EffectiveConnectionTypeAlgorithm::
           TRANSPORT_RTT_OR_DOWNSTREAM_THROUGHOUT) {
     return GetRecentEffectiveConnectionTypeUsingMetrics(
         start_time,
         NetworkQualityEstimator::MetricUsage::DO_NOT_USE /* http_rtt_metric */,
         NetworkQualityEstimator::MetricUsage::
             USE_IF_AVAILABLE /* transport_rtt_metric */,
         NetworkQualityEstimator::MetricUsage::
-            USE_IF_AVAILABLE /* downstream_throughput_kbps_metric */);
+            USE_IF_AVAILABLE /* downstream_throughput_kbps_metric */,
+        http_rtt, transport_rtt, downstream_throughput_kbps);
   }
   // Add additional algorithms here.
   NOTREACHED();
   return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
 }
 
 bool NetworkQualityEstimator::UseTransportRTT() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (effective_connection_type_algorithm_ ==
       EffectiveConnectionTypeAlgorithm::HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT) {
     return false;
   }
   if (effective_connection_type_algorithm_ ==
       EffectiveConnectionTypeAlgorithm::
           TRANSPORT_RTT_OR_DOWNSTREAM_THROUGHOUT) {
     return true;
   }
   // Add additional algorithms here.
   NOTREACHED();
   return false;
 }
 
 EffectiveConnectionType
 NetworkQualityEstimator::GetRecentEffectiveConnectionTypeUsingMetrics(
     const base::TimeTicks& start_time,
     NetworkQualityEstimator::MetricUsage http_rtt_metric,
     NetworkQualityEstimator::MetricUsage transport_rtt_metric,
-    NetworkQualityEstimator::MetricUsage downstream_throughput_kbps_metric)
-    const {
+    NetworkQualityEstimator::MetricUsage downstream_throughput_kbps_metric,
+    base::TimeDelta* http_rtt,
+    base::TimeDelta* transport_rtt,
+    int32_t* downstream_throughput_kbps) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  *http_rtt = nqe::internal::InvalidRTT();
+  *transport_rtt = nqe::internal::InvalidRTT();
+  *downstream_throughput_kbps = nqe::internal::kInvalidThroughput;
+
   if (forced_effective_connection_type_set_)
     return forced_effective_connection_type_;
 
   // If the device is currently offline, then return
   // EFFECTIVE_CONNECTION_TYPE_OFFLINE.
   if (current_network_id_.type == NetworkChangeNotifier::CONNECTION_NONE)
     return EFFECTIVE_CONNECTION_TYPE_OFFLINE;
 
-  base::TimeDelta http_rtt = nqe::internal::InvalidRTT();
-  if (http_rtt_metric != NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
-      !GetRecentHttpRTT(start_time, &http_rtt)) {
-    http_rtt = nqe::internal::InvalidRTT();
-  }
+  if (!GetRecentHttpRTT(start_time, http_rtt))
+    *http_rtt = nqe::internal::InvalidRTT();
 
-  base::TimeDelta transport_rtt = nqe::internal::InvalidRTT();
-  if (transport_rtt_metric !=
-          NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
-      !GetRecentTransportRTT(start_time, &transport_rtt)) {
-    transport_rtt = nqe::internal::InvalidRTT();
-  }
+  if (!GetRecentTransportRTT(start_time, transport_rtt))
+    *transport_rtt = nqe::internal::InvalidRTT();
 
-  int32_t kbps = nqe::internal::kInvalidThroughput;
-  if (downstream_throughput_kbps_metric !=
-          NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
-      !GetRecentDownlinkThroughputKbps(start_time, &kbps)) {
-    kbps = nqe::internal::kInvalidThroughput;
-  }
+  if (!GetRecentDownlinkThroughputKbps(start_time, downstream_throughput_kbps))
+    *downstream_throughput_kbps = nqe::internal::kInvalidThroughput;
 
-  if (http_rtt == nqe::internal::InvalidRTT() &&
+  if (*http_rtt == nqe::internal::InvalidRTT() &&
       http_rtt_metric == NetworkQualityEstimator::MetricUsage::MUST_BE_USED) {
     return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
   }
 
-  if (transport_rtt == nqe::internal::InvalidRTT() &&
+  if (*transport_rtt == nqe::internal::InvalidRTT() &&
       transport_rtt_metric ==
           NetworkQualityEstimator::MetricUsage::MUST_BE_USED) {
     return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
   }
 
-  if (kbps == nqe::internal::kInvalidThroughput &&
+  if (*downstream_throughput_kbps == nqe::internal::kInvalidThroughput &&
       downstream_throughput_kbps_metric ==
           NetworkQualityEstimator::MetricUsage::MUST_BE_USED) {
     return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
   }
 
-  if (http_rtt == nqe::internal::InvalidRTT() &&
-      transport_rtt == nqe::internal::InvalidRTT() &&
-      kbps == nqe::internal::kInvalidThroughput) {
+  if (*http_rtt == nqe::internal::InvalidRTT() &&
+      *transport_rtt == nqe::internal::InvalidRTT() &&
+      *downstream_throughput_kbps == nqe::internal::kInvalidThroughput) {
     // None of the metrics are available.
     return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
   }
 
   // Search from the slowest connection type to the fastest to find the
   // EffectiveConnectionType that best matches the current connection's
   // performance. The match is done by comparing RTT and throughput.
   for (size_t i = 0; i < EFFECTIVE_CONNECTION_TYPE_LAST; ++i) {
     EffectiveConnectionType type = static_cast<EffectiveConnectionType>(i);
     if (i == EFFECTIVE_CONNECTION_TYPE_UNKNOWN)
       continue;
 
     const bool estimated_http_rtt_is_higher_than_threshold =
-        http_rtt != nqe::internal::InvalidRTT() &&
+        http_rtt_metric != NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
+        *http_rtt != nqe::internal::InvalidRTT() &&
         connection_thresholds_[i].http_rtt() != nqe::internal::InvalidRTT() &&
-        http_rtt >= connection_thresholds_[i].http_rtt();
+        *http_rtt >= connection_thresholds_[i].http_rtt();
 
     const bool estimated_transport_rtt_is_higher_than_threshold =
-        transport_rtt != nqe::internal::InvalidRTT() &&
+        transport_rtt_metric !=
+            NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
+        *transport_rtt != nqe::internal::InvalidRTT() &&
         connection_thresholds_[i].transport_rtt() !=
             nqe::internal::InvalidRTT() &&
-        transport_rtt >= connection_thresholds_[i].transport_rtt();
+        *transport_rtt >= connection_thresholds_[i].transport_rtt();
 
     const bool estimated_throughput_is_lower_than_threshold =
-        kbps != nqe::internal::kInvalidThroughput &&
+        downstream_throughput_kbps_metric !=
+            NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
+        *downstream_throughput_kbps != nqe::internal::kInvalidThroughput &&
         connection_thresholds_[i].downstream_throughput_kbps() !=
             nqe::internal::kInvalidThroughput &&
-        kbps <= connection_thresholds_[i].downstream_throughput_kbps();
+        *downstream_throughput_kbps <=
+            connection_thresholds_[i].downstream_throughput_kbps();
 
     if (estimated_http_rtt_is_higher_than_threshold ||
         estimated_transport_rtt_is_higher_than_threshold ||
         estimated_throughput_is_lower_than_threshold) {
       return type;
     }
   }
   // Return the fastest connection type.
   return static_cast<EffectiveConnectionType>(EFFECTIVE_CONNECTION_TYPE_LAST -
                                               1);
 }
 
 void NetworkQualityEstimator::AddEffectiveConnectionTypeObserver(
     EffectiveConnectionTypeObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   effective_connection_type_observer_list_.AddObserver(observer);
 }
 
 void NetworkQualityEstimator::RemoveEffectiveConnectionTypeObserver(
     EffectiveConnectionTypeObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   effective_connection_type_observer_list_.RemoveObserver(observer);
 }
 
+void NetworkQualityEstimator::AddRTTAndThroughputEstimatesObserver(
+    RTTAndThroughputEstimatesObserver* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  rtt_and_throughput_estimates_observer_list_.AddObserver(observer);
+}
+
+void NetworkQualityEstimator::RemoveRTTAndThroughputEstimatesObserver(
+    RTTAndThroughputEstimatesObserver* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  rtt_and_throughput_estimates_observer_list_.RemoveObserver(observer);
+}
+
 bool NetworkQualityEstimator::GetHttpRTT(base::TimeDelta* rtt) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return GetRecentHttpRTT(base::TimeTicks(), rtt);
 }
 
 bool NetworkQualityEstimator::GetTransportRTT(base::TimeDelta* rtt) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return GetRecentTransportRTT(base::TimeTicks(), rtt);
 }
 
@@ skipping 132 matching lines @@
                         cached_estimate_available);
 
   if (!cached_estimate_available)
     return false;
 
   const base::TimeTicks now = tick_clock_->NowTicks();
 
   if (effective_connection_type_ == EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {
     // Read the effective connection type from the cached estimate.
     last_effective_connection_type_computation_ = now;
+    http_rtt_ = cached_network_quality.network_quality().http_rtt();
+    transport_rtt_ = cached_network_quality.network_quality().transport_rtt();
+    downstream_throughput_kbps_ =
+        cached_network_quality.network_quality().downstream_throughput_kbps();
     effective_connection_type_ =
         cached_network_quality.effective_connection_type();
 
     if (effective_connection_type_ != EFFECTIVE_CONNECTION_TYPE_UNKNOWN)
       NotifyObserversOfEffectiveConnectionTypeChanged();
   }
 
   if (cached_network_quality.network_quality().downstream_throughput_kbps() !=
       nqe::internal::kInvalidThroughput) {
     ThroughputObservation througphput_observation(
@@ skipping 74 matching lines @@
 }
 
 void NetworkQualityEstimator::NotifyObserversOfRTT(
     const RttObservation& observation) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(nqe::internal::InvalidRTT(), observation.value);
 
   // Maybe recompute the effective connection type since a new RTT observation
   // is available.
   MaybeComputeEffectiveConnectionType();
-  FOR_EACH_OBSERVER(
-      RTTObserver, rtt_observer_list_,
-      OnRTTObservation(observation.value.InMilliseconds(),
-                       observation.timestamp, observation.source));
+  for (auto& observer : rtt_observer_list_) {
+    observer.OnRTTObservation(observation.value.InMilliseconds(),
+                              observation.timestamp, observation.source);
+  }
 }
 
 void NetworkQualityEstimator::NotifyObserversOfThroughput(
     const ThroughputObservation& observation) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(nqe::internal::kInvalidThroughput, observation.value);
 
   // Maybe recompute the effective connection type since a new throughput
   // observation is available.
   MaybeComputeEffectiveConnectionType();
-  FOR_EACH_OBSERVER(
-      ThroughputObserver, throughput_observer_list_,
-      OnThroughputObservation(observation.value, observation.timestamp,
-                              observation.source));
+  for (auto& observer : throughput_observer_list_) {
+    observer.OnThroughputObservation(observation.value, observation.timestamp,
+                                     observation.source);
+  }
 }
 
 void NetworkQualityEstimator::OnNewThroughputObservationAvailable(
     int32_t downstream_kbps) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (downstream_kbps == 0)
     return;
 
   DCHECK_NE(nqe::internal::kInvalidThroughput, downstream_kbps);
@@ skipping 38 matching lines @@
   }
   ComputeEffectiveConnectionType();
 }
 
 void NetworkQualityEstimator::
     NotifyObserversOfEffectiveConnectionTypeChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(EFFECTIVE_CONNECTION_TYPE_LAST, effective_connection_type_);
 
   // TODO(tbansal): Add hysteresis in the notification.
-  FOR_EACH_OBSERVER(
-      EffectiveConnectionTypeObserver, effective_connection_type_observer_list_,
-      OnEffectiveConnectionTypeChanged(effective_connection_type_));
+  for (auto& observer : effective_connection_type_observer_list_)
+    observer.OnEffectiveConnectionTypeChanged(effective_connection_type_);
 
   // Add the estimates of the current network to the cache store.
   if (effective_connection_type_ != EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {
     network_quality_store_->Add(
         current_network_id_,
         nqe::internal::CachedNetworkQuality(
             tick_clock_->NowTicks(), estimated_quality_at_last_main_frame_,
             effective_connection_type_));
   }
 }
 
+void NetworkQualityEstimator::NotifyObserversOfRTTOrThroughputComputed() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // TODO(tbansal): Add hysteresis in the notification.
+  for (auto& observer : rtt_and_throughput_estimates_observer_list_) {
+    observer.OnRTTOrThroughputEstimatesComputed(http_rtt_, transport_rtt_,
+                                                downstream_throughput_kbps_);
+  }
+}
+
 void NetworkQualityEstimator::AddNetworkQualitiesCacheObserver(
     nqe::internal::NetworkQualityStore::NetworkQualitiesCacheObserver*
         observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   network_quality_store_->AddNetworkQualitiesCacheObserver(observer);
 }
 
 void NetworkQualityEstimator::RemoveNetworkQualitiesCacheObserver(
     nqe::internal::NetworkQualityStore::NetworkQualitiesCacheObserver*
         observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   network_quality_store_->RemoveNetworkQualitiesCacheObserver(observer);
 }
 
 }  // namespace net