NQE: Add accuracy histogram for 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>
 #include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/network_interfaces.h"
 #include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
 #include "net/nqe/socket_watcher_factory.h"
@@ skipping 161 matching lines @@
 }
 
 // Returns true if the scheme of the |request| is either HTTP or HTTPS.
 bool RequestSchemeIsHTTPOrHTTPS(const net::URLRequest& request) {
   return request.url().is_valid() && request.url().SchemeIsHTTPOrHTTPS();
 }
 
 // Returns the suffix of the histogram that should be used for recording the
 // accuracy when the observed RTT is |observed_rtt|. The width of the intervals
 // are in exponentially increasing order.
-std::string GetHistogramSuffixObservedRTT(const base::TimeDelta& observed_rtt) {
+const char* GetHistogramSuffixObservedRTT(const base::TimeDelta& observed_rtt) {
   const float rtt_milliseconds = observed_rtt.InMillisecondsF();
   DCHECK_GE(rtt_milliseconds, 0);
 
   // The values here should remain synchronized with the suffixes specified in
   // histograms.xml.
   static const char* const kSuffixes[] = {
       "0_20",     "20_60",     "60_140",    "140_300",      "300_620",
       "620_1260", "1260_2540", "2540_5100", "5100_Infinity"};
   for (size_t i = 0; i < arraysize(kSuffixes) - 1; ++i) {
     if (rtt_milliseconds <= static_cast<float>((20 * (2 << i) - 20)))
       return kSuffixes[i];
   }
   return kSuffixes[arraysize(kSuffixes) - 1];
 }
 
 // Returns the suffix of the histogram that should be used for recording the
 // accuracy when the observed throughput in kilobits per second is
 // |observed_throughput_kbps|. The width of the intervals are in exponentially
 // increasing order.
-std::string GetHistogramSuffixObservedThroughput(
+const char* GetHistogramSuffixObservedThroughput(
     const int32_t& observed_throughput_kbps) {
   DCHECK_GE(observed_throughput_kbps, 0);
 
   // The values here should remain synchronized with the suffixes specified in
   // histograms.xml.
   static const char* const kSuffixes[] = {
       "0_20",     "20_60",     "60_140",    "140_300",      "300_620",
       "620_1260", "1260_2540", "2540_5100", "5100_Infinity"};
   for (size_t i = 0; i < arraysize(kSuffixes) - 1; ++i) {
     if (observed_throughput_kbps <= static_cast<float>((20 * (2 << i) - 20)))
@@ skipping 28 matching lines @@
   // kBitsPerMetric.
   static const int32_t kLargestValuePossible = (1 << kBitsPerMetric) - 1;
   if (metric > kLargestValuePossible) {
     // Fit |metric| in kBitsPerMetric by clamping it down.
     metric = kLargestValuePossible;
   }
   DCHECK_EQ(0, metric >> kBitsPerMetric);
   return metric;
 }
 
+void RecordRTTAccuracy(const char* prefix,
+                       int32_t metric,
+                       base::TimeDelta measuring_duration,
+                       base::TimeDelta observed_rtt) {
+  const std::string histogram_name =
+      base::StringPrintf("%s.EstimatedObservedDiff.%s.%d.%s", prefix,
+                         metric >= 0 ? "Positive" : "Negative",
+                         static_cast<int32_t>(measuring_duration.InSeconds()),
+                         GetHistogramSuffixObservedRTT(observed_rtt));
+
+  base::HistogramBase* histogram = base::Histogram::FactoryGet(
+      histogram_name, 1, 10 * 1000 /* 10 seconds */, 50 /* Number of buckets */,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  histogram->Add(std::abs(metric));
+}
+
+void RecordThroughputAccuracy(const char* prefix,
+                              int32_t metric,
+                              base::TimeDelta measuring_duration,
+                              int32_t observed_throughput_kbps) {
+  const std::string histogram_name = base::StringPrintf(
+      "%s.EstimatedObservedDiff.%s.%d.%s", prefix,
+      metric >= 0 ? "Positive" : "Negative",
+      static_cast<int32_t>(measuring_duration.InSeconds()),
+      GetHistogramSuffixObservedThroughput(observed_throughput_kbps));
+
+  base::HistogramBase* histogram = base::Histogram::FactoryGet(
+      histogram_name, 1, 1000 * 1000 /* 1 Gbps */, 50 /* Number of buckets */,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  histogram->Add(std::abs(metric));
+}
+
+void RecordEffectiveConnectionTypeAccuracy(
+    const char* prefix,
+    int32_t metric,
+    base::TimeDelta measuring_duration,
+    net::NetworkQualityEstimator::EffectiveConnectionType
+        observed_effective_connection_type) {
+  const std::string histogram_name = base::StringPrintf(
+      "%s.EstimatedObservedDiff.%s.%d.%s", prefix,
+      metric >= 0 ? "Positive" : "Negative",
+      static_cast<int32_t>(measuring_duration.InSeconds()),
+      net::NetworkQualityEstimator::GetNameForEffectiveConnectionType(
+          observed_effective_connection_type));
+
+  base::HistogramBase* histogram = base::Histogram::FactoryGet(
+      histogram_name, 0,
+      net::NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_LAST,
+      net::NetworkQualityEstimator::
+          EFFECTIVE_CONNECTION_TYPE_LAST /* Number of buckets */,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  histogram->Add(std::abs(metric));
+}
+
 }  // namespace
 
 namespace net {
 
 NetworkQualityEstimator::NetworkQualityEstimator(
     std::unique_ptr<ExternalEstimateProvider> external_estimates_provider,
     const std::map<std::string, std::string>& variation_params)
     : NetworkQualityEstimator(std::move(external_estimates_provider),
                               variation_params,
                               false,
@@ skipping 282 matching lines @@
     if (!GetDownlinkThroughputKbpsEstimate(&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);
     effective_connection_type_at_last_main_frame_ =
         GetEffectiveConnectionType();
 
     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 :
          GetAccuracyRecordingIntervals()) {
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE,
@@ skipping 59 matching lines @@
     return;
 
   base::TimeDelta recent_http_rtt;
   if (estimated_quality_at_last_main_frame_.http_rtt() !=
           nqe::internal::InvalidRTT() &&
       GetRecentHttpRTTMedian(last_main_frame_request_, &recent_http_rtt)) {
     const int estimated_observed_diff_milliseconds =
         estimated_quality_at_last_main_frame_.http_rtt().InMilliseconds() -
         recent_http_rtt.InMilliseconds();
 
-    const std::string sign_suffix =
-        estimated_observed_diff_milliseconds >= 0 ? "Positive." : "Negative.";
-
-    base::HistogramBase* histogram = base::Histogram::FactoryGet(
-        "NQE.Accuracy.HttpRTT.EstimatedObservedDiff." + sign_suffix +
-            base::IntToString(measuring_duration.InSeconds()) + "." +
-            GetHistogramSuffixObservedRTT(recent_http_rtt),
-        1, 10 * 1000 /* 10 seconds */, 50 /* Number of buckets */,
-        base::HistogramBase::kUmaTargetedHistogramFlag);
-    histogram->Add(std::abs(estimated_observed_diff_milliseconds));
+    RecordRTTAccuracy("NQE.Accuracy.HttpRTT",
+                      estimated_observed_diff_milliseconds, measuring_duration,
+                      recent_http_rtt);
   }
 
   base::TimeDelta recent_transport_rtt;
   if (estimated_quality_at_last_main_frame_.transport_rtt() !=
           nqe::internal::InvalidRTT() &&
       GetRecentTransportRTTMedian(last_main_frame_request_,
                                   &recent_transport_rtt)) {
     const int estimated_observed_diff_milliseconds =
         estimated_quality_at_last_main_frame_.transport_rtt().InMilliseconds() -
         recent_transport_rtt.InMilliseconds();
 
-    const std::string sign_suffix =
-        estimated_observed_diff_milliseconds >= 0 ? "Positive." : "Negative.";
-
-    base::HistogramBase* histogram = base::Histogram::FactoryGet(
-        "NQE.Accuracy.TransportRTT.EstimatedObservedDiff." + sign_suffix +
-            base::IntToString(measuring_duration.InSeconds()) + "." +
-            GetHistogramSuffixObservedRTT(recent_transport_rtt),
-        1, 10 * 1000 /* 10 seconds */, 50 /* Number of buckets */,
-        base::HistogramBase::kUmaTargetedHistogramFlag);
-    histogram->Add(std::abs(estimated_observed_diff_milliseconds));
+    RecordRTTAccuracy("NQE.Accuracy.TransportRTT",
+                      estimated_observed_diff_milliseconds, measuring_duration,
+                      recent_transport_rtt);
   }
 
   int32_t recent_downstream_throughput_kbps;
   if (estimated_quality_at_last_main_frame_.downstream_throughput_kbps() !=
           nqe::internal::kInvalidThroughput &&
       GetRecentMedianDownlinkThroughputKbps(
           last_main_frame_request_, &recent_downstream_throughput_kbps)) {
     const int estimated_observed_diff =
         estimated_quality_at_last_main_frame_.downstream_throughput_kbps() -
         recent_downstream_throughput_kbps;
 
-    const std::string sign_suffix =
-        estimated_observed_diff >= 0 ? "Positive." : "Negative.";
-
-    base::HistogramBase* histogram = base::Histogram::FactoryGet(
-        "NQE.Accuracy.DownstreamThroughputKbps.EstimatedObservedDiff." +
-            sign_suffix + base::IntToString(measuring_duration.InSeconds()) +
-            "." + GetHistogramSuffixObservedThroughput(
-                      recent_downstream_throughput_kbps),
-        1, 1000 * 1000 /* 1 Gbps */, 50 /* Number of buckets */,
-        base::HistogramBase::kUmaTargetedHistogramFlag);
-    histogram->Add(std::abs(estimated_observed_diff));
+    RecordThroughputAccuracy("NQE.Accuracy.DownstreamThroughputKbps",
+                             estimated_observed_diff, measuring_duration,
+                             recent_downstream_throughput_kbps);
   }
 
   EffectiveConnectionType recent_effective_connection_type =
       GetRecentEffectiveConnectionType(last_main_frame_request_);
   if (effective_connection_type_at_last_main_frame_ !=
           EFFECTIVE_CONNECTION_TYPE_UNKNOWN &&
       recent_effective_connection_type != EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {
     const int estimated_observed_diff =
         static_cast<int>(effective_connection_type_at_last_main_frame_) -
         static_cast<int>(recent_effective_connection_type);
 
-    const std::string sign_suffix =
-        estimated_observed_diff >= 0 ? "Positive." : "Negative.";
+    RecordEffectiveConnectionTypeAccuracy(
+        "NQE.Accuracy.EffectiveConnectionType", estimated_observed_diff,
+        measuring_duration, recent_effective_connection_type);
+  }
 
-    base::HistogramBase* histogram = base::Histogram::FactoryGet(
-        "NQE.Accuracy.EffectiveConnectionType.EstimatedObservedDiff." +
-            sign_suffix + base::IntToString(measuring_duration.InSeconds()) +
-            "." +
-            GetNameForEffectiveConnectionType(recent_effective_connection_type),
-        0, EFFECTIVE_CONNECTION_TYPE_LAST,
-        EFFECTIVE_CONNECTION_TYPE_LAST /* Number of buckets */,
-        base::HistogramBase::kUmaTargetedHistogramFlag);
-    histogram->Add(std::abs(estimated_observed_diff));
+  // Add histogram to evaluate the accuracy of the external estimate provider.
+  if (external_estimate_provider_quality_.http_rtt() !=
+          nqe::internal::InvalidRTT() &&
+      recent_http_rtt != nqe::internal::InvalidRTT()) {
+    const int estimated_observed_diff_milliseconds =
+        external_estimate_provider_quality_.http_rtt().InMilliseconds() -
+        recent_http_rtt.InMilliseconds();
+
+    RecordRTTAccuracy("NQE.ExternalEstimateProvider.RTT.Accuracy",
+                      estimated_observed_diff_milliseconds, measuring_duration,
+                      recent_http_rtt);
   }
 }
 
 void NetworkQualityEstimator::NotifyRequestCompleted(
     const URLRequest& request) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("net"),
                "NetworkQualityEstimator::NotifyRequestCompleted");
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!RequestSchemeIsHTTPOrHTTPS(request))
@@ skipping 197 matching lines @@
             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;
 
   // Update the local state as part of preparation for the new connection.
   current_network_id_ = GetCurrentNetworkID();
   RecordNetworkIDAvailability();
 
+  MaybeQueryExternalEstimateProvider();
+
+  // Read any cached estimates for the new network. If cached estimates are
+  // unavailable, add the default estimates.
+  if (!ReadCachedNetworkQualityEstimate())
+    AddDefaultEstimates();
+  estimated_quality_at_last_main_frame_ = nqe::internal::NetworkQuality();
+  throughput_analyzer_->OnConnectionTypeChanged();
+  MaybeRecomputeEffectiveConnectionType();
+  UpdateSignalStrength();
+}
+
+void NetworkQualityEstimator::MaybeQueryExternalEstimateProvider() const {
   // 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_quality_at_last_main_frame_ = nqe::internal::NetworkQuality();
-  throughput_analyzer_->OnConnectionTypeChanged();
-  MaybeRecomputeEffectiveConnectionType();
-  UpdateSignalStrength();
 }
 
 void NetworkQualityEstimator::UpdateSignalStrength() {
 #if defined(OS_ANDROID)
   int32_t signal_strength_dbm;
   if (!android::cellular_signal_strength::GetSignalStrengthDbm(
           &signal_strength_dbm)) {
     return;
   }
   min_signal_strength_since_connection_change_ = std::min(
@@ skipping 460 matching lines @@
 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);
 
+  external_estimate_provider_quality_ = nqe::internal::NetworkQuality();
+
   if (rtt > base::TimeDelta()) {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_RTT_AVAILABLE);
     UMA_HISTOGRAM_TIMES("NQE.ExternalEstimateProvider.RTT", rtt);
     rtt_observations_.AddObservation(
         RttObservation(rtt, tick_clock_->NowTicks(),
                        NETWORK_QUALITY_OBSERVATION_SOURCE_EXTERNAL_ESTIMATE));
+    external_estimate_provider_quality_.set_http_rtt(rtt);
   }
 
   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, tick_clock_->NowTicks(),
             NETWORK_QUALITY_OBSERVATION_SOURCE_EXTERNAL_ESTIMATE));
+    external_estimate_provider_quality_.set_downstream_throughput_kbps(
+        downstream_throughput_kbps);
   }
 }
 
 // static
 const char* NetworkQualityEstimator::GetNameForEffectiveConnectionType(
     EffectiveConnectionType type) {
   switch (type) {
     case EFFECTIVE_CONNECTION_TYPE_UNKNOWN:
       return "Unknown";
     case EFFECTIVE_CONNECTION_TYPE_OFFLINE:
@@ skipping 137 matching lines @@
     NotifyObserversOfEffectiveConnectionTypeChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(tbansal): Add hysteresis in the notification.
   FOR_EACH_OBSERVER(
       EffectiveConnectionTypeObserver, effective_connection_type_observer_list_,
       OnEffectiveConnectionTypeChanged(effective_connection_type_));
 }
 
 }  // namespace net