Store network quality samples so we can compute percentiles.

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 <limits>
 #include <string>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "net/base/net_util.h"
 #include "net/base/network_quality.h"
 #include "net/url_request/url_request.h"
 #include "url/gurl.h"
 
+namespace {
+
+// Maximum number of observations that can be held in the ObservationBuffer.
+const size_t kMaximumObservationsBufferSize = 500;
+
+}  // namespace
+
 namespace net {
 
 NetworkQualityEstimator::NetworkQualityEstimator()
     : NetworkQualityEstimator(false) {
 }
 
 NetworkQualityEstimator::NetworkQualityEstimator(
     bool allow_local_host_requests_for_tests)
     : allow_localhost_requests_(allow_local_host_requests_for_tests),
       last_connection_change_(base::TimeTicks::Now()),
       current_connection_type_(NetworkChangeNotifier::GetConnectionType()),
-      bytes_read_since_last_connection_change_(false),
+      fastest_rtt_since_last_connection_change_(base::TimeDelta::Max()),
       peak_kbps_since_last_connection_change_(0) {
   static_assert(kMinRequestDurationMicroseconds > 0,
                 "Minimum request duration must be > 0");
   NetworkChangeNotifier::AddConnectionTypeObserver(this);
 }
 
 NetworkQualityEstimator::~NetworkQualityEstimator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
-void NetworkQualityEstimator::NotifyDataReceived(const URLRequest& request,
-                                                 int64_t prefilter_bytes_read) {
+void NetworkQualityEstimator::NotifyDataReceived(
+    const URLRequest& request,
+    int64_t cumulative_prefilter_bytes_read,
+    int64_t prefiltered_bytes_read) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK_GT(prefilter_bytes_read, 0);
+  DCHECK_GT(cumulative_prefilter_bytes_read, 0);
+  DCHECK_GT(prefiltered_bytes_read, 0);
 
   if (!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_) {
     return;
   }
 
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeDelta request_duration = now - request.creation_time();
   DCHECK_GE(request_duration, base::TimeDelta());
-  if (!bytes_read_since_last_connection_change_)
-    fastest_RTT_since_last_connection_change_ = request_duration;
 
-  bytes_read_since_last_connection_change_ = true;
-  if (request_duration < fastest_RTT_since_last_connection_change_)
-    fastest_RTT_since_last_connection_change_ = request_duration;
+  // Only add RTT observation if this is the first read for this response.
+  if (cumulative_prefilter_bytes_read == prefiltered_bytes_read) {
+    if (request_duration < fastest_rtt_since_last_connection_change_)
+      fastest_rtt_since_last_connection_change_ = request_duration;
+
+    rtt_msec_observations_.AddObservation(
+        Observation(request_duration.InMilliseconds(), now));
+  }
 
   // Ignore tiny transfers which will not produce accurate rates.
   // Ignore short duration transfers.
-  if (prefilter_bytes_read >= kMinTransferSizeInBytes &&
+  if (cumulative_prefilter_bytes_read >= kMinTransferSizeInBytes &&
       request_duration >=
           base::TimeDelta::FromMicroseconds(kMinRequestDurationMicroseconds)) {
-    uint64_t kbps = static_cast<uint64_t>(prefilter_bytes_read * 8 * 1000 /
-                                          request_duration.InMicroseconds());
-    if (kbps > peak_kbps_since_last_connection_change_)
-      peak_kbps_since_last_connection_change_ = kbps;
+    double kbps_f = cumulative_prefilter_bytes_read * 8.0 / 1000.0 /
+                    request_duration.InSecondsF();
+    DCHECK_GE(kbps_f, 0.0);
+
+    // Check overflow errors. This may happen if the kbpsF is more than
+    // 2 * 10^9 (= 2000 Gbps).
+    if (kbps_f >= std::numeric_limits<int32_t>::max())
+      kbps_f = std::numeric_limits<int32_t>::max() - 1;
+
+    int32_t kbps = static_cast<int32_t>(kbps_f);
+
+    if (kbps > 0) {
+      if (kbps > peak_kbps_since_last_connection_change_)
+        peak_kbps_since_last_connection_change_ = kbps;
+
+      kbps_observations_.AddObservation(Observation(kbps, now));
+    }
   }
 }
 
 void NetworkQualityEstimator::OnConnectionTypeChanged(
     NetworkChangeNotifier::ConnectionType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (bytes_read_since_last_connection_change_) {
+  if (fastest_rtt_since_last_connection_change_ != base::TimeDelta::Max()) {
     switch (current_connection_type_) {
       case NetworkChangeNotifier::CONNECTION_UNKNOWN:
         UMA_HISTOGRAM_TIMES("NQE.FastestRTT.Unknown",
-                            fastest_RTT_since_last_connection_change_);
+                            fastest_rtt_since_last_connection_change_);
         break;
       case NetworkChangeNotifier::CONNECTION_ETHERNET:
         UMA_HISTOGRAM_TIMES("NQE.FastestRTT.Ethernet",
-                            fastest_RTT_since_last_connection_change_);
+                            fastest_rtt_since_last_connection_change_);
         break;
       case NetworkChangeNotifier::CONNECTION_WIFI:
         UMA_HISTOGRAM_TIMES("NQE.FastestRTT.Wifi",
-                            fastest_RTT_since_last_connection_change_);
+                            fastest_rtt_since_last_connection_change_);
         break;
       case NetworkChangeNotifier::CONNECTION_2G:
         UMA_HISTOGRAM_TIMES("NQE.FastestRTT.2G",
-                            fastest_RTT_since_last_connection_change_);
+                            fastest_rtt_since_last_connection_change_);
         break;
       case NetworkChangeNotifier::CONNECTION_3G:
         UMA_HISTOGRAM_TIMES("NQE.FastestRTT.3G",
-                            fastest_RTT_since_last_connection_change_);
+                            fastest_rtt_since_last_connection_change_);
         break;
       case NetworkChangeNotifier::CONNECTION_4G:
         UMA_HISTOGRAM_TIMES("NQE.FastestRTT.4G",
-                            fastest_RTT_since_last_connection_change_);
+                            fastest_rtt_since_last_connection_change_);
         break;
       case NetworkChangeNotifier::CONNECTION_NONE:
         UMA_HISTOGRAM_TIMES("NQE.FastestRTT.None",
-                            fastest_RTT_since_last_connection_change_);
+                            fastest_rtt_since_last_connection_change_);
         break;
       case NetworkChangeNotifier::CONNECTION_BLUETOOTH:
         UMA_HISTOGRAM_TIMES("NQE.FastestRTT.Bluetooth",
-                            fastest_RTT_since_last_connection_change_);
+                            fastest_rtt_since_last_connection_change_);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   if (peak_kbps_since_last_connection_change_) {
     switch (current_connection_type_) {
       case NetworkChangeNotifier::CONNECTION_UNKNOWN:
@@ skipping 28 matching lines @@
         UMA_HISTOGRAM_COUNTS("NQE.PeakKbps.Bluetooth",
                              peak_kbps_since_last_connection_change_);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   last_connection_change_ = base::TimeTicks::Now();
-  bytes_read_since_last_connection_change_ = false;
   peak_kbps_since_last_connection_change_ = 0;
+  fastest_rtt_since_last_connection_change_ = base::TimeDelta::Max();
+  kbps_observations_.Clear();
+  rtt_msec_observations_.Clear();
   current_connection_type_ = type;
 }
 
-NetworkQuality NetworkQualityEstimator::GetEstimate() const {
+NetworkQuality NetworkQualityEstimator::GetPeakEstimate() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!bytes_read_since_last_connection_change_) {
-    return NetworkQuality(fastest_RTT_since_last_connection_change_, 0,
-                          peak_kbps_since_last_connection_change_, 0);
-  }
-  if (!peak_kbps_since_last_connection_change_) {
-    return NetworkQuality(fastest_RTT_since_last_connection_change_, 0.1,
-                          peak_kbps_since_last_connection_change_, 0);
-  }
-  return NetworkQuality(fastest_RTT_since_last_connection_change_, 0.1,
-                        peak_kbps_since_last_connection_change_, 0.1);
+  return NetworkQuality(fastest_rtt_since_last_connection_change_,
+                        peak_kbps_since_last_connection_change_);
+}
+
+size_t NetworkQualityEstimator::GetMaximumObservationBufferSizeForTests()
+    const {
+  return kMaximumObservationsBufferSize;
+}
+
+bool NetworkQualityEstimator::VerifyBufferSizeForTests(
+    size_t expected_size) const {
+  return kbps_observations_.Size() == expected_size &&
+         rtt_msec_observations_.Size() == expected_size;
+}
+
+NetworkQualityEstimator::Observation::Observation(int32_t value,
+                                                  base::TimeTicks timestamp)
+    : value(value), timestamp(timestamp) {
+  DCHECK_GE(value, 0);
+  DCHECK(!timestamp.is_null());
+}
+
+NetworkQualityEstimator::Observation::~Observation() {
+}
+
+NetworkQualityEstimator::ObservationBuffer::ObservationBuffer() {
+  static_assert(kMaximumObservationsBufferSize > 0U,
+                "Minimum size of observation buffer must be > 0");
+}
+
+NetworkQualityEstimator::ObservationBuffer::~ObservationBuffer() {
+}
+
+void NetworkQualityEstimator::ObservationBuffer::AddObservation(
+    const Observation& observation) {
+  DCHECK_LE(observations_.size(), kMaximumObservationsBufferSize);
+  // Evict the oldest element if the buffer is already full.
+  if (observations_.size() == kMaximumObservationsBufferSize)
+    observations_.pop_front();
+
+  observations_.push_back(observation);
+  DCHECK_LE(observations_.size(), kMaximumObservationsBufferSize);
+}
+
+size_t NetworkQualityEstimator::ObservationBuffer::Size() const {
+  return observations_.size();
+}
+
+void NetworkQualityEstimator::ObservationBuffer::Clear() {
+  observations_.clear();
+  DCHECK(observations_.empty());
 }
 
 }  // namespace net