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

net/nqe/network_quality_estimator.h

 // 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.
 
 #ifndef NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_
 #define NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
-#include <tuple>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "net/base/network_change_notifier.h"
 #include "net/nqe/cached_network_quality.h"
 #include "net/nqe/external_estimate_provider.h"
+#include "net/nqe/network_id.h"
 #include "net/nqe/network_quality.h"
 #include "net/nqe/network_quality_observation.h"
 #include "net/nqe/network_quality_observation_source.h"
+#include "net/nqe/network_quality_store.h"
 #include "net/nqe/observation_buffer.h"
 #include "net/socket/socket_performance_watcher_factory.h"
 
 namespace base {
 class TickClock;
 }  // namespace base
 
 namespace net {
 
 namespace nqe {
@@ skipping 196 matching lines @@
   // Allows the responses smaller than |kMinTransferSizeInBits| to be used for
   // network quality estimation.
   void SetUseSmallResponsesForTesting(bool use_small_responses);
 
   // Reports |effective_connection_type| to all
   // EffectiveConnectionTypeObservers.
   void ReportEffectiveConnectionTypeForTesting(
       EffectiveConnectionType effective_connection_type);
 
  protected:
-  // NetworkID is used to uniquely identify a network.
-  // For the purpose of network quality estimation and caching, a network is
-  // uniquely identified by a combination of |type| and
-  // |id|. This approach is unable to distinguish networks with
-  // same name (e.g., different Wi-Fi networks with same SSID).
-  // This is a protected member to expose it to tests.
-  struct NET_EXPORT_PRIVATE NetworkID {
-    NetworkID(NetworkChangeNotifier::ConnectionType type, const std::string& id)
-        : type(type), id(id) {}
-    NetworkID(const NetworkID& other) : type(other.type), id(other.id) {}
-    ~NetworkID() {}
-
-    NetworkID& operator=(const NetworkID& other) {
-      type = other.type;
-      id = other.id;
-      return *this;
-    }
-
-    // Overloaded because NetworkID is used as key in a map.
-    bool operator<(const NetworkID& other) const {
-      return std::tie(type, id) < std::tie(other.type, other.id);
-    }
-
-    // Connection type of the network.
-    NetworkChangeNotifier::ConnectionType type;
-
-    // Name of this network. This is set to:
-    // - Wi-Fi SSID if the device is connected to a Wi-Fi access point and the
-    //   SSID name is available, or
-    // - MCC/MNC code of the cellular carrier if the device is connected to a
-    //   cellular network, or
-    // - "Ethernet" in case the device is connected to ethernet.
-    // - An empty string in all other cases or if the network name is not
-    //   exposed by platform APIs.
-    std::string id;
-  };
-
-  // Returns true if the cached network quality estimate was successfully read.
-  bool ReadCachedNetworkQualityEstimate();
-
   // NetworkChangeNotifier::ConnectionTypeObserver implementation:
   void OnConnectionTypeChanged(
       NetworkChangeNotifier::ConnectionType type) override;
 
   // ExternalEstimateProvider::UpdatedEstimateObserver implementation.
   void OnUpdatedEstimateAvailable(const base::TimeDelta& rtt,
                                   int32_t downstream_throughput_kbps,
                                   int32_t upstream_throughput_kbps) override;
 
   // Returns true if the RTT is available and sets |rtt| to the RTT estimated at
@@ skipping 57 matching lines @@
   virtual double RandDouble() const;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, StoreObservations);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestAddObservation);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, ObtainOperatingParams);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            ObtainAlgorithmToUseFromParams);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, HalfLifeParam);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, ComputedPercentiles);
-  FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestCaching);
-  FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
-                           TestLRUCacheMaximumSize);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestGetMetricsSince);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            TestExternalEstimateProviderMergeEstimates);
 
   // Value of round trip time observations is in base::TimeDelta.
   typedef nqe::internal::Observation<base::TimeDelta> RttObservation;
   typedef nqe::internal::ObservationBuffer<base::TimeDelta>
       RttObservationBuffer;
 
   // Value of throughput observations is in kilobits per second.
   typedef nqe::internal::Observation<int32_t> ThroughputObservation;
   typedef nqe::internal::ObservationBuffer<int32_t> ThroughputObservationBuffer;
 
-  // This does not use a unordered_map or hash_map for code simplicity (key just
-  // implements operator<, rather than hash and equality) and because the map is
-  // tiny.
-  typedef std::map<NetworkID, nqe::internal::CachedNetworkQuality>
-      CachedNetworkQualities;
-
   // Algorithms supported by network quality estimator for computing effective
   // connection type.
   enum class EffectiveConnectionTypeAlgorithm {
     HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT = 0,
     TRANSPORT_RTT_OR_DOWNSTREAM_THROUGHOUT,
     EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST
   };
 
   // Defines how a metric (e.g, transport RTT) should be used when computing
   // the effective connection type.
@@ skipping 22 matching lines @@
           EffectiveConnectionTypeAlgorithm::HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT;
 
   // Minimum valid value of the variation parameter that holds RTT (in
   // milliseconds) values.
   static const int kMinimumRTTVariationParameterMsec = 1;
 
   // Minimum valid value of the variation parameter that holds throughput (in
   // kilobits per second) values.
   static const int kMinimumThroughputVariationParameterKbps = 1;
 
-  // Maximum size of the cache that holds network quality estimates.
-  // Smaller size may reduce the cache hit rate due to frequent evictions.
-  // Larger size may affect performance.
-  static const size_t kMaximumNetworkQualityCacheSize = 10;
-
   // Returns the RTT value to be used when the valid RTT is unavailable. Readers
   // should discard RTT if it is set to the value returned by |InvalidRTT()|.
   static const base::TimeDelta InvalidRTT();
 
   // Records UMA when there is a change in connection type.
   void RecordMetricsOnConnectionTypeChanged() const;
 
   // Records UMA on whether the NetworkID was available or not. Called right
   // after a network change event.
   void RecordNetworkIDAvailability() const;
@@ skipping 38 matching lines @@
       const std::vector<NetworkQualityObservationSource>&
           disallowed_observation_sources,
       const base::TimeTicks& start_time,
       int percentile) const;
   int32_t GetDownlinkThroughputKbpsEstimateInternal(
       const base::TimeTicks& start_time,
       int percentile) const;
 
   // Returns the current network ID checking by calling the platform APIs.
   // Virtualized for testing.
-  virtual NetworkID GetCurrentNetworkID() const;
-
-  // Writes the estimated quality of the current network to the cache.
-  void CacheNetworkQualityEstimate();
+  virtual nqe::internal::NetworkID GetCurrentNetworkID() const;
 
   void NotifyObserversOfRTT(const RttObservation& observation);
 
   void NotifyObserversOfThroughput(const ThroughputObservation& observation);
 
   // Returns true only if the |request| can be used for RTT estimation.
   bool RequestProvidesRTTObservation(const URLRequest& request) const;
 
   // Recomputes effective connection type, if it was computed more than the
   // specified duration ago, or if there has been a connection change recently.
@@ skipping 35 matching lines @@
     EXTERNAL_ESTIMATE_PROVIDER_STATUS_CALLBACK,
     EXTERNAL_ESTIMATE_PROVIDER_STATUS_RTT_AVAILABLE,
     EXTERNAL_ESTIMATE_PROVIDER_STATUS_DOWNLINK_BANDWIDTH_AVAILABLE,
     EXTERNAL_ESTIMATE_PROVIDER_STATUS_BOUNDARY
   };
 
   // Records the metrics related to external estimate provider.
   void RecordExternalEstimateProviderMetrics(
       NQEExternalEstimateProviderStatus status) const;
 
+  // Returns true if the cached network quality estimate was successfully read.
+  bool ReadCachedNetworkQualityEstimate();
+
   // Records a correlation metric that can be used for computing the correlation
   // between HTTP-layer RTT, transport-layer RTT, throughput and the time
   // taken to complete |request|.
   void RecordCorrelationMetric(const URLRequest& request) const;
 
   // Returns true if transport RTT should be used for computing the effective
   // connection type.
   bool UseTransportRTT() const;
 
   // Determines if the requests to local host can be used in estimating the
@@ skipping 25 matching lines @@
   base::TimeTicks last_effective_connection_type_computation_;
 
   // Intervals after the main frame request arrives at which accuracy of network
   // quality prediction is recorded.
   std::vector<base::TimeDelta> accuracy_recording_intervals_;
 
   // Time when last connection change was observed.
   base::TimeTicks last_connection_change_;
 
   // ID of the current network.
-  NetworkID current_network_id_;
+  nqe::internal::NetworkID current_network_id_;
 
   // Peak network quality (fastest round-trip-time (RTT) and highest
   // downstream throughput) measured since last connectivity change. RTT is
   // measured from time the request is sent until the first byte received.
   // The accuracy is decreased by ignoring these factors:
   // 1) Multiple URLRequests can occur concurrently.
   // 2) Includes server processing time.
   nqe::internal::NetworkQuality peak_network_quality_;
 
-  // Cache that stores quality of previously seen networks.
-  CachedNetworkQualities cached_network_qualities_;
-
   // Buffer that holds throughput observations (in kilobits per second) sorted
   // by timestamp.
   ThroughputObservationBuffer downstream_throughput_kbps_observations_;
 
   // Buffer that holds RTT observations sorted by timestamp.
   RttObservationBuffer rtt_observations_;
 
   // Default network quality observations obtained from the network quality
   // estimator field trial parameters. The observations are indexed by
   // ConnectionType.
@@ skipping 46 matching lines @@
   int32_t min_signal_strength_since_connection_change_;
   int32_t max_signal_strength_since_connection_change_;
 
   // It is costlier to add values to a sparse histogram. So, the correlation UMA
   // is recorded with |correlation_uma_logging_probability_| since recording it
   // in a sparse histogram for each request is unnecessary and cost-prohibitive.
   // e.g., if it is 0.0, then the UMA will never be recorded. On the other hand,
   // if it is 1.0, then it will be recorded for all valid HTTP requests.
   const double correlation_uma_logging_probability_;
 
+  // Stores the qualities of different networks.
+  nqe::internal::NetworkQualityStore network_quality_store_;
+
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<NetworkQualityEstimator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkQualityEstimator);
 };
 
 }  // namespace net
 
 #endif  // NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_