Expose NQE::OnEffectiveConnectionTypeChanged API

net/nqe/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/nqe/network_quality_estimator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.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/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "net/base/load_flags.h"
 #include "net/base/network_change_notifier.h"
 #include "net/http/http_status_code.h"
 #include "net/nqe/external_estimate_provider.h"
 #include "net/nqe/network_quality_observation.h"
 #include "net/nqe/network_quality_observation_source.h"
 #include "net/nqe/observation_buffer.h"
 #include "net/socket/socket_performance_watcher.h"
@@ skipping 23 matching lines @@
 
   TestNetworkQualityEstimator(
       std::unique_ptr<net::ExternalEstimateProvider> external_estimate_provider,
       const std::map<std::string, std::string>& variation_params,
       bool allow_local_host_requests_for_tests,
       bool allow_smaller_responses_for_tests)
       : NetworkQualityEstimator(std::move(external_estimate_provider),
                                 variation_params,
                                 allow_local_host_requests_for_tests,
                                 allow_smaller_responses_for_tests),
-        current_network_simulated_(false),
+        effective_connection_type_set_(false),
+        effective_connection_type_(EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
+        current_network_type_(NetworkChangeNotifier::CONNECTION_UNKNOWN),
         url_rtt_set_(false),
         downlink_throughput_kbps_set_(false) {
     // Set up embedded test server.
     embedded_test_server_.ServeFilesFromDirectory(
         base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
     EXPECT_TRUE(embedded_test_server_.Start());
     embedded_test_server_.RegisterRequestHandler(base::Bind(
         &TestNetworkQualityEstimator::HandleRequest, base::Unretained(this)));
   }
 
   explicit TestNetworkQualityEstimator(
       const std::map<std::string, std::string>& variation_params)
       : TestNetworkQualityEstimator(
             variation_params,
             std::unique_ptr<ExternalEstimateProvider>()) {}
 
   ~TestNetworkQualityEstimator() override {}
 
   // Overrides the current network type and id.
   // Notifies network quality estimator of change in connection.
   void SimulateNetworkChangeTo(NetworkChangeNotifier::ConnectionType type,
                                const std::string& network_id) {
-    current_network_simulated_ = true;
     current_network_type_ = type;
     current_network_id_ = network_id;
     OnConnectionTypeChanged(type);
   }
 
   // Called by embedded server when a HTTP request is received.
   std::unique_ptr<test_server::HttpResponse> HandleRequest(
       const test_server::HttpRequest& request) {
     std::unique_ptr<test_server::BasicHttpResponse> http_response(
         new test_server::BasicHttpResponse());
     http_response->set_code(HTTP_OK);
     http_response->set_content("hello");
     http_response->set_content_type("text/plain");
     return std::move(http_response);
   }
 
   // Returns a GURL hosted at embedded test server.
   const GURL GetEchoURL() const {
     return embedded_test_server_.GetURL("/echo.html");
   }
 
   void set_url_rtt(const base::TimeDelta& url_rtt) {
     url_rtt_set_ = true;
     url_rtt_ = url_rtt;
   }
 
+  void set_effective_connection_type(EffectiveConnectionType type) {
+    effective_connection_type_set_ = true;
+    effective_connection_type_ = type;
+  }
+
+  EffectiveConnectionType GetEffectiveConnectionType() const override {
+    if (effective_connection_type_set_)
+      return effective_connection_type_;
+    return NetworkQualityEstimator::GetEffectiveConnectionType();
+  }
+
   bool GetURLRequestRTTEstimate(base::TimeDelta* rtt) const override {
     if (url_rtt_set_) {
       *rtt = url_rtt_;
       return true;
     }
     return NetworkQualityEstimator::GetURLRequestRTTEstimate(rtt);
   }
 
   void set_downlink_throughput_kbps(int32_t downlink_throughput_kbps) {
     downlink_throughput_kbps_set_ = true;
     downlink_throughput_kbps_ = downlink_throughput_kbps;
   }
 
   bool GetDownlinkThroughputKbpsEstimate(int32_t* kbps) const override {
     if (downlink_throughput_kbps_set_) {
       *kbps = downlink_throughput_kbps_;
       return true;
     }
     return NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimate(kbps);
   }
 
+  using NetworkQualityEstimator::SetTickClockForTesting;
   using NetworkQualityEstimator::ReadCachedNetworkQualityEstimate;
   using NetworkQualityEstimator::OnConnectionTypeChanged;
 
  private:
-  // True if the network type and network id are currently simulated. This
-  // ensures that the correctness of the test does not depend on the
-  // actual network type of the device on which the test is running.
-  bool current_network_simulated_;
-
   // NetworkQualityEstimator implementation that returns the overridden network
   // id (instead of invoking platform APIs).
   NetworkQualityEstimator::NetworkID GetCurrentNetworkID() const override {
-    // GetCurrentNetworkID should be called only if the network type is
-    // currently simulated.
-    EXPECT_TRUE(current_network_simulated_);
-
     return NetworkQualityEstimator::NetworkID(current_network_type_,
                                               current_network_id_);
   }
 
+  bool effective_connection_type_set_;
+  EffectiveConnectionType effective_connection_type_;
+
   NetworkChangeNotifier::ConnectionType current_network_type_;
   std::string current_network_id_;
 
   bool url_rtt_set_;
   base::TimeDelta url_rtt_;
 
   bool downlink_throughput_kbps_set_;
   int32_t downlink_throughput_kbps_;
 
   // Embedded server used for testing.
   EmbeddedTestServer embedded_test_server_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkQualityEstimator);
 };
 
+class TestEffectiveConnectionTypeObserver
+    : public NetworkQualityEstimator::EffectiveConnectionTypeObserver {
+ public:
+  std::vector<NetworkQualityEstimator::EffectiveConnectionType>&
+  effective_connection_types() {
+    return effective_connection_types_;
+  }
+
+  // EffectiveConnectionTypeObserver implementation:
+  void OnEffectiveConnectionTypeChanged(
+      NetworkQualityEstimator::EffectiveConnectionType type) override {
+    effective_connection_types_.push_back(type);
+  }
+
+ private:
+  std::vector<NetworkQualityEstimator::EffectiveConnectionType>
+      effective_connection_types_;
+};
+
 class TestRTTObserver : public NetworkQualityEstimator::RTTObserver {
  public:
   struct Observation {
     Observation(int32_t ms,
                 const base::TimeTicks& ts,
                 NetworkQualityObservationSource src)
         : rtt_ms(ms), timestamp(ts), source(src) {}
     int32_t rtt_ms;
     base::TimeTicks timestamp;
     NetworkQualityObservationSource source;
@@ skipping 1022 matching lines @@
     request->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(test.allow_small_localhost_requests,
               estimator.GetURLRequestRTTEstimate(&rtt));
     EXPECT_EQ(test.allow_small_localhost_requests,
               estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
   }
 }
 
-TEST(NetworkQualityEstimatorTest, TestObservers) {
+// Tests that the effective connection type is computed at the specified
+// interval, and that the observers are notified of any change.
+TEST(NetworkQualityEstimatorTest, TestEffectiveConnectionTypeObserver) {
+  std::unique_ptr<base::SimpleTestTickClock> tick_clock(
+      new base::SimpleTestTickClock());
+  base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
+
+  TestEffectiveConnectionTypeObserver observer;
+  std::map<std::string, std::string> variation_params;
+  TestNetworkQualityEstimator estimator(variation_params);
+  estimator.AddEffectiveConnectionTypeObserver(&observer);
+  estimator.SetTickClockForTesting(std::move(tick_clock));
+
+  TestDelegate test_delegate;
+  TestURLRequestContext context(true);
+  context.set_network_quality_estimator(&estimator);
+  context.Init();
+
+  EXPECT_EQ(0U, observer.effective_connection_types().size());
+
+  estimator.set_effective_connection_type(
+      NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G);
+  tick_clock_ptr->Advance(base::TimeDelta::FromMinutes(60));
+
+  std::unique_ptr<URLRequest> request(context.CreateRequest(
+      estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
+  request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME);
+  request->Start();
+  base::RunLoop().Run();
+  EXPECT_EQ(1U, observer.effective_connection_types().size());
+
+  // Next request should not trigger recomputation of effective connection type
+  // since there has been no change in the clock.
+  std::unique_ptr<URLRequest> request2(context.CreateRequest(
+      estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
+  request2->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME);
+  request2->Start();
+  base::RunLoop().Run();
+  EXPECT_EQ(1U, observer.effective_connection_types().size());
+
+  // Change in connection type should send out notification to the observers.
+  estimator.set_effective_connection_type(
+      NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G);
+  estimator.SimulateNetworkChangeTo(NetworkChangeNotifier::CONNECTION_WIFI,
+                                    "test");
+  EXPECT_EQ(2U, observer.effective_connection_types().size());
+
+  // A change in effective connection type does not trigger notification to the
+  // observers, since it is not accompanied by any new observation or a network
+  // change event.
+  estimator.set_effective_connection_type(
+      NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G);
+  EXPECT_EQ(2U, observer.effective_connection_types().size());
+}
+
+TEST(NetworkQualityEstimatorTest, TestRttThroughputObservers) {
   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);
@@ skipping 135 matching lines @@
   histogram_tester.ExpectBucketCount("NQE.TransportRTT.Percentile50.Unknown",
                                      rtt.InMilliseconds(), 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile10.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile50.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile90.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile100.Unknown",
                                     1);
 }
 
 }  // namespace net