Compute effective connection type dynamically

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 345 matching lines @@
       weight_multiplier_per_second_(
           GetWeightMultiplierPerSecond(variation_params)),
       effective_connection_type_algorithm_(
           algorithm_name_to_enum_.find(GetEffectiveConnectionTypeAlgorithm(
               variation_params)) == algorithm_name_to_enum_.end()
               ? kDefaultEffectiveConnectionTypeAlgorithm
               : algorithm_name_to_enum_
                     .find(GetEffectiveConnectionTypeAlgorithm(variation_params))
                     ->second),
       tick_clock_(new base::DefaultTickClock()),
-      effective_connection_type_recomputation_interval_(
-          base::TimeDelta::FromSeconds(15)),
       last_connection_change_(tick_clock_->NowTicks()),
       current_network_id_(nqe::internal::NetworkID(
           NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN,
           std::string())),
       downstream_throughput_kbps_observations_(weight_multiplier_per_second_),
       rtt_observations_(weight_multiplier_per_second_),
       effective_connection_type_at_last_main_frame_(
           EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       external_estimate_provider_(std::move(external_estimates_provider)),
+      effective_connection_type_recomputation_interval_(
+          base::TimeDelta::FromSeconds(15)),
+      rtt_observations_size_at_last_ect_computation_(0),
+      throughput_observations_size_at_last_ect_computation_(0),
       effective_connection_type_(EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       min_signal_strength_since_connection_change_(INT32_MAX),
       max_signal_strength_since_connection_change_(INT32_MIN),
       correlation_uma_logging_probability_(
           GetDoubleValueForVariationParamWithDefaultValue(
               variation_params,
               "correlation_logging_probability",
               0.0)),
       weak_ptr_factory_(this) {
   static_assert(kDefaultHalfLifeSeconds > 0,
@@ skipping 1221 matching lines @@
 
 void NetworkQualityEstimator::MaybeRecomputeEffectiveConnectionType() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const base::TimeTicks now = tick_clock_->NowTicks();
   // Recompute effective connection type only if
   // |effective_connection_type_recomputation_interval_| has passed since it was
   // last computed or a connection change event was observed since the last
   // computation. Strict inequalities are used to ensure that effective
   // connection type is recomputed on connection change events even if the clock
-  // has not updated. Recompute the effective connection type if the effective
-  // connection type was previously unavailable. This is because the RTT
-  // observations are voluminous, so it may now be possible to compute the
-  // effective connection type.
+  // has not updated.
   if (now - last_effective_connection_type_computation_ <
           effective_connection_type_recomputation_interval_ &&
       last_connection_change_ < last_effective_connection_type_computation_ &&
-      effective_connection_type_ != EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {
+      // Recompute the effective connection type if the previously computed
+      // effective connection type was unknown.
+      effective_connection_type_ != EFFECTIVE_CONNECTION_TYPE_UNKNOWN &&
+      // Recompute the effective connection type if the number of samples
+      // available now are more than twice in count than the number of
+      // samples that were available when the effective connection type was
+      // last computed.
+      rtt_observations_size_at_last_ect_computation_ * 2 >=
+          rtt_observations_.Size() &&
+      throughput_observations_size_at_last_ect_computation_ * 2 >=
+          downstream_throughput_kbps_observations_.Size()) {
     return;
   }
 
   const EffectiveConnectionType past_type = effective_connection_type_;
   last_effective_connection_type_computation_ = now;
   effective_connection_type_ = GetEffectiveConnectionType();
 
   if (past_type != effective_connection_type_)
     NotifyObserversOfEffectiveConnectionTypeChanged();
+
+  rtt_observations_size_at_last_ect_computation_ = rtt_observations_.Size();
+  throughput_observations_size_at_last_ect_computation_ =
+      downstream_throughput_kbps_observations_.Size();
 }
 
 void NetworkQualityEstimator::
     NotifyObserversOfEffectiveConnectionTypeChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(EFFECTIVE_CONNECTION_TYPE_LAST, effective_connection_type_);
 
   // TODO(tbansal): Add hysteresis in the notification.
   FOR_EACH_OBSERVER(
       EffectiveConnectionTypeObserver, effective_connection_type_observer_list_,
       OnEffectiveConnectionTypeChanged(effective_connection_type_));
 
   // Add the estimates of the current network to the cache store.
   if (effective_connection_type_ != EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {
     network_quality_store_.Add(
         current_network_id_,
         nqe::internal::CachedNetworkQuality(
             tick_clock_->NowTicks(), estimated_quality_at_last_main_frame_,
             effective_connection_type_));
   }
 }
 
 }  // namespace net