NQE: Store the current network quality in a single variable

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 234 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_(
           nqe::internal::correlation_uma_logging_probability(variation_params)),
       forced_effective_connection_type_set_(
           nqe::internal::forced_effective_connection_type_set(
               variation_params)),
       forced_effective_connection_type_(
           nqe::internal::forced_effective_connection_type(variation_params)),
@@ skipping 107 matching lines @@
       !RequestProvidesRTTObservation(request)) {
     return;
   }
 
   const base::TimeTicks now = tick_clock_->NowTicks();
 
   // Update |estimated_quality_at_last_main_frame_| if this is a main frame
   // request.
   if (request.load_flags() & LOAD_MAIN_FRAME_DEPRECATED) {
     last_main_frame_request_ = now;
-    base::TimeDelta estimated_http_rtt;
-    if (!GetHttpRTT(&estimated_http_rtt))
-      estimated_http_rtt = nqe::internal::InvalidRTT();
-
-    base::TimeDelta estimated_transport_rtt;
-    if (!GetTransportRTT(&estimated_transport_rtt))
-      estimated_transport_rtt = nqe::internal::InvalidRTT();
-
-    int32_t downstream_throughput_kbps;
-    if (!GetDownlinkThroughputKbps(&downstream_throughput_kbps))
-      downstream_throughput_kbps = nqe::internal::kInvalidThroughput;
-
-    estimated_quality_at_last_main_frame_ = nqe::internal::NetworkQuality(
-        estimated_http_rtt, estimated_transport_rtt,
-        downstream_throughput_kbps);
 
     ComputeEffectiveConnectionType();
-    effective_connection_type_at_last_main_frame_ =
-        GetEffectiveConnectionType();
+    effective_connection_type_at_last_main_frame_ = effective_connection_type_;
+    estimated_quality_at_last_main_frame_ = network_quality_;
 
     RecordMetricsOnMainFrameRequest();
     MaybeQueryExternalEstimateProvider();
 
     // Post the tasks which will run in the future and record the estimation
     // accuracy based on the observations received between now and the time of
     // task execution. Posting the task at different intervals makes it
     // possible to measure the accuracy by comparing the estimate with the
     // observations received over intervals of varying durations.
     for (const base::TimeDelta& measuring_delay :
@@ skipping 56 matching lines @@
   // time. Returning here ensures that we do not take inaccurate readings.
   if (now - last_main_frame_request_ > 2 * measuring_duration)
     return;
 
   // Do not record accuracy if there was a connection change since the last main
   // frame request.
   if (last_main_frame_request_ <= last_connection_change_)
     return;
 
   base::TimeDelta recent_http_rtt;
+  if (!GetRecentHttpRTT(last_main_frame_request_, &recent_http_rtt))
+    recent_http_rtt = nqe::internal::InvalidRTT();
+
   if (estimated_quality_at_last_main_frame_.http_rtt() !=
           nqe::internal::InvalidRTT() &&
-      GetRecentHttpRTT(last_main_frame_request_, &recent_http_rtt)) {
+      recent_http_rtt != nqe::internal::InvalidRTT()) {
     const int estimated_observed_diff_milliseconds =
         estimated_quality_at_last_main_frame_.http_rtt().InMilliseconds() -
         recent_http_rtt.InMilliseconds();
 
     RecordRTTAccuracy("NQE.Accuracy.HttpRTT",
                       estimated_observed_diff_milliseconds, measuring_duration,
                       recent_http_rtt);
   }
 
   base::TimeDelta recent_transport_rtt;
@@ skipping 209 matching lines @@
   use_small_responses_ = use_small_responses;
   throughput_analyzer_->SetUseSmallResponsesForTesting(use_small_responses_);
 }
 
 void NetworkQualityEstimator::ReportEffectiveConnectionTypeForTesting(
     EffectiveConnectionType effective_connection_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (auto& observer : effective_connection_type_observer_list_)
     observer.OnEffectiveConnectionTypeChanged(effective_connection_type);
 
-  network_quality_store_->Add(
-      current_network_id_,
-      nqe::internal::CachedNetworkQuality(tick_clock_->NowTicks(),
-                                          estimated_quality_at_last_main_frame_,
-                                          effective_connection_type));
+  network_quality_store_->Add(current_network_id_,
+                              nqe::internal::CachedNetworkQuality(
+                                  tick_clock_->NowTicks(), network_quality_,
+                                  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() &&
          !request.was_cached() &&
          request.creation_time() >= last_connection_change_;
 }
 
 void NetworkQualityEstimator::RecordExternalEstimateProviderMetrics(
     NQEExternalEstimateProviderStatus status) const {
   UMA_HISTOGRAM_ENUMERATION("NQE.ExternalEstimateProviderStatus", status,
                             EXTERNAL_ESTIMATE_PROVIDER_STATUS_BOUNDARY);
 }
 
 void NetworkQualityEstimator::OnConnectionTypeChanged(
     NetworkChangeNotifier::ConnectionType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   RecordMetricsOnConnectionTypeChanged();
 
   // Write the estimates of the previous network to the cache.
   network_quality_store_->Add(
-      current_network_id_,
-      nqe::internal::CachedNetworkQuality(
-          last_effective_connection_type_computation_,
-          estimated_quality_at_last_main_frame_, effective_connection_type_));
+      current_network_id_, nqe::internal::CachedNetworkQuality(
+                               last_effective_connection_type_computation_,
+                               network_quality_, effective_connection_type_));
 
   // Clear the local state.
   last_connection_change_ = tick_clock_->NowTicks();
   peak_network_quality_ = nqe::internal::NetworkQuality();
   downstream_throughput_kbps_observations_.Clear();
   rtt_observations_.Clear();
 
 #if defined(OS_ANDROID)
   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;
+  network_quality_ = nqe::internal::NetworkQuality();
   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 46 matching lines @@
 
   if (peak_network_quality_.downstream_throughput_kbps() !=
       nqe::internal::kInvalidThroughput) {
     base::HistogramBase* downstream_throughput_histogram =
         GetHistogram("PeakKbps.", current_network_id_.type, 1000 * 1000);
     downstream_throughput_histogram->Add(
         peak_network_quality_.downstream_throughput_kbps());
   }
 
   base::TimeDelta rtt;
-  if (GetHttpRTT(&rtt)) {
+  if (GetRecentHttpRTT(base::TimeTicks(), &rtt)) {
     // Add the 50th percentile value.
     base::HistogramBase* rtt_percentile =
         GetHistogram("RTT.Percentile50.", current_network_id_.type, 10 * 1000);
     rtt_percentile->Add(rtt.InMilliseconds());
 
     // Add the remaining percentile values.
     static const int kPercentiles[] = {0, 10, 90, 100};
     std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
     disallowed_observation_sources.push_back(
         NETWORK_QUALITY_OBSERVATION_SOURCE_TCP);
     disallowed_observation_sources.push_back(
         NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC);
     for (size_t i = 0; i < arraysize(kPercentiles); ++i) {
       rtt = GetRTTEstimateInternal(disallowed_observation_sources,
                                    base::TimeTicks(), kPercentiles[i]);
 
       rtt_percentile = GetHistogram(
           "RTT.Percentile" + base::IntToString(kPercentiles[i]) + ".",
           current_network_id_.type, 10 * 1000);  // 10 seconds
       rtt_percentile->Add(rtt.InMilliseconds());
     }
   }
 
-  if (GetTransportRTT(&rtt)) {
+  if (GetRecentTransportRTT(base::TimeTicks(), &rtt)) {
     // Add the 50th percentile value.
     base::HistogramBase* transport_rtt_percentile = GetHistogram(
         "TransportRTT.Percentile50.", current_network_id_.type, 10 * 1000);
     transport_rtt_percentile->Add(rtt.InMilliseconds());
 
     // Add the remaining percentile values.
     static const int kPercentiles[] = {0, 10, 90, 100};
     std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
     disallowed_observation_sources.push_back(
         NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP);
@@ skipping 22 matching lines @@
           NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI ||
       NetworkChangeNotifier::IsConnectionCellular(current_network_id_.type)) {
     UMA_HISTOGRAM_BOOLEAN("NQE.NetworkIdAvailable",
                           !current_network_id_.id.empty());
   }
 }
 
 void NetworkQualityEstimator::RecordMetricsOnMainFrameRequest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  base::TimeDelta http_rtt;
-  if (GetHttpRTT(&http_rtt)) {
+  if (estimated_quality_at_last_main_frame_.http_rtt() !=
+      nqe::internal::InvalidRTT()) {
     // Add the 50th percentile value.
-    UMA_HISTOGRAM_TIMES("NQE.MainFrame.RTT.Percentile50", http_rtt);
+    UMA_HISTOGRAM_TIMES("NQE.MainFrame.RTT.Percentile50",
+                        estimated_quality_at_last_main_frame_.http_rtt());
     base::HistogramBase* rtt_percentile = GetHistogram(
         "MainFrame.RTT.Percentile50.", current_network_id_.type, 10 * 1000);
-    rtt_percentile->Add(http_rtt.InMilliseconds());
+    rtt_percentile->Add(
+        estimated_quality_at_last_main_frame_.http_rtt().InMilliseconds());
   }
 
-  base::TimeDelta transport_rtt;
-  if (GetTransportRTT(&transport_rtt)) {
+  if (estimated_quality_at_last_main_frame_.transport_rtt() !=
+      nqe::internal::InvalidRTT()) {
     // Add the 50th percentile value.
     UMA_HISTOGRAM_TIMES("NQE.MainFrame.TransportRTT.Percentile50",
-                        transport_rtt);
+                        estimated_quality_at_last_main_frame_.transport_rtt());
     base::HistogramBase* transport_rtt_percentile =
         GetHistogram("MainFrame.TransportRTT.Percentile50.",
                      current_network_id_.type, 10 * 1000);
-    transport_rtt_percentile->Add(transport_rtt.InMilliseconds());
+    transport_rtt_percentile->Add(
+        estimated_quality_at_last_main_frame_.transport_rtt().InMilliseconds());
   }
 
-  int32_t kbps;
-  if (GetDownlinkThroughputKbps(&kbps)) {
+  if (estimated_quality_at_last_main_frame_.downstream_throughput_kbps() !=
+      nqe::internal::kInvalidThroughput) {
     // Add the 50th percentile value.
-    UMA_HISTOGRAM_COUNTS_1M("NQE.MainFrame.Kbps.Percentile50", kbps);
+    UMA_HISTOGRAM_COUNTS_1M(
+        "NQE.MainFrame.Kbps.Percentile50",
+        estimated_quality_at_last_main_frame_.downstream_throughput_kbps());
     base::HistogramBase* throughput_percentile = GetHistogram(
         "MainFrame.Kbps.Percentile50.", current_network_id_.type, 1000 * 1000);
-    throughput_percentile->Add(kbps);
+    throughput_percentile->Add(
+        estimated_quality_at_last_main_frame_.downstream_throughput_kbps());
   }
 
-  const EffectiveConnectionType effective_connection_type =
-      GetEffectiveConnectionType();
   UMA_HISTOGRAM_ENUMERATION("NQE.MainFrame.EffectiveConnectionType",
-                            effective_connection_type,
+                            effective_connection_type_at_last_main_frame_,
                             EFFECTIVE_CONNECTION_TYPE_LAST);
   base::HistogramBase* effective_connection_type_histogram =
       base::Histogram::FactoryGet(
           std::string("NQE.MainFrame.EffectiveConnectionType.") +
               nqe::internal::GetNameForConnectionType(current_network_id_.type),
           0, EFFECTIVE_CONNECTION_TYPE_LAST,
           EFFECTIVE_CONNECTION_TYPE_LAST /* Number of buckets */,
           base::HistogramBase::kUmaTargetedHistogramFlag);
 
-  effective_connection_type_histogram->Add(effective_connection_type);
+  effective_connection_type_histogram->Add(
+      effective_connection_type_at_last_main_frame_);
 }
 
 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;
 
+  base::TimeDelta http_rtt = nqe::internal::InvalidRTT();
+  base::TimeDelta transport_rtt = nqe::internal::InvalidRTT();
+  int32_t downstream_throughput_kbps = nqe::internal::kInvalidThroughput;
+
   effective_connection_type_ =
       GetRecentEffectiveConnectionTypeAndNetworkQuality(
-          base::TimeTicks(), &http_rtt_, &transport_rtt_,
-          &downstream_throughput_kbps_);
+          base::TimeTicks(), &http_rtt, &transport_rtt,
+          &downstream_throughput_kbps);
+
+  network_quality_ = nqe::internal::NetworkQuality(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;
+  base::TimeDelta http_rtt = nqe::internal::InvalidRTT();
+  base::TimeDelta transport_rtt = nqe::internal::InvalidRTT();
+  int32_t downstream_throughput_kbps = nqe::internal::kInvalidThroughput;
 
   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,
@@ skipping 160 matching lines @@
   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);
-}
-
-bool NetworkQualityEstimator::GetDownlinkThroughputKbps(int32_t* kbps) const {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return GetRecentDownlinkThroughputKbps(base::TimeTicks(), kbps);
-}
-
 bool NetworkQualityEstimator::GetRecentHttpRTT(
     const base::TimeTicks& start_time,
     base::TimeDelta* rtt) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
   disallowed_observation_sources.push_back(
       NETWORK_QUALITY_OBSERVATION_SOURCE_TCP);
   disallowed_observation_sources.push_back(
       NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC);
   *rtt = GetRTTEstimateInternal(disallowed_observation_sources, start_time, 50);
@@ skipping 117 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();
+    network_quality_ = cached_network_quality.network_quality();
     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 157 matching lines @@
     NotifyObserversOfEffectiveConnectionTypeChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(EFFECTIVE_CONNECTION_TYPE_LAST, effective_connection_type_);
 
   // TODO(tbansal): Add hysteresis in the notification.
   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_));
+    network_quality_store_->Add(current_network_id_,
+                                nqe::internal::CachedNetworkQuality(
+                                    tick_clock_->NowTicks(), network_quality_,
+                                    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_);
+    observer.OnRTTOrThroughputEstimatesComputed(
+        network_quality_.http_rtt(), network_quality_.transport_rtt(),
+        network_quality_.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);
 }
 
 void NetworkQualityEstimator::OnPrefsRead(
     const std::map<nqe::internal::NetworkID,
                    nqe::internal::CachedNetworkQuality> read_prefs) {
   DCHECK(thread_checker_.CalledOnValidThread());
   UMA_HISTOGRAM_COUNTS("NQE.Prefs.ReadSize", read_prefs.size());
   // TODO(tbansal): crbug.com/490870. Incorporate the network quality into the
   // current estimates.
 }
 
 }  // namespace net