Factor out NetworkID and caching mechanism from n_q_e.{h,cc}

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 289 matching lines @@
           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_(
-          NetworkID(NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN,
-                    std::string())),
+      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_(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,
                 "Default half life duration must be > 0");
-  static_assert(kMaximumNetworkQualityCacheSize > 0,
-                "Size of the network quality cache must be > 0");
-  // This limit should not be increased unless the logic for removing the
-  // oldest cache entry is rewritten to use a doubly-linked-list LRU queue.
-  static_assert(kMaximumNetworkQualityCacheSize <= 10,
-                "Size of the network quality cache must <= 10");
   // 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 571 matching lines @@
                             EXTERNAL_ESTIMATE_PROVIDER_STATUS_BOUNDARY);
 }
 
 void NetworkQualityEstimator::OnConnectionTypeChanged(
     NetworkChangeNotifier::ConnectionType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   RecordMetricsOnConnectionTypeChanged();
 
   // Write the estimates of the previous network to the cache.
-  CacheNetworkQualityEstimate();
+  network_quality_store_.Add(current_network_id_,
+                             nqe::internal::CachedNetworkQuality(
+                                 last_effective_connection_type_computation_,
+                                 estimated_quality_at_last_main_frame_));
 
   // Clear the local state.
   last_connection_change_ = tick_clock_->NowTicks();
   peak_network_quality_ = nqe::internal::NetworkQuality();
   downstream_throughput_kbps_observations_.Clear();
   rtt_observations_.Clear();
 
 #if defined(OS_ANDROID)
   if (NetworkChangeNotifier::IsConnectionCellular(current_network_id_.type)) {
     UMA_HISTOGRAM_BOOLEAN(
@@ skipping 226 matching lines @@
 NetworkQualityEstimator::GetRecentEffectiveConnectionTypeUsingMetrics(
     const base::TimeTicks& start_time,
     NetworkQualityEstimator::MetricUsage http_rtt_metric,
     NetworkQualityEstimator::MetricUsage transport_rtt_metric,
     NetworkQualityEstimator::MetricUsage downstream_throughput_kbps_metric)
     const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If the device is currently offline, then return
   // EFFECTIVE_CONNECTION_TYPE_OFFLINE.
-  if (GetCurrentNetworkID().type == NetworkChangeNotifier::CONNECTION_NONE)
+  if (current_network_id_.type == NetworkChangeNotifier::CONNECTION_NONE)
     return EFFECTIVE_CONNECTION_TYPE_OFFLINE;
 
   base::TimeDelta http_rtt = nqe::internal::InvalidRTT();
   if (http_rtt_metric != NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
       !GetRecentHttpRTTMedian(start_time, &http_rtt)) {
     http_rtt = nqe::internal::InvalidRTT();
   }
 
   base::TimeDelta transport_rtt = nqe::internal::InvalidRTT();
   if (transport_rtt_metric !=
@@ skipping 164 matching lines @@
   // thus a higher percentile throughput will be faster than a lower one.
   int32_t kbps = nqe::internal::kInvalidThroughput;
   if (!downstream_throughput_kbps_observations_.GetPercentile(
           start_time, &kbps, 100 - percentile,
           std::vector<NetworkQualityObservationSource>())) {
     return nqe::internal::kInvalidThroughput;
   }
   return kbps;
 }
 
-NetworkQualityEstimator::NetworkID
-NetworkQualityEstimator::GetCurrentNetworkID() const {
+nqe::internal::NetworkID NetworkQualityEstimator::GetCurrentNetworkID() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(tbansal): crbug.com/498068 Add NetworkQualityEstimatorAndroid class
   // that overrides this method on the Android platform.
 
   // It is possible that the connection type changed between when
   // GetConnectionType() was called and when the API to determine the
   // network name was called. Check if that happened and retry until the
   // connection type stabilizes. This is an imperfect solution but should
   // capture majority of cases, and should not significantly affect estimates
   // (that are approximate to begin with).
   while (true) {
-    NetworkQualityEstimator::NetworkID network_id(
+    nqe::internal::NetworkID network_id(
         NetworkChangeNotifier::GetConnectionType(), std::string());
 
     switch (network_id.type) {
       case NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN:
       case NetworkChangeNotifier::ConnectionType::CONNECTION_NONE:
       case NetworkChangeNotifier::ConnectionType::CONNECTION_BLUETOOTH:
       case NetworkChangeNotifier::ConnectionType::CONNECTION_ETHERNET:
         break;
       case NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI:
 #if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_CHROMEOS) || \
@@ skipping 15 matching lines @@
 
     if (network_id.type == NetworkChangeNotifier::GetConnectionType())
       return network_id;
   }
   NOTREACHED();
 }
 
 bool NetworkQualityEstimator::ReadCachedNetworkQualityEstimate() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // If the network name is unavailable, caching should not be performed.
-  if (current_network_id_.id.empty())
+  nqe::internal::CachedNetworkQuality cached_network_quality;
+
+  const bool cached_estimate_available = network_quality_store_.GetById(
+      current_network_id_, &cached_network_quality);
+  UMA_HISTOGRAM_BOOLEAN("NQE.CachedNetworkQualityAvailable",
+                        cached_estimate_available);
+
+  if (!cached_estimate_available)
     return false;
 
-  CachedNetworkQualities::const_iterator it =
-      cached_network_qualities_.find(current_network_id_);
+  const base::TimeTicks now = tick_clock_->NowTicks();
 
-  if (it == cached_network_qualities_.end())
-    return false;
-
-  nqe::internal::NetworkQuality network_quality(it->second.network_quality());
-
-  const base::TimeTicks now = tick_clock_->NowTicks();
-  bool read_cached_estimate = false;
-
-  if (network_quality.downstream_throughput_kbps() !=
+  if (cached_network_quality.network_quality().downstream_throughput_kbps() !=
       nqe::internal::kInvalidThroughput) {
-    read_cached_estimate = true;
     ThroughputObservation througphput_observation(
-        network_quality.downstream_throughput_kbps(), now,
-        NETWORK_QUALITY_OBSERVATION_SOURCE_CACHED_ESTIMATE);
+        cached_network_quality.network_quality().downstream_throughput_kbps(),
+        now, NETWORK_QUALITY_OBSERVATION_SOURCE_CACHED_ESTIMATE);
     downstream_throughput_kbps_observations_.AddObservation(
         througphput_observation);
     NotifyObserversOfThroughput(througphput_observation);
   }
 
-  if (network_quality.http_rtt() != nqe::internal::InvalidRTT()) {
-    read_cached_estimate = true;
+  if (cached_network_quality.network_quality().http_rtt() !=
+      nqe::internal::InvalidRTT()) {
     RttObservation rtt_observation(
-        network_quality.http_rtt(), now,
+        cached_network_quality.network_quality().http_rtt(), now,
         NETWORK_QUALITY_OBSERVATION_SOURCE_CACHED_ESTIMATE);
     rtt_observations_.AddObservation(rtt_observation);
     NotifyObserversOfRTT(rtt_observation);
   }
-
-  return read_cached_estimate;
+  return true;
 }
 
 void NetworkQualityEstimator::OnUpdatedEstimateAvailable(
     const base::TimeDelta& rtt,
     int32_t downstream_throughput_kbps,
     int32_t upstream_throughput_kbps) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(external_estimate_provider_);
 
   RecordExternalEstimateProviderMetrics(
@@ skipping 70 matching lines @@
 void NetworkQualityEstimator::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   DCHECK(thread_checker_.CalledOnValidThread());
   tick_clock_ = std::move(tick_clock);
 }
 
 double NetworkQualityEstimator::RandDouble() const {
   return base::RandDouble();
 }
 
-void NetworkQualityEstimator::CacheNetworkQualityEstimate() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK_LE(cached_network_qualities_.size(),
-            static_cast<size_t>(kMaximumNetworkQualityCacheSize));
-
-  // If the network name is unavailable, caching should not be performed.
-  if (current_network_id_.id.empty())
-    return;
-
-  base::TimeDelta http_rtt = nqe::internal::InvalidRTT();
-  int32_t downlink_throughput_kbps = nqe::internal::kInvalidThroughput;
-
-  if (!GetHttpRTTEstimate(&http_rtt) ||
-      !GetDownlinkThroughputKbpsEstimate(&downlink_throughput_kbps)) {
-    return;
-  }
-
-  // |transport_rtt| is currently not cached.
-  nqe::internal::NetworkQuality network_quality = nqe::internal::NetworkQuality(
-      http_rtt, nqe::internal::InvalidRTT() /* transport_rtt */,
-      downlink_throughput_kbps);
-
-  if (cached_network_qualities_.size() == kMaximumNetworkQualityCacheSize) {
-    // Remove the oldest entry.
-    CachedNetworkQualities::iterator oldest_entry_iterator =
-        cached_network_qualities_.begin();
-
-    for (CachedNetworkQualities::iterator it =
-             cached_network_qualities_.begin();
-         it != cached_network_qualities_.end(); ++it) {
-      if ((it->second).OlderThan(oldest_entry_iterator->second))
-        oldest_entry_iterator = it;
-    }
-    cached_network_qualities_.erase(oldest_entry_iterator);
-  }
-  DCHECK_LT(cached_network_qualities_.size(),
-            static_cast<size_t>(kMaximumNetworkQualityCacheSize));
-
-  cached_network_qualities_.insert(
-      std::make_pair(current_network_id_,
-                     nqe::internal::CachedNetworkQuality(network_quality)));
-  DCHECK_LE(cached_network_qualities_.size(),
-            static_cast<size_t>(kMaximumNetworkQualityCacheSize));
-}
-
 void NetworkQualityEstimator::OnUpdatedRTTAvailable(
     SocketPerformanceWatcherFactory::Protocol protocol,
     const base::TimeDelta& rtt) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(nqe::internal::InvalidRTT(), rtt);
 
   RttObservation observation(rtt, tick_clock_->NowTicks(),
                              ProtocolSourceToObservationSource(protocol));
   NotifyObserversOfRTT(observation);
   rtt_observations_.AddObservation(observation);
@@ skipping 77 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