Add in-memory caching of network quality estimates across network changes.

net/base/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_BASE_NETWORK_QUALITY_ESTIMATOR_H_
 #define NET_BASE_NETWORK_QUALITY_ESTIMATOR_H_
 
 #include <stdint.h>
 
+#include <string>
+#include <vector>
+
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
+#include "base/memory/scoped_vector.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "net/base/network_change_notifier.h"
 
 namespace net {
 
 struct NetworkQuality;
 
 // NetworkQualityEstimator provides network quality estimates (quality of the
 // full paths to all origins that have been connected to).
@@ skipping 14 matching lines @@
   // Returns an estimate of the current network quality.
   NetworkQuality GetEstimate() const;
 
   // Notifies NetworkQualityEstimator that a response has been received.
   // |prefilter_bytes_read| is the count of the bytes received prior to
   // applying filters (e.g. decompression, SDCH) from request creation time
   // until now.
   void NotifyDataReceived(const URLRequest& request,
                           int64_t prefilter_bytes_read);
 
+ protected:
+  // Returns true if the cached network quality estimate was successfully read.
+  bool ReadCachedNetworkQualityEstimate();
+
+  // NetworkChangeNotifier::ConnectionTypeObserver implementation.
+  void OnConnectionTypeChanged(
+      NetworkChangeNotifier::ConnectionType type) override;
+
+  // Set the current network name for testing.
+  void SetCurrentNetworkNameForTests(const std::string& network_name);
+
+  // Returns the number of entries in the cache. Used only for testing.
+  size_t GetCacheSizeForTests() const;
+
  private:
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            TestPeakKbpsFastestRTTUpdates);
   FRIEND_TEST_ALL_PREFIXES(URLRequestTestHTTP, NetworkQualityEstimator);
 
+  // CachedNetworkQuality stores the quality of a previously seen network.
+  // A network is uniquely identified by a combination of |connection_type_|
+  // and |network_name_|.

[mmenke, 2015/06/08 20:34:21]

SSIDs are user-assigned, so unless GetWifiSSID() returns more than that, those
aren't unique.

Moreover, "ethernet" does not uniquely identify an ethernet network, and an
empty string does not uniquely identify anything (On platforms we can't get an
SSID on).

[tbansal1, 2015/06/09 02:23:13]

Agreed. Added more comments to make it clearer that "unique" is only
from the perspective of this algorithm.

+  class CachedNetworkQuality {
+   public:
+    CachedNetworkQuality(NetworkChangeNotifier::ConnectionType connection_type,
+                         const std::string& network_name,
+                         uint64_t median_kbps,
+                         const base::TimeDelta& median_rtt);
+
+    ~CachedNetworkQuality();
+
+    // Updates the network quality to the specified |median_kbps| and
+    // |median_rtt|.
+    void UpdateNetworkQuality(uint64_t median_kbps,
+                              const base::TimeDelta& median_rtt);
+
+    // Returns true iff the cached network matches the specified network.
+    bool MatchesNetwork(NetworkChangeNotifier::ConnectionType connection_type,
+                        const std::string& network_name) const;
+
+    // Returns the time when this cached entry was last updated.
+    base::TimeTicks last_update_time() const { return last_update_time_; }
+
+   private:
+    // Median Kbps of this cached network.
+    uint64_t median_kbps_;
+
+    // Median RTT of this cached network.
+    base::TimeDelta median_rtt_;

[mmenke, 2015/06/08 20:34:21]

Seems like we should just have a NetworkQuality object here.

[tbansal1, 2015/06/09 02:23:13]

Done.

+
+    // Time when this cache entry was last updated.
+    base::TimeTicks last_update_time_;
+
+    // Connection type of this cached network.
+    const NetworkChangeNotifier::ConnectionType connection_type_;
+
+    // Name of this cached network.
+    const std::string network_name_;
+
+    DISALLOW_COPY_AND_ASSIGN(CachedNetworkQuality);
+  };
+
   // Tiny transfer sizes may give inaccurate throughput results.
   // Minimum size of the transfer over which the throughput is computed.
   static const int kMinTransferSizeInBytes = 10000;
 
   // Minimum duration (in microseconds) of the transfer over which the
   // throughput is computed.
   static const int kMinRequestDurationMicroseconds = 1000;
 
   // Construct a NetworkQualityEstimator instance allowing for test
   // configuration.
   // Registers for network type change notifications so estimates can be kept
   // network specific.
   // |allow_local_host_requests_for_tests| should only be true when testing
   // against local HTTP server and allows the requests to local host to be
   // used for network quality estimation.
   explicit NetworkQualityEstimator(bool allow_local_host_requests_for_tests);
 
-  // NetworkChangeNotifier::ConnectionTypeObserver implementation.
-  void OnConnectionTypeChanged(
-      NetworkChangeNotifier::ConnectionType type) override;
+  // Updates the current network name to:
+  // WiFi SSID (if the user is connected to a WiFi access point and the SSID
+  // name is available), or
+  // The MCC/MNC code of the cellular carrier if the device is connected to a
+  // cellular network, or
+  // "ethernet" if the device is connected to an Ethernet network.
+  // Updates the current network name to an empty string in all other cases or
+  // if the network name is not exposed by platform APIs.
+  // Virtualized for testing.
+  virtual void UpdateCurrentNetworkName();
+
+  // Write the estimated quality of the current network to the cache.
+  void CacheNetworkQualityEstimate();
 
   // Determines if the requests to local host can be used in estimating the
   // network quality. Set to true only for tests.
   const bool allow_localhost_requests_;
 
   // Time when last connection change was observed.
   base::TimeTicks last_connection_change_;
 
   // Last value passed to |OnConnectionTypeChanged|. This indicates the
   // current connection type.
   NetworkChangeNotifier::ConnectionType current_connection_type_;
 
   // Set if any network data has been received since last connectivity change.
   bool bytes_read_since_last_connection_change_;
 
   // Fastest round-trip-time (RTT) since last connectivity change. RTT measured
   // from URLRequest creation until first byte received.
   base::TimeDelta fastest_RTT_since_last_connection_change_;
 
+  // Cache to store quality of previously seen networks.
+  ScopedVector<CachedNetworkQuality> cached_network_quality_;
+
   // Rough measurement of downlink peak Kbps witnessed since last connectivity
   // change. The accuracy is decreased by ignoring these factors:
   // 1) Multiple URLRequests can occur concurrently.
   // 2) The transfer time includes at least one RTT while no bytes are read.
   uint64_t peak_kbps_since_last_connection_change_;
 
+  // Name of the current network.
+  std::string current_network_name_;
+
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkQualityEstimator);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NETWORK_QUALITY_ESTIMATOR_H_