Separate out observation sources as either HTTP layer or transport layer

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 933 matching lines @@
   const base::TimeDelta old_url_rtt = base::TimeDelta::FromMilliseconds(1);
   const base::TimeDelta old_tcp_rtt = base::TimeDelta::FromMilliseconds(10);
 
   DCHECK_LT(old_url_rtt, rtt_threshold_3g);
   DCHECK_LT(old_tcp_rtt, rtt_threshold_3g);
 
   // First sample has very old timestamp.
   for (size_t i = 0; i < 2; ++i) {
     estimator.downstream_throughput_kbps_observations_.AddObservation(
         NetworkQualityEstimator::ThroughputObservation(
-            old_downlink_kbps, old,
-            NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
+            old_downlink_kbps, old, NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP));
     estimator.rtt_observations_.AddObservation(
         NetworkQualityEstimator::RttObservation(
-            old_url_rtt, old, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
+            old_url_rtt, old, NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP));
     estimator.rtt_observations_.AddObservation(
         NetworkQualityEstimator::RttObservation(
             old_tcp_rtt, old, NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
   }
 
   const int32_t new_downlink_kbps = 100;
   const base::TimeDelta new_url_rtt = base::TimeDelta::FromMilliseconds(100);
   const base::TimeDelta new_tcp_rtt = base::TimeDelta::FromMilliseconds(1000);
 
   DCHECK_NE(old_downlink_kbps, new_downlink_kbps);
   DCHECK_NE(old_url_rtt, new_url_rtt);
   DCHECK_NE(old_tcp_rtt, new_tcp_rtt);
   DCHECK_GT(new_url_rtt, rtt_threshold_3g);
   DCHECK_GT(new_tcp_rtt, rtt_threshold_3g);
   DCHECK_GT(new_url_rtt, rtt_threshold_4g);
   DCHECK_GT(new_tcp_rtt, rtt_threshold_4g);
 
   estimator.downstream_throughput_kbps_observations_.AddObservation(
       NetworkQualityEstimator::ThroughputObservation(
-          new_downlink_kbps, now,
-          NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
+          new_downlink_kbps, now, NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP));
   estimator.rtt_observations_.AddObservation(
       NetworkQualityEstimator::RttObservation(
-          new_url_rtt, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
+          new_url_rtt, now, NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP));
   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;
@@ skipping 477 matching lines @@
   estimator.set_recent_effective_connection_type(
       EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
   // Run one main frame request to force recomputation of effective connection
   // type.
   estimator.RunOneRequest();
   estimator.SimulateNetworkChange(NetworkChangeNotifier::CONNECTION_WIFI,
                                   "test");
 
   NetworkQualityEstimator::RttObservation rtt_observation(
       base::TimeDelta::FromSeconds(5), tick_clock_ptr->NowTicks(),
-      NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST);
+      NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP);
 
   for (size_t i = 0; i < 10; ++i) {
     estimator.NotifyObserversOfRTT(rtt_observation);
     EXPECT_EQ(expected_effective_connection_type_notifications,
               observer.effective_connection_types().size());
   }
   estimator.set_recent_effective_connection_type(
       EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   // Even though there are 10 RTT samples already available, the addition of one
   // more RTT sample should trigger recomputation of the effective connection
   // type since the last computed effective connection type was unknown.
   estimator.NotifyObserversOfRTT(NetworkQualityEstimator::RttObservation(
       base::TimeDelta::FromSeconds(5), tick_clock_ptr->NowTicks(),
-      NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
+      NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP));
   ++expected_effective_connection_type_notifications;
   EXPECT_EQ(expected_effective_connection_type_notifications,
             observer.effective_connection_types().size());
 }
 
 // Tests that the effective connection type is computed regularly depending
 // on the number of RTT and bandwidth samples.
 TEST(NetworkQualityEstimatorTest,
      AdaptiveRecomputationEffectiveConnectionType) {
   base::HistogramTester histogram_tester;
@@ skipping 52 matching lines @@
           EFFECTIVE_CONNECTION_TYPE_3G);
     }
     size_t rtt_observations_count = estimator.rtt_observations_.Size() * 0.5;
     // Increase the number of RTT observations to more than twice the number
     // of current observations. This should trigger recomputation of
     // effective connection type.
     for (size_t i = 0; i < rtt_observations_count + 1; ++i) {
       estimator.rtt_observations_.AddObservation(
           NetworkQualityEstimator::RttObservation(
               base::TimeDelta::FromSeconds(5), tick_clock_ptr->NowTicks(),
-              NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
+              NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP));
 
       estimator.NotifyObserversOfRTT(NetworkQualityEstimator::RttObservation(
           base::TimeDelta::FromSeconds(5), tick_clock_ptr->NowTicks(),
-          NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
+          NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP));
 
       if (i == rtt_observations_count) {
         // Effective connection type must be recomputed since the number of RTT
         // samples are now more than twice the number of RTT samples that were
         // available when effective connection type was last computed.
         ++expected_effective_connection_type_notifications;
       }
       EXPECT_EQ(expected_effective_connection_type_notifications,
                 observer.effective_connection_types().size());
     }
@@ skipping 34 matching lines @@
   EXPECT_TRUE(estimator.GetHttpRTT(&rtt));
 
   int32_t throughput;
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbps(&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(NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST,
-              observation.source);
+    EXPECT_EQ(NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP, observation.source);
   }
   for (const auto& observation : throughput_observer.observations()) {
     EXPECT_LE(0, observation.throughput_kbps);
     EXPECT_LE(0, (observation.timestamp - then).InMilliseconds());
-    EXPECT_EQ(NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST,
-              observation.source);
+    EXPECT_EQ(NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP, observation.source);
   }
 
   EXPECT_FALSE(estimator.GetTransportRTT(&rtt));
 
   // 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()
@@ skipping 561 matching lines @@
     if (expected_count == 1) {
       EffectiveConnectionType last_notified_type =
           observer.effective_connection_types().at(
               observer.effective_connection_types().size() - 1);
       EXPECT_EQ(i, last_notified_type);
     }
   }
 }
 
 }  // namespace net