Populate EEP estimate in NQE

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 160 matching lines @@
     bool allow_smaller_responses_for_tests)
     : allow_localhost_requests_(allow_local_host_requests_for_tests),
       allow_small_responses_(allow_smaller_responses_for_tests),
       last_connection_change_(base::TimeTicks::Now()),
       current_network_id_(
           NetworkID(NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN,
                     std::string())),
       downstream_throughput_kbps_observations_(
           GetWeightMultiplierPerSecond(variation_params)),
       rtt_msec_observations_(GetWeightMultiplierPerSecond(variation_params)),
-      external_estimates_provider_(external_estimates_provider.Pass()) {
+      external_estimate_provider_(external_estimates_provider.Pass()) {
   static_assert(kMinRequestDurationMicroseconds > 0,
                 "Minimum request duration must be > 0");
   static_assert(kDefaultHalfLifeSeconds > 0,
                 "Default half life duration must be > 0");
   static_assert(kMaximumNetworkQualityCacheSize > 0,
                 "Size of the network quality cache must be > 0");
   // This limit should not be increased unless the logic for removing the
   // oldest cache entry is rewritten to use a doubly-linked-list LRU queue.
   static_assert(kMaximumNetworkQualityCacheSize <= 10,
                 "Size of the network quality cache must <= 10");
 
   ObtainOperatingParams(variation_params);
   NetworkChangeNotifier::AddConnectionTypeObserver(this);
-  if (external_estimates_provider_)
-    external_estimates_provider_->SetUpdatedEstimateDelegate(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();
 }
 
 // static
 const base::TimeDelta NetworkQualityEstimator::InvalidRTT() {
   return base::TimeDelta::Max();
 }
 
 void NetworkQualityEstimator::ObtainOperatingParams(
     const std::map<std::string, std::string>& variation_params) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   for (size_t i = 0; i <= NetworkChangeNotifier::CONNECTION_LAST; ++i) {
     NetworkChangeNotifier::ConnectionType type =
         static_cast<NetworkChangeNotifier::ConnectionType>(i);
+    DCHECK_EQ(InvalidRTT(), default_observations_[i].rtt());
+    DCHECK_EQ(kInvalidThroughput,
+              default_observations_[i].downstream_throughput_kbps());
     int32_t variations_value = kMinimumRTTVariationParameterMsec - 1;
     // Name of the parameter that holds the RTT value for this connection type.
     std::string rtt_parameter_name =
         std::string(GetNameForConnectionType(type))
             .append(kDefaultRTTMsecObservationSuffix);
     auto it = variation_params.find(rtt_parameter_name);
     if (it != variation_params.end() &&
         base::StringToInt(it->second, &variations_value) &&
         variations_value >= kMinimumRTTVariationParameterMsec) {
       default_observations_[i] =
@@ skipping 34 matching lines @@
 }
 
 NetworkQualityEstimator::~NetworkQualityEstimator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
 void NetworkQualityEstimator::NotifyHeadersReceived(const URLRequest& request) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  MaybeQueryExternalEstimateProvider();
   if (!RequestProvidesUsefulObservations(request))
     return;
 
   // Update |estimated_median_network_quality_| if this is a main frame request.
   if (request.load_flags() & LOAD_MAIN_FRAME) {
     estimated_median_network_quality_ = NetworkQuality(
         GetRTTEstimateInternal(base::TimeTicks(), 50),
         GetDownlinkThroughputKbpsEstimateInternal(base::TimeTicks(), 50));
   }
 
@@ skipping 30 matching lines @@
     if (estimated_median_network_quality_.rtt() != InvalidRTT()) {
       RecordRTTUMA(estimated_median_network_quality_.rtt().InMilliseconds(),
                    observed_rtt.InMilliseconds());
     }
 }
 
 void NetworkQualityEstimator::NotifyRequestCompleted(
     const URLRequest& request) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  MaybeQueryExternalEstimateProvider();
   if (!RequestProvidesUsefulObservations(request))
     return;
 
   base::TimeTicks now = base::TimeTicks::Now();
   LoadTimingInfo load_timing_info;
   request.GetLoadTimingInfo(&load_timing_info);
 
   // If the load timing info is unavailable, it probably means that the request
   // did not go over the network.
   if (load_timing_info.send_start.is_null() ||
@@ skipping 85 matching lines @@
   return request.url().is_valid() &&
          (allow_localhost_requests_ || !IsLocalhost(request.url().host())) &&
          request.url().SchemeIsHTTPOrHTTPS() &&
          // 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());
   if (peak_network_quality_.rtt() != InvalidRTT()) {
     switch (current_network_id_.type) {
       case NetworkChangeNotifier::CONNECTION_UNKNOWN:
         UMA_HISTOGRAM_TIMES("NQE.FastestRTT.Unknown",
                             peak_network_quality_.rtt());
         break;
       case NetworkChangeNotifier::CONNECTION_ETHERNET:
@@ skipping 99 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_ = NetworkQuality();
   downstream_throughput_kbps_observations_.Clear();
   rtt_msec_observations_.Clear();
   current_network_id_ = GetCurrentNetworkID();
 
+  QueryExternalEstimateProvider();
+
   // Read any cached estimates for the new network. If cached estimates are
   // unavailable, add the default estimates.
   if (!ReadCachedNetworkQualityEstimate())
     AddDefaultEstimates();
   estimated_median_network_quality_ = NetworkQuality();
 }
 
-bool NetworkQualityEstimator::GetRTTEstimate(base::TimeDelta* rtt) const {
+bool NetworkQualityEstimator::GetRTTEstimate(base::TimeDelta* rtt) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(rtt);
+  MaybeQueryExternalEstimateProvider();
   if (rtt_msec_observations_.Size() == 0) {
     *rtt = InvalidRTT();
     return false;
   }
   *rtt = GetRTTEstimateInternal(base::TimeTicks(), 50);
   return (*rtt != InvalidRTT());
 }
 
-bool NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimate(
-    int32_t* kbps) const {
+bool NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimate(int32_t* kbps) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(kbps);
+  MaybeQueryExternalEstimateProvider();
   if (downstream_throughput_kbps_observations_.Size() == 0) {
     *kbps = kInvalidThroughput;
     return false;
   }
   *kbps = GetDownlinkThroughputKbpsEstimateInternal(base::TimeTicks(), 50);
   return (*kbps != kInvalidThroughput);
 }
 
 bool NetworkQualityEstimator::GetRecentMedianRTT(
     const base::TimeTicks& begin_timestamp,
-    base::TimeDelta* rtt) const {
+    base::TimeDelta* rtt) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(rtt);
+
+  MaybeQueryExternalEstimateProvider();
   *rtt = GetRTTEstimateInternal(begin_timestamp, 50);
   return (*rtt != InvalidRTT());
 }
 
 bool NetworkQualityEstimator::GetRecentMedianDownlinkThroughputKbps(
     const base::TimeTicks& begin_timestamp,
-    int32_t* kbps) const {
+    int32_t* kbps) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(kbps);
+
+  MaybeQueryExternalEstimateProvider();
   *kbps = GetDownlinkThroughputKbpsEstimateInternal(begin_timestamp, 50);
   return (*kbps != kInvalidThroughput);
 }
 
 NetworkQualityEstimator::Observation::Observation(int32_t value,
                                                   base::TimeTicks timestamp)
     : value(value), timestamp(timestamp) {
   DCHECK_GE(value, 0);
   DCHECK(!timestamp.is_null());
 }
@@ skipping 210 matching lines @@
 
   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()));
   return true;
 }
 
 void NetworkQualityEstimator::OnUpdatedEstimateAvailable() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(external_estimates_provider_);
-  // TODO(tbansal): Query provider for the recent value.
+  DCHECK(external_estimate_provider_);
+
+  RecordExternalEstimateProviderMetrics(
+      EXTERNAL_ESTIMATE_PROVIDER_STATUS_CALLBACK);
+  QueryExternalEstimateProvider();
+}
+
+void NetworkQualityEstimator::MaybeQueryExternalEstimateProvider() {
+  if (base::TimeTicks::Now() - external_estimate_request_time_ >=
+      base::TimeDelta::FromMilliseconds(
+          kExternalEstimateProviderQueryIntervalMsec)) {

[mmenke, 2015/09/14 20:07:06]

None of the tests check this logic.

[tbansal1, 2015/09/14 23:46:56]

Obsolete.

+    QueryExternalEstimateProvider();
+  }
+}
+
+void NetworkQualityEstimator::QueryExternalEstimateProvider() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!external_estimate_provider_)
+    return;
+  RecordExternalEstimateProviderMetrics(
+      EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED);
+  external_estimate_request_time_ = base::TimeTicks::Now();
+
+  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_->RequestUpdate();
+    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() - time_since_last_update));

[mmenke, 2015/09/14 20:07:06]

I still think just randomly adding these sources together like this is a
mistake.

Suppose Android's system estimate does the same thing you're doing...Suddenly
you're weighting previous RTT measurements significantly more (They affect the
current estimate, and the previous system estimate).

It also has weird effects in that the more consumers you have sampling the data,
the greater weight system measurements have, which seems a bit weird.

[tbansal1, 2015/09/14 23:46:56]

Modified the CL to add estimate from external provider only on network changes.
However, that estimate is still mixed with the other observations. So, there is
no periodic sampling of EEP anymore.

There is another CL that tags the Observation with the source from where the
observation came
(https://codereview.chromium.org/1273173002/diff/300001/net/base/network_quali...).
With that, it would be possible to distinguish the observations, if there is a
need to do that.

+  }
+
+  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() - time_since_last_update));

[mmenke, 2015/09/14 20:07:06]

I don't think any of the tests check that these observations are actually added,
or are combined correctly with estimates from other sources.

[tbansal1, 2015/09/14 23:46:56]

Added test to make sure that the observation size increases.

+  }
 }
 
 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;
@@ skipping 82 matching lines @@
 
 NetworkQualityEstimator::NetworkQuality&
     NetworkQualityEstimator::NetworkQuality::
     operator=(const NetworkQuality& other) {
   rtt_ = other.rtt_;
   downstream_throughput_kbps_ = other.downstream_throughput_kbps_;
   return *this;
 }
 
 }  // namespace net