Added Network Quality Estimator Real-time interface to Cronet

net/base/network_quality_estimator_unittest.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/base/network_quality_estimator.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <map>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
@@ skipping 75 matching lines @@
 
   net::NetworkChangeNotifier::ConnectionType current_network_type_;
   std::string current_network_id_;
 
   // Embedded server used for testing.
   net::test_server::EmbeddedTestServer embedded_test_server_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkQualityEstimator);
 };
 
+class TestRTTObserver : public net::NetworkQualityEstimator::RTTObserver {
+ public:
+  struct Observation {
+    Observation(int32_t ms,
+                const base::TimeTicks& ts,
+                net::NetworkQualityEstimator::ObservationSource src)
+        : rtt_ms(ms), timestamp(ts), source(src) {}
+    int32_t rtt_ms;
+    base::TimeTicks timestamp;
+    net::NetworkQualityEstimator::ObservationSource source;
+  };
+
+  std::vector<Observation>& observations() { return observations_; }
+
+  // RttObserver implementation:
+  void OnRTTObservation(
+      int32_t rtt_ms,
+      const base::TimeTicks& timestamp,
+      net::NetworkQualityEstimator::ObservationSource source) override {
+    observations_.push_back(Observation(rtt_ms, timestamp, source));
+  }
+
+ private:
+  std::vector<Observation> observations_;
+};
+
+class TestThroughputObserver
+    : public net::NetworkQualityEstimator::ThroughputObserver {
+ public:
+  struct Observation {
+    Observation(int32_t kbps,
+                const base::TimeTicks& ts,
+                net::NetworkQualityEstimator::ObservationSource src)
+        : throughput_kbps(kbps), timestamp(ts), source(src) {}
+    int32_t throughput_kbps;
+    base::TimeTicks timestamp;
+    net::NetworkQualityEstimator::ObservationSource source;
+  };
+
+  std::vector<Observation>& observations() { return observations_; }
+
+  // ThroughputObserver implementation:
+  void OnThroughputObservation(
+      int32_t throughput_kbps,
+      const base::TimeTicks& timestamp,
+      net::NetworkQualityEstimator::ObservationSource source) override {
+    observations_.push_back(Observation(throughput_kbps, timestamp, source));
+  }
+
+ private:
+  std::vector<Observation> observations_;
+};
+
 }  // namespace
 
 namespace net {
 
 TEST(NetworkQualityEstimatorTest, TestKbpsRTTUpdates) {
   base::HistogramTester histogram_tester;
   // Enable requests to local host to be used for network quality estimation.
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
@@ skipping 127 matching lines @@
   // Network quality should be unavailable when no observations are available.
   base::TimeDelta rtt;
   EXPECT_FALSE(estimator.GetRTTEstimate(&rtt));
   int32_t kbps;
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 
   // Insert samples from {1,2,3,..., 100}. First insert odd samples, then even
   // samples. This helps in verifying that the order of samples does not matter.
   for (int i = 1; i <= 99; i += 2) {
     estimator.downstream_throughput_kbps_observations_.AddObservation(
-        NetworkQualityEstimator::Observation(i, now));
+        NetworkQualityEstimator::Observation(
+            i, now, NetworkQualityEstimator::URL_REQUEST));
     estimator.rtt_msec_observations_.AddObservation(
-        NetworkQualityEstimator::Observation(i, now));
+        NetworkQualityEstimator::Observation(
+            i, now, NetworkQualityEstimator::URL_REQUEST));
     EXPECT_TRUE(estimator.GetRTTEstimate(&rtt));
     EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
   }
 
   for (int i = 2; i <= 100; i += 2) {
     estimator.downstream_throughput_kbps_observations_.AddObservation(
-        NetworkQualityEstimator::Observation(i, now));
+        NetworkQualityEstimator::Observation(
+            i, now, NetworkQualityEstimator::URL_REQUEST));
     estimator.rtt_msec_observations_.AddObservation(
-        NetworkQualityEstimator::Observation(i, now));
+        NetworkQualityEstimator::Observation(
+            i, now, NetworkQualityEstimator::URL_REQUEST));
     EXPECT_TRUE(estimator.GetRTTEstimate(&rtt));
     EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
   }
 
   for (int i = 0; i <= 100; ++i) {
     // Checks if the difference between the two integers is less than 1. This is
     // required because computed percentiles may be slightly different from
     // what is expected due to floating point computation errors and integer
     // rounding off errors.
     EXPECT_NEAR(estimator.GetDownlinkThroughputKbpsEstimateInternal(
@@ skipping 20 matching lines @@
 // order. RTT percentiles must be in increasing order.
 TEST(NetworkQualityEstimatorTest, PercentileDifferentTimestamps) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks very_old = base::TimeTicks::UnixEpoch();
 
   // First 50 samples have very old timestamp.
   for (int i = 1; i <= 50; ++i) {
     estimator.downstream_throughput_kbps_observations_.AddObservation(
-        NetworkQualityEstimator::Observation(i, very_old));
+        NetworkQualityEstimator::Observation(
+            i, very_old, NetworkQualityEstimator::URL_REQUEST));
     estimator.rtt_msec_observations_.AddObservation(
-        NetworkQualityEstimator::Observation(i, very_old));
+        NetworkQualityEstimator::Observation(
+            i, very_old, NetworkQualityEstimator::URL_REQUEST));
   }
 
   // Next 50 (i.e., from 51 to 100) have recent timestamp.
   for (int i = 51; i <= 100; ++i) {
     estimator.downstream_throughput_kbps_observations_.AddObservation(
-        NetworkQualityEstimator::Observation(i, now));
+        NetworkQualityEstimator::Observation(
+            i, now, NetworkQualityEstimator::URL_REQUEST));
     estimator.rtt_msec_observations_.AddObservation(
-        NetworkQualityEstimator::Observation(i, now));
+        NetworkQualityEstimator::Observation(
+            i, now, NetworkQualityEstimator::URL_REQUEST));
   }
 
   // Older samples have very little weight. So, all percentiles are >= 51
   // (lowest value among recent observations).
   for (int i = 1; i < 100; ++i) {
     // Checks if the difference between the two integers is less than 1. This is
     // required because computed percentiles may be slightly different from
     // what is expected due to floating point computation errors and integer
     // rounding off errors.
     EXPECT_NEAR(estimator.GetDownlinkThroughputKbpsEstimateInternal(
@@ skipping 180 matching lines @@
 // Test if the network estimates are cached when network change notification
 // is invoked.
 TEST(NetworkQualityEstimatorTest, TestCaching) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
   size_t expected_cache_size = 0;
   EXPECT_EQ(expected_cache_size, estimator.cached_network_qualities_.size());
 
   // Cache entry will not be added for (NONE, "").
   estimator.downstream_throughput_kbps_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(1, base::TimeTicks::Now()));
+      NetworkQualityEstimator::Observation(
+          1, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
   estimator.rtt_msec_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(1000, base::TimeTicks::Now()));
+      NetworkQualityEstimator::Observation(
+          1000, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
   estimator.SimulateNetworkChangeTo(
       NetworkChangeNotifier::ConnectionType::CONNECTION_2G, "test-1");
   EXPECT_EQ(expected_cache_size, estimator.cached_network_qualities_.size());
 
   // Entry will be added for (2G, "test1").
   // Also, set the network quality for (2G, "test1") so that it is stored in
   // the cache.
   estimator.downstream_throughput_kbps_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(1, base::TimeTicks::Now()));
+      NetworkQualityEstimator::Observation(
+          1, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
   estimator.rtt_msec_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(1000, base::TimeTicks::Now()));
+      NetworkQualityEstimator::Observation(
+          1000, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
 
   estimator.SimulateNetworkChangeTo(
       NetworkChangeNotifier::ConnectionType::CONNECTION_3G, "test-1");
   ++expected_cache_size;
   EXPECT_EQ(expected_cache_size, estimator.cached_network_qualities_.size());
 
   // Entry will be added for (3G, "test1").
   // Also, set the network quality for (3G, "test1") so that it is stored in
   // the cache.
   estimator.downstream_throughput_kbps_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(2, base::TimeTicks::Now()));
+      NetworkQualityEstimator::Observation(
+          2, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
   estimator.rtt_msec_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(500, base::TimeTicks::Now()));
+      NetworkQualityEstimator::Observation(
+          500, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
   estimator.SimulateNetworkChangeTo(
       NetworkChangeNotifier::ConnectionType::CONNECTION_3G, "test-2");
   ++expected_cache_size;
   EXPECT_EQ(expected_cache_size, estimator.cached_network_qualities_.size());
 
   // Entry will not be added for (3G, "test2").
   estimator.SimulateNetworkChangeTo(
       NetworkChangeNotifier::ConnectionType::CONNECTION_2G, "test-1");
   EXPECT_EQ(expected_cache_size, estimator.cached_network_qualities_.size());
 
@@ skipping 43 matching lines @@
       std::string());
   EXPECT_EQ(0U, estimator.cached_network_qualities_.size());
 
   // Add 100 more networks than the maximum size of the cache.
   size_t network_count =
       NetworkQualityEstimator::kMaximumNetworkQualityCacheSize + 100;
 
   base::TimeTicks update_time_of_network_100;
   for (size_t i = 0; i < network_count; ++i) {
     estimator.downstream_throughput_kbps_observations_.AddObservation(
-        NetworkQualityEstimator::Observation(2, base::TimeTicks::Now()));
+        NetworkQualityEstimator::Observation(
+            2, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
     estimator.rtt_msec_observations_.AddObservation(
-        NetworkQualityEstimator::Observation(500, base::TimeTicks::Now()));
+        NetworkQualityEstimator::Observation(
+            500, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
 
     if (i == 100)
       update_time_of_network_100 = base::TimeTicks::Now();
 
     estimator.SimulateNetworkChangeTo(
         net::NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI,
         base::SizeTToString(i));
     if (i < NetworkQualityEstimator::kMaximumNetworkQualityCacheSize)
       EXPECT_EQ(i, estimator.cached_network_qualities_.size());
     EXPECT_LE(estimator.cached_network_qualities_.size(),
               static_cast<size_t>(
                   NetworkQualityEstimator::kMaximumNetworkQualityCacheSize));
   }
   // One more call so that the last network is also written to cache.
   estimator.downstream_throughput_kbps_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(2, base::TimeTicks::Now()));
+      NetworkQualityEstimator::Observation(
+          2, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
   estimator.rtt_msec_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(500, base::TimeTicks::Now()));
+      NetworkQualityEstimator::Observation(
+          500, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
   estimator.SimulateNetworkChangeTo(
       net::NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI,
       base::SizeTToString(network_count - 1));
   EXPECT_EQ(static_cast<size_t>(
                 NetworkQualityEstimator::kMaximumNetworkQualityCacheSize),
             estimator.cached_network_qualities_.size());
 
   // Test that the cache is LRU by examining its contents. Networks in cache
   // must all be newer than the 100th network.
   for (NetworkQualityEstimator::CachedNetworkQualities::iterator it =
            estimator.cached_network_qualities_.begin();
        it != estimator.cached_network_qualities_.end(); ++it) {
     EXPECT_GE((it->second).last_update_time_, update_time_of_network_100);
   }
 }
 
 TEST(NetworkQualityEstimatorTest, TestGetMedianRTTSince) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks old =
       base::TimeTicks::Now() - base::TimeDelta::FromMilliseconds(1);
 
   // First sample has very old timestamp.
   estimator.downstream_throughput_kbps_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(1, old));
+      NetworkQualityEstimator::Observation(
+          1, old, NetworkQualityEstimator::URL_REQUEST));
   estimator.rtt_msec_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(1, old));
+      NetworkQualityEstimator::Observation(
+          1, old, NetworkQualityEstimator::URL_REQUEST));
 
   estimator.downstream_throughput_kbps_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(100, now));
+      NetworkQualityEstimator::Observation(
+          100, now, NetworkQualityEstimator::URL_REQUEST));
   estimator.rtt_msec_observations_.AddObservation(
-      NetworkQualityEstimator::Observation(100, now));
+      NetworkQualityEstimator::Observation(
+          100, now, NetworkQualityEstimator::URL_REQUEST));
 
   base::TimeDelta rtt;
   EXPECT_FALSE(estimator.GetRecentMedianRTT(
       now + base::TimeDelta::FromSeconds(10), &rtt));
   EXPECT_TRUE(estimator.GetRecentMedianRTT(now, &rtt));
   EXPECT_EQ(100, rtt.InMilliseconds());
 
   int32_t downstream_throughput_kbps;
   EXPECT_FALSE(estimator.GetRecentMedianDownlinkThroughputKbps(
       now + base::TimeDelta::FromSeconds(10), &downstream_throughput_kbps));
@@ skipping 257 matching lines @@
 
   scoped_ptr<URLRequest> request(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(2U, estimator.rtt_msec_observations_.Size());
   EXPECT_EQ(2U, estimator.downstream_throughput_kbps_observations_.Size());
 }
 
+TEST(NetworkQualityEstimatorTest, TestObservers) {
+  TestRTTObserver rtt_observer;
+  TestThroughputObserver throughput_observer;
+  std::map<std::string, std::string> variation_params;
+  TestNetworkQualityEstimator estimator(variation_params);
+  estimator.AddRTTObserver(&rtt_observer);
+  estimator.AddThroughputObserver(&throughput_observer);
+
+  TestDelegate test_delegate;
+  TestURLRequestContext context(true);
+  context.set_network_quality_estimator(&estimator);
+  context.Init();
+
+  EXPECT_EQ(0U, rtt_observer.observations().size());
+  EXPECT_EQ(0U, throughput_observer.observations().size());
+  base::TimeTicks then = base::TimeTicks::Now();
+
+  scoped_ptr<URLRequest> request(context.CreateRequest(
+      estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
+  request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME);
+  request->Start();
+  base::RunLoop().Run();
+
+  scoped_ptr<URLRequest> request2(context.CreateRequest(
+      estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
+  request2->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME);
+  request2->Start();
+  base::RunLoop().Run();
+
+  // Both RTT and downstream throughput should be updated.
+  EXPECT_NE(NetworkQualityEstimator::InvalidRTT(),
+            estimator.GetRTTEstimateInternal(base::TimeTicks(), 100));
+  EXPECT_NE(NetworkQualityEstimator::kInvalidThroughput,
+            estimator.GetDownlinkThroughputKbpsEstimateInternal(
+                base::TimeTicks(), 100));
+
+  EXPECT_EQ(2U, rtt_observer.observations().size());
+  EXPECT_EQ(2U, throughput_observer.observations().size());
+  for (auto observation : rtt_observer.observations()) {
+    EXPECT_LE(0, observation.rtt_ms);
+    EXPECT_LE(0, (observation.timestamp - then).InMilliseconds());
+    EXPECT_EQ(NetworkQualityEstimator::URL_REQUEST, observation.source);
+  }
+  for (auto observation : throughput_observer.observations()) {
+    EXPECT_LE(0, observation.throughput_kbps);
+    EXPECT_LE(0, (observation.timestamp - then).InMilliseconds());
+    EXPECT_EQ(NetworkQualityEstimator::URL_REQUEST, observation.source);
+  }
+}
+
 }  // namespace net