Reduce the number of calls to external estimate provider

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 258 matching lines @@
   static_assert(kMaximumNetworkQualityCacheSize <= 10,
                 "Size of the network quality cache must <= 10");
 
   ObtainOperatingParams(variation_params);
   ObtainEffectiveConnectionTypeModelParams(variation_params);
   NetworkChangeNotifier::AddConnectionTypeObserver(this);
   if (external_estimate_provider_) {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE);
     external_estimate_provider_->SetUpdatedEstimateDelegate(this);
-    QueryExternalEstimateProvider();
   } else {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_NOT_AVAILABLE);
   }
   current_network_id_ = GetCurrentNetworkID();
   AddDefaultEstimates();
 
   throughput_analyzer_.reset(new nqe::internal::ThroughputAnalyzer(
       base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&NetworkQualityEstimator::OnNewThroughputObservationAvailable,
@@ skipping 319 matching lines @@
   // Write the estimates of the previous network to the cache.
   CacheNetworkQualityEstimate();
 
   // Clear the local state.
   last_connection_change_ = base::TimeTicks::Now();
   peak_network_quality_ = nqe::internal::NetworkQuality();
   downstream_throughput_kbps_observations_.Clear();
   rtt_observations_.Clear();
   current_network_id_ = GetCurrentNetworkID();
 
-  QueryExternalEstimateProvider();
+  // Query the external estimate provider on certain connection types. Once the
+  // updated estimates are available, OnUpdatedEstimateAvailable will be called
+  // by |external_estimate_provider_| with updated estimates.
+  if (external_estimate_provider_ &&
+      current_network_id_.type != NetworkChangeNotifier::CONNECTION_NONE &&
+      current_network_id_.type != NetworkChangeNotifier::CONNECTION_UNKNOWN &&
+      current_network_id_.type != NetworkChangeNotifier::CONNECTION_ETHERNET &&
+      current_network_id_.type != NetworkChangeNotifier::CONNECTION_BLUETOOTH) {
+    RecordExternalEstimateProviderMetrics(
+        EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED);
+    external_estimate_provider_->Update();
+  }
 
   // Read any cached estimates for the new network. If cached estimates are
   // unavailable, add the default estimates.
   if (!ReadCachedNetworkQualityEstimate())
     AddDefaultEstimates();
   estimated_median_network_quality_ = nqe::internal::NetworkQuality();
   throughput_analyzer_->OnConnectionTypeChanged();
 }
 
 void NetworkQualityEstimator::RecordMetricsOnConnectionTypeChanged() const {
@@ skipping 311 matching lines @@
     RttObservation rtt_observation(
         network_quality.http_rtt(), now,
         NETWORK_QUALITY_OBSERVATION_SOURCE_CACHED_ESTIMATE);
     rtt_observations_.AddObservation(rtt_observation);
     NotifyObserversOfRTT(rtt_observation);
   }
 
   return read_cached_estimate;
 }
 
-void NetworkQualityEstimator::OnUpdatedEstimateAvailable() {
+void NetworkQualityEstimator::OnUpdatedEstimateAvailable(
+    const base::TimeDelta& rtt,
+    int32_t downstream_throughput_kbps,
+    int32_t upstream_throughput_kbps) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(external_estimate_provider_);
 
   RecordExternalEstimateProviderMetrics(
       EXTERNAL_ESTIMATE_PROVIDER_STATUS_CALLBACK);
-  QueryExternalEstimateProvider();
+
+  if (rtt > base::TimeDelta()) {
+    RecordExternalEstimateProviderMetrics(
+        EXTERNAL_ESTIMATE_PROVIDER_STATUS_RTT_AVAILABLE);
+    UMA_HISTOGRAM_TIMES("NQE.ExternalEstimateProvider.RTT", rtt);
+    rtt_observations_.AddObservation(
+        RttObservation(rtt, base::TimeTicks::Now(),
+                       NETWORK_QUALITY_OBSERVATION_SOURCE_EXTERNAL_ESTIMATE));
+  }
+
+  if (downstream_throughput_kbps > 0) {
+    RecordExternalEstimateProviderMetrics(
+        EXTERNAL_ESTIMATE_PROVIDER_STATUS_DOWNLINK_BANDWIDTH_AVAILABLE);
+    UMA_HISTOGRAM_COUNTS("NQE.ExternalEstimateProvider.DownlinkBandwidth",
+                         downstream_throughput_kbps);
+    downstream_throughput_kbps_observations_.AddObservation(
+        ThroughputObservation(
+            downstream_throughput_kbps, base::TimeTicks::Now(),
+            NETWORK_QUALITY_OBSERVATION_SOURCE_EXTERNAL_ESTIMATE));
+  }
 }
 
 const char* NetworkQualityEstimator::GetNameForEffectiveConnectionType(
     EffectiveConnectionType type) const {
   switch (type) {
     case EFFECTIVE_CONNECTION_TYPE_UNKNOWN:
       return "Unknown";
     case EFFECTIVE_CONNECTION_TYPE_OFFLINE:
       return "Offline";
     case EFFECTIVE_CONNECTION_TYPE_SLOW_2G:
       return "Slow2G";
     case EFFECTIVE_CONNECTION_TYPE_2G:
       return "2G";
     case EFFECTIVE_CONNECTION_TYPE_3G:
       return "3G";
     case EFFECTIVE_CONNECTION_TYPE_4G:
       return "4G";
     case EFFECTIVE_CONNECTION_TYPE_BROADBAND:
       return "Broadband";
     default:
       NOTREACHED();
       break;
   }
   return "";
 }
 
-void NetworkQualityEstimator::QueryExternalEstimateProvider() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (!external_estimate_provider_)
-    return;
-  RecordExternalEstimateProviderMetrics(
-      EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED);
-
-  base::TimeDelta time_since_last_update;
-
-  // Request a new estimate if estimate is not available, or if the available
-  // estimate is not fresh.
-  if (!external_estimate_provider_->GetTimeSinceLastUpdate(
-          &time_since_last_update) ||
-      time_since_last_update >
-          base::TimeDelta::FromMilliseconds(
-              kExternalEstimateProviderFreshnessDurationMsec)) {
-    // Request the external estimate provider for updated estimates. When the
-    // 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)) {
-    RecordExternalEstimateProviderMetrics(
-        EXTERNAL_ESTIMATE_PROVIDER_STATUS_RTT_AVAILABLE);
-    UMA_HISTOGRAM_TIMES("NQE.ExternalEstimateProvider.RTT", rtt);
-    rtt_observations_.AddObservation(
-        RttObservation(rtt, base::TimeTicks::Now(),
-                       NETWORK_QUALITY_OBSERVATION_SOURCE_EXTERNAL_ESTIMATE));
-  }
-
-  int32_t downstream_throughput_kbps;
-  if (external_estimate_provider_->GetDownstreamThroughputKbps(
-          &downstream_throughput_kbps)) {
-    RecordExternalEstimateProviderMetrics(
-        EXTERNAL_ESTIMATE_PROVIDER_STATUS_DOWNLINK_BANDWIDTH_AVAILABLE);
-    UMA_HISTOGRAM_COUNTS("NQE.ExternalEstimateProvider.DownlinkBandwidth",
-                         downstream_throughput_kbps);
-    downstream_throughput_kbps_observations_.AddObservation(
-        ThroughputObservation(
-            downstream_throughput_kbps, base::TimeTicks::Now(),
-            NETWORK_QUALITY_OBSERVATION_SOURCE_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())
     return;
 
   base::TimeDelta http_rtt = nqe::internal::InvalidRTT();
@@ skipping 82 matching lines @@
   }
   ThroughputObservation throughput_observation(
       downstream_kbps, base::TimeTicks::Now(),
       NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST);
   downstream_throughput_kbps_observations_.AddObservation(
       throughput_observation);
   NotifyObserversOfThroughput(throughput_observation);
 }
 
 }  // namespace net