Split NQE to multiple files

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/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"
 #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"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
@@ skipping 104 matching lines @@
   EmbeddedTestServer embedded_test_server_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkQualityEstimator);
 };
 
 class TestRTTObserver : public NetworkQualityEstimator::RTTObserver {
  public:
   struct Observation {
     Observation(int32_t ms,
                 const base::TimeTicks& ts,
-                NetworkQualityEstimator::ObservationSource src)
+                NetworkQualityObservationSource src)
         : rtt_ms(ms), timestamp(ts), source(src) {}
     int32_t rtt_ms;
     base::TimeTicks timestamp;
-    NetworkQualityEstimator::ObservationSource source;
+    NetworkQualityObservationSource source;
   };
 
   std::vector<Observation>& observations() { return observations_; }
 
   // RttObserver implementation:
-  void OnRTTObservation(
-      int32_t rtt_ms,
-      const base::TimeTicks& timestamp,
-      NetworkQualityEstimator::ObservationSource source) override {
+  void OnRTTObservation(int32_t rtt_ms,
+                        const base::TimeTicks& timestamp,
+                        NetworkQualityObservationSource source) override {
     observations_.push_back(Observation(rtt_ms, timestamp, source));
   }
 
  private:
   std::vector<Observation> observations_;
 };
 
 class TestThroughputObserver
     : public NetworkQualityEstimator::ThroughputObserver {
  public:
   struct Observation {
     Observation(int32_t kbps,
                 const base::TimeTicks& ts,
-                NetworkQualityEstimator::ObservationSource src)
+                NetworkQualityObservationSource src)
         : throughput_kbps(kbps), timestamp(ts), source(src) {}
     int32_t throughput_kbps;
     base::TimeTicks timestamp;
-    NetworkQualityEstimator::ObservationSource source;
+    NetworkQualityObservationSource source;
   };
 
   std::vector<Observation>& observations() { return observations_; }
 
   // ThroughputObserver implementation:
   void OnThroughputObservation(
       int32_t throughput_kbps,
       const base::TimeTicks& timestamp,
-      NetworkQualityEstimator::ObservationSource source) override {
+      NetworkQualityObservationSource source) override {
     observations_.push_back(Observation(throughput_kbps, timestamp, source));
   }
 
  private:
   std::vector<Observation> observations_;
 };
 
 }  // namespace
 
 TEST(NetworkQualityEstimatorTest, TestKbpsRTTUpdates) {
@@ skipping 15 matching lines @@
   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();
 
   // Both RTT and downstream throughput should be updated.
   EXPECT_TRUE(estimator.GetURLRequestRTTEstimate(&rtt));
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 
-  EXPECT_TRUE(estimator.GetURLRequestRTTEstimate(&rtt));
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
-
   // Check UMA histograms.
   histogram_tester.ExpectTotalCount("NQE.PeakKbps.Unknown", 0);
   histogram_tester.ExpectTotalCount("NQE.FastestRTT.Unknown", 0);
 
   histogram_tester.ExpectTotalCount("NQE.RatioEstimatedToActualRTT.Unknown", 0);
 
   std::unique_ptr<URLRequest> request2(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request2->SetLoadFlags(request2->load_flags() | LOAD_MAIN_FRAME);
   request2->Start();
@@ skipping 32 matching lines @@
   base::TimeDelta rtt;
   int32_t kbps;
   EXPECT_FALSE(estimator.GetURLRequestRTTEstimate(&rtt));
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 
   TestDelegate test_delegate;
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
-  // Push 10 more observations than the maximum buffer size.
-  for (size_t i = 0; i < estimator.kMaximumObservationsBufferSize + 10U; ++i) {
+  // Push more observations than the maximum buffer size.
+  const size_t kMaxObservations = 1000;
+  for (size_t i = 0; i < kMaxObservations; ++i) {
     std::unique_ptr<URLRequest> request(context.CreateRequest(
         estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
     request->Start();
     base::RunLoop().Run();
     EXPECT_TRUE(estimator.GetURLRequestRTTEstimate(&rtt));
     EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
   }
 
   // Verify that the stored observations are cleared on network change.
   estimator.SimulateNetworkChangeTo(
       NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, "test-2");
   EXPECT_FALSE(estimator.GetURLRequestRTTEstimate(&rtt));
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 }
 
-// Verifies that the percentiles are correctly computed. All observations have
-// the same timestamp. Kbps percentiles must be in decreasing order. RTT
-// percentiles must be in increasing order.
-TEST(NetworkQualityEstimatorTest, PercentileSameTimestamps) {
-  std::map<std::string, std::string> variation_params;
-  TestNetworkQualityEstimator estimator(variation_params);
-  base::TimeTicks now = base::TimeTicks::Now();
-
-  // Network quality should be unavailable when no observations are available.
-  base::TimeDelta rtt;
-  EXPECT_FALSE(estimator.GetURLRequestRTTEstimate(&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::ThroughputObservation(
-            i, now, NetworkQualityEstimator::URL_REQUEST));
-    estimator.rtt_observations_.AddObservation(
-        NetworkQualityEstimator::RttObservation(
-            base::TimeDelta::FromMilliseconds(i), now,
-            NetworkQualityEstimator::URL_REQUEST));
-    EXPECT_TRUE(estimator.GetURLRequestRTTEstimate(&rtt));
-    EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
-  }
-
-  for (int i = 1; i <= 99; i += 2) {
-    // Insert TCP observation which should not be taken into account when
-    // computing median RTT at HTTP layer.
-    estimator.rtt_observations_.AddObservation(
-        NetworkQualityEstimator::RttObservation(
-            base::TimeDelta::FromMilliseconds(10000), now,
-            NetworkQualityEstimator::TCP));
-
-    // Insert QUIC observation which should not be taken into account when
-    // computing median RTT at HTTP layer.
-    estimator.rtt_observations_.AddObservation(
-        NetworkQualityEstimator::RttObservation(
-            base::TimeDelta::FromMilliseconds(10000), now,
-            NetworkQualityEstimator::QUIC));
-  }
-
-  for (int i = 2; i <= 100; i += 2) {
-    estimator.downstream_throughput_kbps_observations_.AddObservation(
-        NetworkQualityEstimator::ThroughputObservation(
-            i, now, NetworkQualityEstimator::URL_REQUEST));
-    estimator.rtt_observations_.AddObservation(
-        NetworkQualityEstimator::RttObservation(
-            base::TimeDelta::FromMilliseconds(i), now,
-            NetworkQualityEstimator::URL_REQUEST));
-    EXPECT_TRUE(estimator.GetURLRequestRTTEstimate(&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(
-                    base::TimeTicks(), i),
-                100 - i, 1);
-    std::vector<NetworkQualityEstimator::ObservationSource>
-        disallowed_observation_sources;
-    disallowed_observation_sources.push_back(NetworkQualityEstimator::TCP);
-    disallowed_observation_sources.push_back(NetworkQualityEstimator::QUIC);
-    EXPECT_NEAR(estimator
-                    .GetRTTEstimateInternal(disallowed_observation_sources,
-                                            base::TimeTicks(), i)
-                    .InMilliseconds(),
-                i, 1);
-  }
-
-  EXPECT_TRUE(estimator.GetURLRequestRTTEstimate(&rtt));
-  EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
-}
-
-// Verifies that the percentiles are correctly computed. Observations have
-// different timestamps with half the observations being very old and the rest
-// of them being very recent. Percentiles should factor in recent observations
-// much more heavily than older samples. Kbps percentiles must be in decreasing
-// 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 = now - base::TimeDelta::FromDays(365);
-
-  // First 50 samples have very old timestamp.
-  for (int i = 1; i <= 50; ++i) {
-    estimator.downstream_throughput_kbps_observations_.AddObservation(
-        NetworkQualityEstimator::ThroughputObservation(
-            i, very_old, NetworkQualityEstimator::URL_REQUEST));
-    estimator.rtt_observations_.AddObservation(
-        NetworkQualityEstimator::RttObservation(
-            base::TimeDelta::FromMilliseconds(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::ThroughputObservation(
-            i, now, NetworkQualityEstimator::URL_REQUEST));
-
-    // Insert TCP observation which should not be taken into account when
-    // computing median RTT at HTTP layer.
-    estimator.rtt_observations_.AddObservation(
-        NetworkQualityEstimator::RttObservation(
-            base::TimeDelta::FromMilliseconds(10000), now,
-            NetworkQualityEstimator::TCP));
-
-    estimator.rtt_observations_.AddObservation(
-        NetworkQualityEstimator::RttObservation(
-            base::TimeDelta::FromMilliseconds(i), now,
-            NetworkQualityEstimator::URL_REQUEST));
-  }
-
-  std::vector<NetworkQualityEstimator::ObservationSource>
-      disallowed_observation_sources;
-  disallowed_observation_sources.push_back(NetworkQualityEstimator::TCP);
-  disallowed_observation_sources.push_back(NetworkQualityEstimator::QUIC);
-
-  // 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(
-                    base::TimeTicks(), i),
-                51 + 0.49 * (100 - i), 1);
-    EXPECT_NEAR(estimator
-                    .GetRTTEstimateInternal(disallowed_observation_sources,
-                                            base::TimeTicks(), i)
-                    .InMilliseconds(),
-                51 + 0.49 * i, 1);
-  }
-}
-
 // This test notifies NetworkQualityEstimator of received data. Next,
 // throughput and RTT percentiles are checked for correctness by doing simple
 // verifications.
 TEST(NetworkQualityEstimatorTest, ComputedPercentiles) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
-  std::vector<NetworkQualityEstimator::ObservationSource>
-      disallowed_observation_sources;
-  disallowed_observation_sources.push_back(NetworkQualityEstimator::TCP);
-  disallowed_observation_sources.push_back(NetworkQualityEstimator::QUIC);
+  std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
+  disallowed_observation_sources.push_back(
+      NETWORK_QUALITY_OBSERVATION_SOURCE_TCP);
+  disallowed_observation_sources.push_back(
+      NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC);
 
-  EXPECT_EQ(NetworkQualityEstimator::InvalidRTT(),
+  EXPECT_EQ(nqe::internal::InvalidRTT(),
             estimator.GetRTTEstimateInternal(disallowed_observation_sources,
                                              base::TimeTicks(), 100));
-  EXPECT_EQ(NetworkQualityEstimator::kInvalidThroughput,
+  EXPECT_EQ(nqe::internal::kInvalidThroughput,
             estimator.GetDownlinkThroughputKbpsEstimateInternal(
                 base::TimeTicks(), 100));
 
   TestDelegate test_delegate;
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
   // Number of observations are more than the maximum buffer size.
-  for (size_t i = 0; i < estimator.kMaximumObservationsBufferSize + 100U; ++i) {
+  for (size_t i = 0; i < 1000U; ++i) {
     std::unique_ptr<URLRequest> request(context.CreateRequest(
         estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
     request->Start();
     base::RunLoop().Run();
   }
 
   // Verify the percentiles through simple tests.
   for (int i = 0; i <= 100; ++i) {
     EXPECT_GT(estimator.GetDownlinkThroughputKbpsEstimateInternal(
                   base::TimeTicks(), i),
@@ skipping 43 matching lines @@
   estimator.SimulateNetworkChangeTo(
       NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, "test-1");
 
   EXPECT_TRUE(estimator.GetURLRequestRTTEstimate(&rtt));
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
   EXPECT_EQ(200, kbps);
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(2000), rtt);
 
   // Peak network quality should not be affected by the network quality
   // estimator field trial.
-  EXPECT_EQ(NetworkQualityEstimator::InvalidRTT(),
-            estimator.peak_network_quality_.rtt());
-  EXPECT_EQ(NetworkQualityEstimator::kInvalidThroughput,
+  EXPECT_EQ(nqe::internal::InvalidRTT(), estimator.peak_network_quality_.rtt());
+  EXPECT_EQ(nqe::internal::kInvalidThroughput,
             estimator.peak_network_quality_.downstream_throughput_kbps());
 
   // Simulate network change to 2G. Only the Kbps default estimate should be
   // available.
   estimator.SimulateNetworkChangeTo(
       NetworkChangeNotifier::ConnectionType::CONNECTION_2G, "test-2");
 
   EXPECT_FALSE(estimator.GetURLRequestRTTEstimate(&rtt));
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
   EXPECT_EQ(300, kbps);
@@ skipping 153 matching lines @@
 // 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::ThroughputObservation(
-          1, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
+          1, base::TimeTicks::Now(),
+          NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
   estimator.rtt_observations_.AddObservation(
       NetworkQualityEstimator::RttObservation(
           base::TimeDelta::FromMilliseconds(1000), base::TimeTicks::Now(),
-          NetworkQualityEstimator::URL_REQUEST));
+          NETWORK_QUALITY_OBSERVATION_SOURCE_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::ThroughputObservation(
-          1, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
+          1, base::TimeTicks::Now(),
+          NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
   estimator.rtt_observations_.AddObservation(
       NetworkQualityEstimator::RttObservation(
           base::TimeDelta::FromMilliseconds(1000), base::TimeTicks::Now(),
-          NetworkQualityEstimator::URL_REQUEST));
+          NETWORK_QUALITY_OBSERVATION_SOURCE_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::ThroughputObservation(
-          2, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
+          2, base::TimeTicks::Now(),
+          NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
   estimator.rtt_observations_.AddObservation(
       NetworkQualityEstimator::RttObservation(
           base::TimeDelta::FromMilliseconds(500), base::TimeTicks::Now(),
-          NetworkQualityEstimator::URL_REQUEST));
+          NETWORK_QUALITY_OBSERVATION_SOURCE_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 @@
   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::ThroughputObservation(
-            2, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
+            2, base::TimeTicks::Now(),
+            NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
     estimator.rtt_observations_.AddObservation(
         NetworkQualityEstimator::RttObservation(
             base::TimeDelta::FromMilliseconds(500), base::TimeTicks::Now(),
-            NetworkQualityEstimator::URL_REQUEST));
+            NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
 
     if (i == 100)
       update_time_of_network_100 = base::TimeTicks::Now();
 
     estimator.SimulateNetworkChangeTo(
         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::ThroughputObservation(
-          2, base::TimeTicks::Now(), NetworkQualityEstimator::URL_REQUEST));
+          2, base::TimeTicks::Now(),
+          NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
   estimator.rtt_observations_.AddObservation(
       NetworkQualityEstimator::RttObservation(
           base::TimeDelta::FromMilliseconds(500), base::TimeTicks::Now(),
-          NetworkQualityEstimator::URL_REQUEST));
+          NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
   estimator.SimulateNetworkChangeTo(
       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 = now - base::TimeDelta::FromMilliseconds(1);
   ASSERT_NE(old, now);
 
   // First sample has very old timestamp.
   estimator.downstream_throughput_kbps_observations_.AddObservation(
       NetworkQualityEstimator::ThroughputObservation(
-          1, old, NetworkQualityEstimator::URL_REQUEST));
+          1, old, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
   estimator.rtt_observations_.AddObservation(
       NetworkQualityEstimator::RttObservation(
           base::TimeDelta::FromMilliseconds(1), old,
-          NetworkQualityEstimator::URL_REQUEST));
+          NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
 
   estimator.downstream_throughput_kbps_observations_.AddObservation(
       NetworkQualityEstimator::ThroughputObservation(
-          100, now, NetworkQualityEstimator::URL_REQUEST));
+          100, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
   estimator.rtt_observations_.AddObservation(
       NetworkQualityEstimator::RttObservation(
           base::TimeDelta::FromMilliseconds(100), now,
-          NetworkQualityEstimator::URL_REQUEST));
+          NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
 
   const struct {
     base::TimeTicks start_timestamp;
     bool expect_network_quality_available;
     base::TimeDelta expected_url_request_rtt;
     int32_t expected_downstream_throughput;
   } tests[] = {
       {now + base::TimeDelta::FromSeconds(10), false,
        base::TimeDelta::FromMilliseconds(0), 0},
       {now, true, base::TimeDelta::FromMilliseconds(100), 100},
@@ skipping 358 matching lines @@
   EXPECT_TRUE(estimator.GetURLRequestRTTEstimate(&rtt));
 
   int32_t throughput;
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&throughput));
 
   EXPECT_EQ(2U, rtt_observer.observations().size());
   EXPECT_EQ(2U, throughput_observer.observations().size());
   for (const 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);
+    EXPECT_EQ(NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST,
+              observation.source);
   }
   for (const 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);
+    EXPECT_EQ(NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST,
+              observation.source);
   }
 
   // Verify that observations from TCP and QUIC are passed on to the observers.
   base::TimeDelta tcp_rtt(base::TimeDelta::FromMilliseconds(1));
   base::TimeDelta quic_rtt(base::TimeDelta::FromMilliseconds(2));
 
   std::unique_ptr<SocketPerformanceWatcher> tcp_watcher =
       estimator.GetSocketPerformanceWatcherFactory()
           ->CreateSocketPerformanceWatcher(
               SocketPerformanceWatcherFactory::PROTOCOL_TCP);
@@ skipping 45 matching lines @@
 
   EXPECT_EQ(0U, rtt_observer.observations().size());
   base::TimeDelta rtt;
   EXPECT_FALSE(estimator.GetURLRequestRTTEstimate(&rtt));
 
   // Send two requests. Verify that the completion of each request generates at
   // least one TCP RTT observation.
   for (size_t i = 0; i < 2; ++i) {
     size_t before_count_tcp_rtt_observations = 0;
     for (const auto& observation : rtt_observer.observations()) {
-      if (observation.source == NetworkQualityEstimator::TCP)
+      if (observation.source == NETWORK_QUALITY_OBSERVATION_SOURCE_TCP)
         ++before_count_tcp_rtt_observations;
     }
 
     std::unique_ptr<URLRequest> request(context.CreateRequest(
         estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
     request->Start();
     base::RunLoop().Run();
 
     size_t after_count_tcp_rtt_observations = 0;
     for (const auto& observation : rtt_observer.observations()) {
-      if (observation.source == NetworkQualityEstimator::TCP)
+      if (observation.source == NETWORK_QUALITY_OBSERVATION_SOURCE_TCP)
         ++after_count_tcp_rtt_observations;
     }
     // At least one notification should be received per socket performance
     // watcher.
     EXPECT_LE(1U, after_count_tcp_rtt_observations -
                       before_count_tcp_rtt_observations)
         << i;
   }
   EXPECT_TRUE(estimator.GetURLRequestRTTEstimate(&rtt));
 }
 
 }  // namespace net