Expose RTT and throughput estimates from Cronet

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 391 matching lines @@
               0.0)),
       forced_effective_connection_type_set_(
           !GetStringValueForVariationParamWithDefaultValue(
                variation_params,
                "force_effective_connection_type",
                "")
                .empty()),
       weak_ptr_factory_(this) {
   static_assert(kDefaultHalfLifeSeconds > 0,
                 "Default half life duration must be > 0");
+  static_assert(kMinimumRTTVariationParameterMsec > 0 &&
+                    kMinimumRTTVariationParameterMsec >
+                        nqe::internal::INVALID_RTT_THROUGHPUT,
+                "kMinimumRTTVariationParameterMsec is set incorrectly");
+  static_assert(kMinimumThroughputVariationParameterKbps > 0 &&
+                    kMinimumThroughputVariationParameterKbps >
+                        nqe::internal::kInvalidThroughput,
+                "kMinimumThroughputVariationParameterKbps is set incorrectly");
   // None of the algorithms can have an empty name.
   DCHECK(algorithm_name_to_enum_.end() ==
          algorithm_name_to_enum_.find(std::string()));
 
   DCHECK_EQ(algorithm_name_to_enum_.size(),
             static_cast<size_t>(EffectiveConnectionTypeAlgorithm::
                                     EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST));
   DCHECK_NE(EffectiveConnectionTypeAlgorithm::
                 EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST,
             effective_connection_type_algorithm_);
@@ skipping 285 matching lines @@
       load_timing_info.receive_headers_end.is_null()) {
     return;
   }
   DCHECK(!request.response_info().was_cached);
 
   // 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()) {
+  if (observed_http_rtt < peak_network_quality_.http_rtt() ||
+      peak_network_quality_.http_rtt() == nqe::internal::InvalidRTT()) {
     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);
 }
@@ skipping 968 matching lines @@
 
 void NetworkQualityEstimator::OnNewThroughputObservationAvailable(
     int32_t downstream_kbps) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (downstream_kbps == 0)
     return;
 
   DCHECK_NE(nqe::internal::kInvalidThroughput, downstream_kbps);
 
-  if (downstream_kbps > peak_network_quality_.downstream_throughput_kbps()) {
+  if (downstream_kbps > peak_network_quality_.downstream_throughput_kbps() ||
+      peak_network_quality_.downstream_throughput_kbps() ==
+          nqe::internal::kInvalidThroughput) {
     peak_network_quality_ = nqe::internal::NetworkQuality(
         peak_network_quality_.http_rtt(), peak_network_quality_.transport_rtt(),
         downstream_kbps);
   }
   ThroughputObservation throughput_observation(
       downstream_kbps, tick_clock_->NowTicks(),
       NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST);
   downstream_throughput_kbps_observations_.AddObservation(
       throughput_observation);
   NotifyObserversOfThroughput(throughput_observation);
@@ skipping 64 matching lines @@
 }
 
 void NetworkQualityEstimator::RemoveNetworkQualitiesCacheObserver(
     nqe::internal::NetworkQualityStore::NetworkQualitiesCacheObserver*
         observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   network_quality_store_->RemoveNetworkQualitiesCacheObserver(observer);
 }
 
 }  // namespace net