Store network quality samples so we can compute percentiles.

net/base/network_quality_estimator.cc

Index: net/base/network_quality_estimator.cc
diff --git a/net/base/network_quality_estimator.cc b/net/base/network_quality_estimator.cc
index 6415ee6e6d7eb36b47ab4fd568d3537283b27729..f0f4701483e71233f0d123ef91db1e729fe1aef2 100644
--- a/net/base/network_quality_estimator.cc
+++ b/net/base/network_quality_estimator.cc
@@ -15,6 +15,10 @@
 
 namespace net {
 
+// Maximum number of observations to hold in the ObservationBuffer.
+const size_t NetworkQualityEstimator::ObservationBuffer::kMaximumObservations =
+    500;
+
 NetworkQualityEstimator::NetworkQualityEstimator()
     : NetworkQualityEstimator(false) {
 }
@@ -36,10 +40,13 @@ NetworkQualityEstimator::~NetworkQualityEstimator() {
   NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
-void NetworkQualityEstimator::NotifyDataReceived(const URLRequest& request,
-                                                 int64_t prefilter_bytes_read) {
+void NetworkQualityEstimator::NotifyDataReceived(
+    const URLRequest& request,
+    int64_t cummulative_prefilter_bytes_read,

[mmenke, 2015/06/08 16:07:04]

cumulative only has one m

[tbansal1, 2015/06/08 20:27:52]

Done.

+    int64_t prefiltered_bytes_read) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK_GT(prefilter_bytes_read, 0);
+  DCHECK_GT(cummulative_prefilter_bytes_read, 0);
+  DCHECK_GT(prefiltered_bytes_read, 0);
 
   if (!request.url().is_valid() ||
       (!allow_localhost_requests_ && IsLocalhost(request.url().host())) ||
@@ -61,15 +68,22 @@ void NetworkQualityEstimator::NotifyDataReceived(const URLRequest& request,
   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 (cummulative_prefilter_bytes_read == prefiltered_bytes_read)
+    rtt_msec_observations_.AddObservation(request_duration.InMilliseconds());
+
   // Ignore tiny transfers which will not produce accurate rates.
   // Ignore short duration transfers.
-  if (prefilter_bytes_read >= kMinTransferSizeInBytes &&
+  if (cummulative_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());
+    uint64_t kbps =
+        static_cast<uint64_t>(cummulative_prefilter_bytes_read * 8 * 1000 /
+                              request_duration.InMicroseconds());
     if (kbps > peak_kbps_since_last_connection_change_)
       peak_kbps_since_last_connection_change_ = kbps;
+
+    kbps_observations_.AddObservation(kbps);

[mmenke, 2015/06/08 17:30:16]

AddObservation takes an int, not a uint64.  Should fix that in this CL (Suggest
just using ints, with a cap of max int)

[tbansal1, 2015/06/08 20:27:52]

Changed to int32_t. Thats what histogram uses:
https://code.google.com/p/chromium/codesearch#chromium/src/base/metrics/histo...

Added check for value <0 in AddObservation()

   }
 }
 
@@ -162,19 +176,42 @@ void NetworkQualityEstimator::OnConnectionTypeChanged(
   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);
+  if (!bytes_read_since_last_connection_change_)
+    return NetworkQuality(base::TimeDelta(), 0, 0.0);
+  if (!peak_kbps_since_last_connection_change_)
+    return NetworkQuality(fastest_RTT_since_last_connection_change_, 0, 0.0);
+  return NetworkQuality(fastest_RTT_since_last_connection_change_,
+                        peak_kbps_since_last_connection_change_, 0.0);
+}
+
+NetworkQualityEstimator::Observation::Observation(int value,
+                                                  base::TimeTicks timestamp)
+    : value(value), timestamp(timestamp) {
+  DCHECK_GE(value, 0);
+}
+
+NetworkQualityEstimator::Observation::~Observation() {
+}
+
+NetworkQualityEstimator::ObservationBuffer::ObservationBuffer() {
+  static_assert(kMaximumObservations > 0U,
+                "Minimum size of observation buffer must be > 0");
+}
+
+NetworkQualityEstimator::ObservationBuffer::~ObservationBuffer() {
+}
+
+void NetworkQualityEstimator::ObservationBuffer::AddObservation(int value) {
+  DCHECK_LE(observations_.size(), kMaximumObservations);
+  // Pop the oldest element if the buffer is already full.
+  if (observations_.size() == kMaximumObservations)
+    observations_.pop_front();
+
+  observations_.push_back(Observation(value, base::TimeTicks::Now()));
+  DCHECK_LE(observations_.size(), kMaximumObservations);
 }
 
 }  // namespace net