Record NQE accuracy at main frame requests

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 139 matching lines @@
   }
   NOTREACHED();
   return net::NETWORK_QUALITY_OBSERVATION_SOURCE_TCP;
 }
 
 // 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 |actual_rtt|. The width of the intervals
+// are in exponentially increasing order.
+std::string GetHistogramSuffixActualRTT(const base::TimeDelta& actual_rtt) {
+  const float rtt_milliseconds = actual_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];
+}
+
 }  // namespace
 
 namespace net {
 
 // SocketWatcher implements SocketPerformanceWatcher, and notifies
 // NetworkQualityEstimator of various socket performance events. SocketWatcher
 // is not thread-safe.
 class NetworkQualityEstimator::SocketWatcher : public SocketPerformanceWatcher {
  public:
   SocketWatcher(
@@ skipping 119 matching lines @@
   AddDefaultEstimates();
 
   throughput_analyzer_.reset(new nqe::internal::ThroughputAnalyzer(
       base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&NetworkQualityEstimator::OnNewThroughputObservationAvailable,
                  base::Unretained(this)),
       use_localhost_requests_, use_smaller_responses_for_tests));
 
   watcher_factory_.reset(new SocketWatcherFactory(
       base::ThreadTaskRunnerHandle::Get(), weak_ptr_factory_.GetWeakPtr()));
+
+  // Record accuracy at 3 different intervals. The values used here must remain
+  // in sync with the suffixes specified in
+  // tools/metrics/histograms/histograms.xml.
+  accuracy_recording_intervals_.push_back(base::TimeDelta::FromSeconds(15));
+  accuracy_recording_intervals_.push_back(base::TimeDelta::FromSeconds(30));
+  accuracy_recording_intervals_.push_back(base::TimeDelta::FromSeconds(60));
 }
 
 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(nqe::internal::InvalidRTT(), default_observations_[i].http_rtt());
@@ skipping 115 matching lines @@
         throughput_observation);
     NotifyObserversOfThroughput(throughput_observation);
   }
 }
 
 NetworkQualityEstimator::~NetworkQualityEstimator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
+const std::vector<base::TimeDelta>&
+NetworkQualityEstimator::GetAccuracyRecordingIntervals() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return accuracy_recording_intervals_;
+}
+
 void NetworkQualityEstimator::NotifyStartTransaction(
     const URLRequest& request) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!RequestSchemeIsHTTPOrHTTPS(request))
     return;
 
   throughput_analyzer_->NotifyStartTransaction(request);
 }
 
 void NetworkQualityEstimator::NotifyHeadersReceived(const URLRequest& request) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("net"),
                "NetworkQualityEstimator::NotifyHeadersReceived");
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!RequestSchemeIsHTTPOrHTTPS(request) ||
       !RequestProvidesRTTObservation(request)) {
     return;
   }
 
-  // Update |estimated_median_network_quality_| if this is a main frame request.
+  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) {
+    last_main_frame_request_ = now;
     base::TimeDelta estimated_http_rtt;
     if (!GetHttpRTTEstimate(&estimated_http_rtt))
       estimated_http_rtt = nqe::internal::InvalidRTT();
 
+    base::TimeDelta estimated_transport_rtt;
+    if (!GetTransportRTTEstimate(&estimated_transport_rtt))
+      estimated_transport_rtt = nqe::internal::InvalidRTT();
+
     int32_t downstream_throughput_kbps;
     if (!GetDownlinkThroughputKbpsEstimate(&downstream_throughput_kbps))
       downstream_throughput_kbps = nqe::internal::kInvalidThroughput;
 
-    estimated_median_network_quality_ = nqe::internal::NetworkQuality(
-        estimated_http_rtt, nqe::internal::InvalidRTT(),
+    estimated_quality_at_last_main_frame_ = nqe::internal::NetworkQuality(
+        estimated_http_rtt, estimated_transport_rtt,
         downstream_throughput_kbps);
 
     RecordMetricsOnMainFrameRequest();
+
+    // 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::MessageLoop::current()->task_runner()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&NetworkQualityEstimator::RecordAccuracyAfterMainFrame,
+                     weak_ptr_factory_.GetWeakPtr(), measuring_delay),
+          measuring_delay);
+    }
   }
 
-  const base::TimeTicks now = tick_clock_->NowTicks();
   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() ||
       load_timing_info.receive_headers_end.is_null()) {
     return;
   }
 
   // Duration between when the resource was requested and when the response
   // headers were received.
   base::TimeDelta observed_http_rtt =
       load_timing_info.receive_headers_end - load_timing_info.send_start;
   DCHECK_GE(observed_http_rtt, base::TimeDelta());
   if (observed_http_rtt < peak_network_quality_.http_rtt()) {
     peak_network_quality_ = nqe::internal::NetworkQuality(
         observed_http_rtt, peak_network_quality_.transport_rtt(),
         peak_network_quality_.downstream_throughput_kbps());
   }
 
   RttObservation http_rtt_observation(
       observed_http_rtt, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST);
   rtt_observations_.AddObservation(http_rtt_observation);
   NotifyObserversOfRTT(http_rtt_observation);
 
   // Compare the RTT observation with the estimated value and record it.
-  if (estimated_median_network_quality_.http_rtt() !=
+  if (estimated_quality_at_last_main_frame_.http_rtt() !=
       nqe::internal::InvalidRTT()) {
     RecordHttpRTTUMA(
-        estimated_median_network_quality_.http_rtt().InMilliseconds(),
+        estimated_quality_at_last_main_frame_.http_rtt().InMilliseconds(),
         observed_http_rtt.InMilliseconds());
   }
 }
 
+void NetworkQualityEstimator::RecordAccuracyAfterMainFrame(
+    const base::TimeDelta& measuring_duration) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(0, measuring_duration.InMilliseconds() % 1000);
+  DCHECK(ContainsValue(GetAccuracyRecordingIntervals(), measuring_duration));
+
+  const base::TimeTicks now = tick_clock_->NowTicks();
+
+  // Return if the time since |last_main_frame_request_| is less than
+  // |measuring_duration|. This may happen if another main frame request started
+  // during last |measuring_duration|. Returning here ensures that we do not
+  // take inaccurate readings.
+  if (now - last_main_frame_request_ < measuring_duration)
+    return;
+
+  // Return if the time since |last_main_frame_request_| is off by a factor of
+  // 2. This can happen if the task is executed much later than its scheduled
+  // time. Returning here ensures that we do not take inaccurate readings.
+  if (now - last_main_frame_request_ > 2 * measuring_duration)
+    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)) {
+    int estimated_actual_diff_milliseconds =
+        estimated_quality_at_last_main_frame_.http_rtt().InMilliseconds() -
+        recent_http_rtt.InMilliseconds();
+
+    const std::string prefix =
+        estimated_actual_diff_milliseconds >= 0
+            ? "NQE.Accuracy.HttpRTT.EstimatedActualDiff."
+            : "NQE.Accuracy.HttpRTT.ActualEstimatedDiff.";
+
+    base::HistogramBase* histogram = base::Histogram::FactoryGet(
+        prefix + base::IntToString(measuring_duration.InSeconds()) + "." +
+            GetHistogramSuffixActualRTT(recent_http_rtt),
+        1, 10 * 1000 /* 10 seconds */, 50 /* Number of buckets */,
+        base::HistogramBase::kUmaTargetedHistogramFlag);
+    histogram->Add(std::abs(estimated_actual_diff_milliseconds));
+  }
+
+  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)) {
+    int estimated_actual_diff_milliseconds =
+        estimated_quality_at_last_main_frame_.transport_rtt().InMilliseconds() -
+        recent_transport_rtt.InMilliseconds();
+
+    const std::string prefix =
+        estimated_actual_diff_milliseconds >= 0
+            ? "NQE.Accuracy.TransportRTT.EstimatedActualDiff."
+            : "NQE.Accuracy.TransportRTT.ActualEstimatedDiff.";
+
+    base::HistogramBase* histogram = base::Histogram::FactoryGet(
+        prefix + base::IntToString(measuring_duration.InSeconds()) + "." +
+            GetHistogramSuffixActualRTT(recent_transport_rtt),
+        1, 10 * 1000 /* 10 seconds */, 50 /* Number of buckets */,
+        base::HistogramBase::kUmaTargetedHistogramFlag);
+    histogram->Add(std::abs(estimated_actual_diff_milliseconds));
+  }
+
+  // TODO(tbansal): Add histogram for downstream throughput and effective
+  // connection type.
+}
+
 void NetworkQualityEstimator::NotifyRequestCompleted(
     const URLRequest& request) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("net"),
                "NetworkQualityEstimator::NotifyRequestCompleted");
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!RequestSchemeIsHTTPOrHTTPS(request))
     return;
 
   throughput_analyzer_->NotifyRequestCompleted(request);
@@ skipping 115 matching lines @@
       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();
+  estimated_quality_at_last_main_frame_ = nqe::internal::NetworkQuality();
   throughput_analyzer_->OnConnectionTypeChanged();
   MaybeRecomputeEffectiveConnectionType();
 }
 
 void NetworkQualityEstimator::RecordMetricsOnConnectionTypeChanged() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (peak_network_quality_.http_rtt() != nqe::internal::InvalidRTT()) {
     base::HistogramBase* rtt_histogram =
         GetHistogram("FastestRTT.", current_network_id_.type, 10 * 1000);
     rtt_histogram->Add(peak_network_quality_.http_rtt().InMilliseconds());
@@ skipping 349 matching lines @@
   DCHECK(external_estimate_provider_);
 
   RecordExternalEstimateProviderMetrics(
       EXTERNAL_ESTIMATE_PROVIDER_STATUS_CALLBACK);
 
   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(),
+        RttObservation(rtt, tick_clock_->NowTicks(),
                        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(),
+            downstream_throughput_kbps, tick_clock_->NowTicks(),
             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:
@@ skipping 156 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