NQE: Move ECT to net:: namespace

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>
@@ skipping 10 matching lines @@
 #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/threading/platform_thread.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/effective_connection_type.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"
 #include "net/socket/socket_performance_watcher_factory.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_request.h"
@@ skipping 272 matching lines @@
 
   // 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() {
+  std::vector<EffectiveConnectionType>& effective_connection_types() {
     return effective_connection_types_;
   }
 
   // EffectiveConnectionTypeObserver implementation:
-  void OnEffectiveConnectionTypeChanged(
-      NetworkQualityEstimator::EffectiveConnectionType type) override {
+  void OnEffectiveConnectionTypeChanged(EffectiveConnectionType type) override {
     effective_connection_types_.push_back(type);
   }
 
  private:
-  std::vector<NetworkQualityEstimator::EffectiveConnectionType>
-      effective_connection_types_;
+  std::vector<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;
@@ skipping 73 matching lines @@
   // Both RTT and downstream throughput should be updated.
   EXPECT_TRUE(estimator.GetHttpRTTEstimate(&rtt));
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
   EXPECT_FALSE(estimator.GetTransportRTTEstimate(&rtt));
 
   // Check UMA histograms.
   histogram_tester.ExpectTotalCount("NQE.PeakKbps.Unknown", 0);
   histogram_tester.ExpectTotalCount("NQE.FastestRTT.Unknown", 0);
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType.Unknown",
-      NetworkQualityEstimator::EffectiveConnectionType::
-          EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
-      1);
+      EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_UNKNOWN, 1);
 
   std::unique_ptr<URLRequest> request2(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request2->SetLoadFlags(request2->load_flags() | LOAD_MAIN_FRAME);
   request2->Start();
   base::RunLoop().Run();
   histogram_tester.ExpectTotalCount(
       "NQE.MainFrame.EffectiveConnectionType.Unknown", 2);
 
   estimator.SimulateNetworkChangeTo(
@@ skipping 34 matching lines @@
   EXPECT_FALSE(estimator.GetHttpRTTEstimate(&rtt));
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 
   std::unique_ptr<URLRequest> request3(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request3->SetLoadFlags(request2->load_flags() | LOAD_MAIN_FRAME);
   request3->Start();
   base::RunLoop().Run();
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType.WiFi",
-      NetworkQualityEstimator::EffectiveConnectionType::
-          EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
-      1);
+      EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_UNKNOWN, 1);
 
   estimator.SimulateNetworkChangeTo(
       NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN, "test");
   histogram_tester.ExpectBucketCount("NQE.CachedNetworkQualityAvailable", false,
                                      3);
   histogram_tester.ExpectBucketCount("NQE.CachedNetworkQualityAvailable", true,
                                      1);
 }
 
 TEST(NetworkQualityEstimatorTest, StoreObservations) {
@@ skipping 192 matching lines @@
 }
 
 // Tests that |GetEffectiveConnectionType| returns
 // EFFECTIVE_CONNECTION_TYPE_OFFLINE when the device is currently offline.
 TEST(NetworkQualityEstimatorTest, Offline) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
   const struct {
     NetworkChangeNotifier::ConnectionType connection_type;
-    NetworkQualityEstimator::EffectiveConnectionType expected_connection_type;
+    EffectiveConnectionType expected_connection_type;
   } tests[] = {
-      {NetworkChangeNotifier::CONNECTION_2G,
-       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_UNKNOWN},
+      {NetworkChangeNotifier::CONNECTION_2G, EFFECTIVE_CONNECTION_TYPE_UNKNOWN},
       {NetworkChangeNotifier::CONNECTION_NONE,
-       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {NetworkChangeNotifier::CONNECTION_3G,
-       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_UNKNOWN},
+       EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {NetworkChangeNotifier::CONNECTION_3G, EFFECTIVE_CONNECTION_TYPE_UNKNOWN},
   };
 
   for (const auto& test : tests) {
     estimator.SimulateNetworkChangeTo(test.connection_type, "test");
     EXPECT_EQ(test.expected_connection_type,
               estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that |GetEffectiveConnectionType| returns correct connection type when
@@ skipping 10 matching lines @@
 
   TestNetworkQualityEstimator estimator(variation_params);
 
   // Simulate the connection type as Wi-Fi so that GetEffectiveConnectionType
   // does not return Offline if the device is offline.
   estimator.SimulateNetworkChangeTo(NetworkChangeNotifier::CONNECTION_WIFI,
                                     "test");
 
   const struct {
     int32_t rtt_msec;
-    NetworkQualityEstimator::EffectiveConnectionType expected_conn_type;
+    EffectiveConnectionType expected_conn_type;
   } tests[] = {
-      {5000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {4000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {3000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {2000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {1000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {700, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
-      {500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
-      {400, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
-      {300, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
-      {200, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
-      {100, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
-      {20, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {5000, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {4000, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {3000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {2000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {1500, EFFECTIVE_CONNECTION_TYPE_2G},
+      {1000, EFFECTIVE_CONNECTION_TYPE_2G},
+      {700, EFFECTIVE_CONNECTION_TYPE_3G},
+      {500, EFFECTIVE_CONNECTION_TYPE_3G},
+      {400, EFFECTIVE_CONNECTION_TYPE_4G},
+      {300, EFFECTIVE_CONNECTION_TYPE_4G},
+      {200, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {100, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {20, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
   };
 
   for (const auto& test : tests) {
     estimator.set_http_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
     estimator.set_recent_http_rtt(
         base::TimeDelta::FromMilliseconds(test.rtt_msec));
     estimator.set_downlink_throughput_kbps(INT32_MAX);
     estimator.set_recent_downlink_throughput_kbps(INT32_MAX);
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that default transport RTT thresholds for different effective
 // connection types are correctly set.
 TEST(NetworkQualityEstimatorTest, DefaultTransportRTTBasedThresholds) {
   const struct {
     bool override_defaults_using_variation_params;
     int32_t transport_rtt_msec;
-    NetworkQualityEstimator::EffectiveConnectionType expected_conn_type;
+    EffectiveConnectionType expected_conn_type;
   } tests[] = {
       // When the variation params do not override connection thresholds,
       // default values should be used.
-      {false, 5000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {false, 4000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {false, 3000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {false, 2000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {false, 1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {false, 1000,
-       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
-      {false, 20, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {false, 5000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {false, 4000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {false, 3000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {false, 2000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {false, 1500, EFFECTIVE_CONNECTION_TYPE_2G},
+      {false, 1000, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {false, 20, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       // Override default thresholds using variation params.
-      {true, 5000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {true, 4000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {true, 3000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {true, 2000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {true, 1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {true, 1000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {true, 20, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {true, 5000, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {true, 4000, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {true, 3000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {true, 2000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {true, 1500, EFFECTIVE_CONNECTION_TYPE_2G},
+      {true, 1000, EFFECTIVE_CONNECTION_TYPE_2G},
+      {true, 20, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
   };
 
   for (const auto& test : tests) {
     std::map<std::string, std::string> variation_params;
     variation_params["effective_connection_type_algorithm"] =
         "TransportRTTOrDownstreamThroughput";
     if (test.override_defaults_using_variation_params) {
       variation_params["Offline.ThresholdMedianTransportRTTMsec"] = "4000";
       variation_params["Slow2G.ThresholdMedianTransportRTTMsec"] = "2000";
       variation_params["2G.ThresholdMedianTransportRTTMsec"] = "1000";
@@ skipping 15 matching lines @@
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that default HTTP RTT thresholds for different effective
 // connection types are correctly set.
 TEST(NetworkQualityEstimatorTest, DefaultHttpRTTBasedThresholds) {
   const struct {
     bool override_defaults_using_variation_params;
     int32_t http_rtt_msec;
-    NetworkQualityEstimator::EffectiveConnectionType expected_conn_type;
+    EffectiveConnectionType expected_conn_type;
   } tests[] = {
       // When the variation params do not override connection thresholds,
       // default values should be used.
-      {false, 5000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {false, 4000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {false, 3000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {false, 2000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {false, 1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {false, 1000,
-       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
-      {false, 20, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {false, 5000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {false, 4000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {false, 3000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {false, 2000, EFFECTIVE_CONNECTION_TYPE_2G},
+      {false, 1500, EFFECTIVE_CONNECTION_TYPE_2G},
+      {false, 1000, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {false, 20, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       // Override default thresholds using variation params.
-      {true, 5000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {true, 4000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {true, 3000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {true, 2000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {true, 1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {true, 1000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {true, 20, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {true, 5000, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {true, 4000, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {true, 3000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {true, 2000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {true, 1500, EFFECTIVE_CONNECTION_TYPE_2G},
+      {true, 1000, EFFECTIVE_CONNECTION_TYPE_2G},
+      {true, 20, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
   };
 
   for (const auto& test : tests) {
     std::map<std::string, std::string> variation_params;
     if (test.override_defaults_using_variation_params) {
       variation_params["Offline.ThresholdMedianHttpRTTMsec"] = "4000";
       variation_params["Slow2G.ThresholdMedianHttpRTTMsec"] = "2000";
       variation_params["2G.ThresholdMedianHttpRTTMsec"] = "1000";
     }
 
@@ skipping 30 matching lines @@
 
   TestNetworkQualityEstimator estimator(variation_params);
 
   // Simulate the connection type as Wi-Fi so that GetEffectiveConnectionType
   // does not return Offline if the device is offline.
   estimator.SimulateNetworkChangeTo(NetworkChangeNotifier::CONNECTION_WIFI,
                                     "test");
 
   const struct {
     int32_t transport_rtt_msec;
-    NetworkQualityEstimator::EffectiveConnectionType expected_conn_type;
+    EffectiveConnectionType expected_conn_type;
   } tests[] = {
-      {5000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {4000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {3000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {2000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {1000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {700, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
-      {500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
-      {400, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
-      {300, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
-      {200, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
-      {100, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
-      {20, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {5000, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {4000, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {3000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {2000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {1500, EFFECTIVE_CONNECTION_TYPE_2G},
+      {1000, EFFECTIVE_CONNECTION_TYPE_2G},
+      {700, EFFECTIVE_CONNECTION_TYPE_3G},
+      {500, EFFECTIVE_CONNECTION_TYPE_3G},
+      {400, EFFECTIVE_CONNECTION_TYPE_4G},
+      {300, EFFECTIVE_CONNECTION_TYPE_4G},
+      {200, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {100, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {20, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
   };
 
   for (const auto& test : tests) {
     estimator.set_transport_rtt(
         base::TimeDelta::FromMilliseconds(test.transport_rtt_msec));
     estimator.set_recent_transport_rtt(
         base::TimeDelta::FromMilliseconds(test.transport_rtt_msec));
     estimator.set_downlink_throughput_kbps(INT32_MAX);
     estimator.set_recent_downlink_throughput_kbps(INT32_MAX);
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
@@ skipping 23 matching lines @@
   TestNetworkQualityEstimator estimator(variation_params);
 
   // Simulate the connection type as Wi-Fi so that GetEffectiveConnectionType
   // does not return Offline if the device is offline.
   estimator.SimulateNetworkChangeTo(NetworkChangeNotifier::CONNECTION_WIFI,
                                     "test");
 
   const struct {
     int32_t rtt_msec;
     int32_t downlink_throughput_kbps;
-    NetworkQualityEstimator::EffectiveConnectionType expected_conn_type;
+    EffectiveConnectionType expected_conn_type;
   } tests[] = {
       // Set RTT to a very low value to observe the effect of throughput.
       // Throughput is the bottleneck.
-      {1, 5, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {1, 10, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {1, 50, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {1, 100, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {1, 150, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {1, 300, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {1, 400, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
-      {1, 500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
-      {1, 700, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
-      {1, 1000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
-      {1, 1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
-      {1, 2500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {1, 5, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {1, 10, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {1, 50, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {1, 100, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {1, 150, EFFECTIVE_CONNECTION_TYPE_2G},
+      {1, 300, EFFECTIVE_CONNECTION_TYPE_2G},
+      {1, 400, EFFECTIVE_CONNECTION_TYPE_3G},
+      {1, 500, EFFECTIVE_CONNECTION_TYPE_3G},
+      {1, 700, EFFECTIVE_CONNECTION_TYPE_4G},
+      {1, 1000, EFFECTIVE_CONNECTION_TYPE_4G},
+      {1, 1500, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {1, 2500, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       // Set both RTT and throughput. RTT is the bottleneck.
-      {3000, 25000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {700, 25000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
+      {3000, 25000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {700, 25000, EFFECTIVE_CONNECTION_TYPE_3G},
   };
 
   for (const auto& test : tests) {
     estimator.set_http_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
     estimator.set_recent_http_rtt(
         base::TimeDelta::FromMilliseconds(test.rtt_msec));
     estimator.set_downlink_throughput_kbps(test.downlink_throughput_kbps);
     estimator.set_recent_downlink_throughput_kbps(
         test.downlink_throughput_kbps);
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
@@ skipping 25 matching lines @@
   TestNetworkQualityEstimator estimator(variation_params);
 
   // Simulate the connection type as Wi-Fi so that GetEffectiveConnectionType
   // does not return Offline if the device is offline.
   estimator.SimulateNetworkChangeTo(NetworkChangeNotifier::CONNECTION_WIFI,
                                     "test");
 
   const struct {
     int32_t transport_rtt_msec;
     int32_t downlink_throughput_kbps;
-    NetworkQualityEstimator::EffectiveConnectionType expected_conn_type;
+    EffectiveConnectionType expected_conn_type;
   } tests[] = {
       // Set RTT to a very low value to observe the effect of throughput.
       // Throughput is the bottleneck.
-      {1, 5, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {1, 10, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
-      {1, 50, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {1, 100, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {1, 150, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {1, 300, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
-      {1, 400, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
-      {1, 500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
-      {1, 700, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
-      {1, 1000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
-      {1, 1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
-      {1, 2500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {1, 5, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {1, 10, EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {1, 50, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {1, 100, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {1, 150, EFFECTIVE_CONNECTION_TYPE_2G},
+      {1, 300, EFFECTIVE_CONNECTION_TYPE_2G},
+      {1, 400, EFFECTIVE_CONNECTION_TYPE_3G},
+      {1, 500, EFFECTIVE_CONNECTION_TYPE_3G},
+      {1, 700, EFFECTIVE_CONNECTION_TYPE_4G},
+      {1, 1000, EFFECTIVE_CONNECTION_TYPE_4G},
+      {1, 1500, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+      {1, 2500, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       // Set both RTT and throughput. RTT is the bottleneck.
-      {3000, 25000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {700, 25000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
+      {3000, 25000, EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
+      {700, 25000, EFFECTIVE_CONNECTION_TYPE_3G},
   };
 
   for (const auto& test : tests) {
     estimator.set_transport_rtt(
         base::TimeDelta::FromMilliseconds(test.transport_rtt_msec));
     estimator.set_recent_transport_rtt(
         base::TimeDelta::FromMilliseconds(test.transport_rtt_msec));
     estimator.set_downlink_throughput_kbps(test.downlink_throughput_kbps);
     estimator.set_recent_downlink_throughput_kbps(
         test.downlink_throughput_kbps);
@@ skipping 94 matching lines @@
   estimator.rtt_observations_.AddObservation(
       NetworkQualityEstimator::RttObservation(
           new_tcp_rtt, now, NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
 
   const struct {
     base::TimeTicks start_timestamp;
     bool expect_network_quality_available;
     base::TimeDelta expected_http_rtt;
     base::TimeDelta expected_transport_rtt;
     int32_t expected_downstream_throughput;
-    NetworkQualityEstimator::EffectiveConnectionType
-        expected_effective_connection_type;
+    EffectiveConnectionType expected_effective_connection_type;
   } tests[] = {
       {now + base::TimeDelta::FromSeconds(10), false,
        base::TimeDelta::FromMilliseconds(0),
        base::TimeDelta::FromMilliseconds(0), 0,
-       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+       EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       {now, true, new_url_rtt, new_tcp_rtt, new_downlink_kbps,
-       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
+       EFFECTIVE_CONNECTION_TYPE_4G},
       {old - base::TimeDelta::FromMicroseconds(500), true, old_url_rtt,
-       old_tcp_rtt, old_downlink_kbps,
-       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
+       old_tcp_rtt, old_downlink_kbps, EFFECTIVE_CONNECTION_TYPE_BROADBAND},
 
   };
   for (const auto& test : tests) {
     base::TimeDelta http_rtt;
     base::TimeDelta transport_rtt;
     int32_t downstream_throughput_kbps;
     EXPECT_EQ(
         test.expect_network_quality_available,
         estimator.GetRecentHttpRTTMedian(test.start_timestamp, &http_rtt));
     EXPECT_EQ(test.expect_network_quality_available,
@@ skipping 329 matching lines @@
   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);
+  estimator.set_effective_connection_type(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());
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType.Unknown",
-      NetworkQualityEstimator::EffectiveConnectionType::
-          EFFECTIVE_CONNECTION_TYPE_2G,
-      1);
+      EFFECTIVE_CONNECTION_TYPE_2G, 1);
 
   // 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.set_effective_connection_type(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);
+  estimator.set_effective_connection_type(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);
@@ skipping 146 matching lines @@
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile100.Unknown",
                                     1);
 
   // Verify that metrics are logged correctly on main-frame requests.
   histogram_tester.ExpectTotalCount(
       "NQE.MainFrame.TransportRTT.Percentile50.Unknown", num_requests);
   histogram_tester.ExpectTotalCount(
       "NQE.MainFrame.EffectiveConnectionType.Unknown", num_requests);
   histogram_tester.ExpectBucketCount(
       "NQE.MainFrame.EffectiveConnectionType.Unknown",
-      NetworkQualityEstimator::EffectiveConnectionType::
-          EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
-      1);
+      EFFECTIVE_CONNECTION_TYPE_UNKNOWN, 1);
 }
 
 #if defined(OS_IOS)
 // Flaky on iOS when |accuracy_recording_delay| is non-zero.
 #define MAYBE_RecordAccuracy DISABLED_RecordAccuracy
 #else
 #define MAYBE_RecordAccuracy RecordAccuracy
 #endif
 // Tests if the NQE accuracy metrics are recorded properly.
 TEST(NetworkQualityEstimatorTest, MAYBE_RecordAccuracy) {
   const int expected_rtt_msec = 100;
   const int expected_downstream_throughput_kbps = 200;
 
   const base::TimeDelta accuracy_recording_delays[] = {
       base::TimeDelta::FromSeconds(0), base::TimeDelta::FromSeconds(1),
   };
 
   const struct {
     base::TimeDelta rtt;
     base::TimeDelta recent_rtt;
     int32_t downstream_throughput_kbps;
     int32_t recent_downstream_throughput_kbps;
-    NetworkQualityEstimator::EffectiveConnectionType effective_connection_type;
-    NetworkQualityEstimator::EffectiveConnectionType
-        recent_effective_connection_type;
+    EffectiveConnectionType effective_connection_type;
+    EffectiveConnectionType recent_effective_connection_type;
   } tests[] = {
       {base::TimeDelta::FromMilliseconds(expected_rtt_msec),
        base::TimeDelta::FromMilliseconds(expected_rtt_msec),
        expected_downstream_throughput_kbps, expected_downstream_throughput_kbps,
-       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G,
-       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
+       EFFECTIVE_CONNECTION_TYPE_2G, EFFECTIVE_CONNECTION_TYPE_2G},
 
       {
           base::TimeDelta::FromMilliseconds(expected_rtt_msec + 1),
           base::TimeDelta::FromMilliseconds(expected_rtt_msec),
           expected_downstream_throughput_kbps + 1,
-          expected_downstream_throughput_kbps,
-          NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G,
-          NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G,
+          expected_downstream_throughput_kbps, EFFECTIVE_CONNECTION_TYPE_3G,
+          EFFECTIVE_CONNECTION_TYPE_2G,
       },
       {
           base::TimeDelta::FromMilliseconds(expected_rtt_msec - 1),
           base::TimeDelta::FromMilliseconds(expected_rtt_msec),
           expected_downstream_throughput_kbps - 1,
           expected_downstream_throughput_kbps,
-          NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G,
-          NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G,
+          EFFECTIVE_CONNECTION_TYPE_SLOW_2G, EFFECTIVE_CONNECTION_TYPE_2G,
       },
   };
 
   for (const auto& accuracy_recording_delay : accuracy_recording_delays) {
     for (const auto& test : tests) {
       std::unique_ptr<base::SimpleTestTickClock> tick_clock(
           new base::SimpleTestTickClock());
       base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
       tick_clock_ptr->Advance(base::TimeDelta::FromSeconds(1));
 
@@ skipping 105 matching lines @@
           "NQE.ExternalEstimateProvider.RTT.Accuracy.EstimatedObservedDiff." +
               sign_suffix_with_zero_samples + "." + interval_value + ".60_140",
           0);
     }
   }
 }
 
 // Tests that the effective connection type is converted correctly to a
 // descriptive string name, and vice-versa.
 TEST(NetworkQualityEstimatorTest, NameConnectionTypeConversion) {
-  for (size_t i = 0;
-       i < NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_LAST; ++i) {
-    const NetworkQualityEstimator::EffectiveConnectionType
-        effective_connection_type =
-            static_cast<NetworkQualityEstimator::EffectiveConnectionType>(i);
+  for (size_t i = 0; i < EFFECTIVE_CONNECTION_TYPE_LAST; ++i) {
+    const EffectiveConnectionType effective_connection_type =
+        static_cast<EffectiveConnectionType>(i);
     std::string connection_type_name =
         std::string(NetworkQualityEstimator::GetNameForEffectiveConnectionType(
             effective_connection_type));
     EXPECT_FALSE(connection_type_name.empty());
     EXPECT_EQ(effective_connection_type,
               NetworkQualityEstimator::GetEffectiveConnectionTypeForName(
                   connection_type_name));
   }
 }
 
@@ skipping 164 matching lines @@
 
     // Get the bits at index 18-24 which contain the resource fetch time.
     EXPECT_LE(0, (buckets.at(0).min >> kBitsPerMetric) % 128);
 
     // Get the bits at index 25-31 which contain the resource load size.
     EXPECT_LE(0, (buckets.at(0).min) % 128);
   }
 }
 
 }  // namespace net