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/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "net/base/network_change_notifier.h"
 
 namespace net {
 
 struct NetworkQuality;
 
@@ skipping 16 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 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(std::string network_name);

[bengr, 2015/05/29 17:38:10]

const std::string&

[tbansal1, 2015/05/29 19:13:36]

Done.

+
+  // Returns the number of entries in the cache. Used only for testing.
+  uint32_t GetCacheSizeForTests() const;
+
+  // 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 MCCMNC code of the cellular carrier if the device is connected to a

[bengr, 2015/05/29 17:38:10]

nit: MCC/MNC

[tbansal1, 2015/05/29 19:13:36]

Done.

+  // 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();
+
  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 combination of |connection_type_| and
+  // |network_name_|.
+  class CachedNetworkQuality {
+   public:
+    CachedNetworkQuality(NetworkChangeNotifier::ConnectionType connection_type,
+                         std::string network_name,

[bengr, 2015/05/29 17:38:10]

const std::string&

[tbansal1, 2015/05/29 19:13:36]

Done.

+                         int median_kbps,
+                         int median_rtt_milliseconds)
+        : median_kbps_(median_kbps),
+          median_rtt_milliseconds_(median_rtt_milliseconds),
+          last_updated_(base::TimeTicks::Now()),
+          connection_type_(connection_type),
+          network_name_(network_name) {
+      DCHECK_NE(network_name_, std::string());

[bengr, 2015/05/29 17:38:10]

After reading the comment for UpdateCurrentNetworkName, I thought that
network_name_ could be an empty string.

[tbansal1, 2015/05/29 19:13:37]

The current network name may be empty but in that case, we 
should not cache (because empty network name is not
distinctive enough). Added comment to explain that.

+    }
+
+    virtual ~CachedNetworkQuality() {}
+
+    void UpdateNetworkQuality(int updated_median_kbps,
+                              int updated_median_rtt_milliseconds) {
+      median_kbps_ = updated_median_kbps;
+      median_rtt_milliseconds_ = updated_median_rtt_milliseconds;

[bengr, 2015/05/29 17:38:10]

Why are these not TimeDeltas?

[tbansal1, 2015/05/29 19:13:36]

Initially, I did not make it TimeDelta because if we 
write this to the pref,
we have to write it as an int.

But, it is probably better to make this TimeDelta and then
convert it to int when reading/writing pref. Done.

Done.

+      last_updated_ = base::TimeTicks::Now();
+    }
+
+    bool MatchesNetwork(NetworkChangeNotifier::ConnectionType connection_type,
+                        std::string network_name) const {

[bengr, 2015/05/29 17:38:10]

const std::string&

[tbansal1, 2015/05/29 19:13:36]

Done.

+      return connection_type == connection_type_ &&
+             network_name == network_name_;
+    }
+
+    // Median Kbps of this cached network.
+    int median_kbps_;
+
+    // Median RTT (in milliseconds) of this cached network.
+    int median_rtt_milliseconds_;

[bengr, 2015/05/29 17:38:10]

TimeDelta?

[tbansal1, 2015/05/29 19:13:36]

Done.

+
+    // Time when this cache entry was last updated.
+    base::TimeTicks last_updated_;
+
+   private:
+    // Connection type of this cached network.
+    NetworkChangeNotifier::ConnectionType connection_type_;
+
+    // Name of this cached network.
+    std::string network_name_;
+  };
+
   // 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;
+  // 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.
+  std::vector<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_