Record NQE accuracy at main frame requests

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/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/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 26 matching lines @@
       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),
         effective_connection_type_set_(false),
         effective_connection_type_(EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
         current_network_type_(NetworkChangeNotifier::CONNECTION_UNKNOWN),
+        accuracy_recording_intervals_set_(false),
         http_rtt_set_(false),
+        recent_http_rtt_set_(false),
+        transport_rtt_set_(false),
+        recent_transport_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(
@@ skipping 48 matching lines @@
   bool GetHttpRTTEstimate(base::TimeDelta* rtt) const override {
     if (http_rtt_set_) {
       *rtt = http_rtt_;
       return true;
     }
     return NetworkQualityEstimator::GetHttpRTTEstimate(rtt);
   }
 
   bool GetRecentHttpRTTMedian(const base::TimeTicks& start_time,
                               base::TimeDelta* rtt) const override {
-    if (http_rtt_set_) {
-      *rtt = http_rtt_;
+    if (recent_http_rtt_set_) {
+      *rtt = recent_http_rtt_;
       return true;
     }
     return NetworkQualityEstimator::GetRecentHttpRTTMedian(start_time, rtt);
   }
 
-  void set_downlink_throughput_kbps(int32_t downlink_throughput_kbps) {
-    downlink_throughput_kbps_set_ = true;
-    downlink_throughput_kbps_ = downlink_throughput_kbps;
+  void set_recent_http_rtt(const base::TimeDelta& recent_http_rtt) {
+    recent_http_rtt_set_ = true;
+    recent_http_rtt_ = recent_http_rtt;
   }
 
-  bool GetDownlinkThroughputKbpsEstimate(int32_t* kbps) const override {
-    if (downlink_throughput_kbps_set_) {
-      *kbps = downlink_throughput_kbps_;
-      return true;
+  void set_transport_rtt(const base::TimeDelta& transport_rtt) {
+    transport_rtt_set_ = true;
+    transport_rtt_ = transport_rtt;
     }
-    return NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimate(kbps);
-  }
 
-  bool GetRecentMedianDownlinkThroughputKbps(const base::TimeTicks& start_time,
-                                             int32_t* kbps) const override {
-    if (downlink_throughput_kbps_set_) {
-      *kbps = downlink_throughput_kbps_;
-      return true;
+    void set_recent_transport_rtt(const base::TimeDelta& recent_transport_rtt) {
+      recent_transport_rtt_set_ = true;
+      recent_transport_rtt_ = recent_transport_rtt;
     }
-    return NetworkQualityEstimator::GetRecentMedianDownlinkThroughputKbps(
-        start_time, kbps);
-  }
 
-  using NetworkQualityEstimator::SetTickClockForTesting;
-  using NetworkQualityEstimator::ReadCachedNetworkQualityEstimate;
-  using NetworkQualityEstimator::OnConnectionTypeChanged;
+    bool GetTransportRTTEstimate(base::TimeDelta* rtt) const override {

[bengr, 2016/06/01 16:55:30]

Add comments saying what you're overriding.

[tbansal1, 2016/06/01 21:49:02]

Done.

+      if (transport_rtt_set_) {
+        *rtt = transport_rtt_;
+        return true;
+      }
+      return NetworkQualityEstimator::GetTransportRTTEstimate(rtt);
+    }
 
- private:
-  // NetworkQualityEstimator implementation that returns the overridden network
-  // id (instead of invoking platform APIs).
-  NetworkQualityEstimator::NetworkID GetCurrentNetworkID() const override {
-    return NetworkQualityEstimator::NetworkID(current_network_type_,
-                                              current_network_id_);
-  }
+    bool GetRecentTransportRTTMedian(const base::TimeTicks& start_time,
+                                     base::TimeDelta* rtt) const override {
+      if (recent_transport_rtt_set_) {
+        *rtt = recent_transport_rtt_;
+        return true;
+      }
+      return NetworkQualityEstimator::GetRecentTransportRTTMedian(start_time,
+                                                                  rtt);
+    }
 
-  bool effective_connection_type_set_;
-  EffectiveConnectionType effective_connection_type_;
+    void set_downlink_throughput_kbps(int32_t downlink_throughput_kbps) {
+      downlink_throughput_kbps_set_ = true;
+      downlink_throughput_kbps_ = downlink_throughput_kbps;
+    }
 
-  NetworkChangeNotifier::ConnectionType current_network_type_;
-  std::string current_network_id_;
+    bool GetDownlinkThroughputKbpsEstimate(int32_t* kbps) const override {
+      if (downlink_throughput_kbps_set_) {
+        *kbps = downlink_throughput_kbps_;
+        return true;
+      }
+      return NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimate(kbps);
+    }
 
-  bool http_rtt_set_;
-  base::TimeDelta http_rtt_;
+    bool GetRecentMedianDownlinkThroughputKbps(
+        const base::TimeTicks& start_time,
+        int32_t* kbps) const override {
+      if (downlink_throughput_kbps_set_) {
+        *kbps = downlink_throughput_kbps_;
+        return true;
+      }
+      return NetworkQualityEstimator::GetRecentMedianDownlinkThroughputKbps(
+          start_time, kbps);
+    }
 
-  bool downlink_throughput_kbps_set_;
-  int32_t downlink_throughput_kbps_;
+    void SetAccuracyRecordingIntervals(
+        const std::vector<base::TimeDelta>& accuracy_recording_intervals) {
+      accuracy_recording_intervals_set_ = true;
+      accuracy_recording_intervals_ = accuracy_recording_intervals;
+    }
 
-  // Embedded server used for testing.
-  EmbeddedTestServer embedded_test_server_;
+    const std::vector<base::TimeDelta>& GetAccuracyRecordingIntervals()
+        const override {
+      if (accuracy_recording_intervals_set_)
+        return accuracy_recording_intervals_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestNetworkQualityEstimator);
+      return NetworkQualityEstimator::GetAccuracyRecordingIntervals();
+    }
+
+    using NetworkQualityEstimator::SetTickClockForTesting;
+    using NetworkQualityEstimator::ReadCachedNetworkQualityEstimate;
+    using NetworkQualityEstimator::OnConnectionTypeChanged;
+
+   private:
+    // NetworkQualityEstimator implementation that returns the overridden
+    // network
+    // id (instead of invoking platform APIs).
+    NetworkQualityEstimator::NetworkID GetCurrentNetworkID() const override {
+      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 accuracy_recording_intervals_set_;
+    std::vector<base::TimeDelta> accuracy_recording_intervals_;
+
+    bool http_rtt_set_;
+    base::TimeDelta http_rtt_;
+
+    bool recent_http_rtt_set_;
+    base::TimeDelta recent_http_rtt_;
+
+    bool transport_rtt_set_;
+    base::TimeDelta transport_rtt_;
+
+    bool recent_transport_rtt_set_;
+    base::TimeDelta recent_transport_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_;
   }
 
@@ skipping 298 matching lines @@
   const struct {
     int32_t rtt_msec;
     NetworkQualityEstimator::EffectiveConnectionType expected_conn_type;
   } tests[] = {
       {5000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       {20, NetworkQualityEstimator::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));
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // 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);
 
@@ skipping 49 matching lines @@
       {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},
   };
 
   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));
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that |GetEffectiveConnectionType| returns correct connection type when
 // both RTT and throughput thresholds are specified in the variation params.
 TEST(NetworkQualityEstimatorTest, ObtainThresholdsRTTandThroughput) {
   std::map<std::string, std::string> variation_params;
 
   variation_params["Offline.ThresholdMedianHttpRTTMsec"] = "4000";
@@ skipping 39 matching lines @@
       // Set both RTT and throughput. RTT is the bottleneck.
       {3000, 25000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
       {700, 25000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
       // Set throughput to an invalid value.
       {3000, 0, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
       {700, 0, NetworkQualityEstimator::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);
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests if |weight_multiplier_per_second_| is set to correct value for various
 // values of half life parameter.
 TEST(NetworkQualityEstimatorTest, HalfLifeParam) {
   std::map<std::string, std::string> variation_params;
 
@@ skipping 799 matching lines @@
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile50.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile90.Unknown", 1);
   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);
 }
 
+// Tests if the NQE accuracy metrics are recorded properly.
+TEST(NetworkQualityEstimatorTest, RecordAccuracyNonZeroDelay) {
+  const int expected_rtt_msec = 100;
+
+  const base::TimeDelta accuracy_recording_delays[] = {
+      base::TimeDelta::FromSeconds(0), base::TimeDelta::FromSeconds(1),
+  };
+
+  const struct {
+    base::TimeDelta rtt;
+    base::TimeDelta recent_rtt;
+  } tests[] = {
+      {base::TimeDelta::FromMilliseconds(expected_rtt_msec),
+       base::TimeDelta::FromMilliseconds(expected_rtt_msec)},
+      {base::TimeDelta::FromMilliseconds(expected_rtt_msec + 1),
+       base::TimeDelta::FromMilliseconds(expected_rtt_msec)},
+      {base::TimeDelta::FromMilliseconds(expected_rtt_msec - 1),
+       base::TimeDelta::FromMilliseconds(expected_rtt_msec)},
+  };
+
+  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));
+
+      std::map<std::string, std::string> variation_params;
+      TestNetworkQualityEstimator estimator(variation_params);
+      estimator.SetTickClockForTesting(std::move(tick_clock));
+
+      std::vector<base::TimeDelta> accuracy_recording_intervals;
+      accuracy_recording_intervals.push_back(accuracy_recording_delay);
+      estimator.SetAccuracyRecordingIntervals(accuracy_recording_intervals);
+
+      // RTT is higher than threshold. Network is slow.
+      // Network was predicted to be slow and actually was slow.
+      estimator.set_http_rtt(test.rtt);
+      estimator.set_recent_http_rtt(test.recent_rtt);
+      estimator.set_transport_rtt(test.rtt);
+      estimator.set_recent_transport_rtt(test.recent_rtt);
+
+      base::HistogramTester histogram_tester;
+
+      TestDelegate test_delegate;
+      TestURLRequestContext context(true);
+      context.set_network_quality_estimator(&estimator);
+      context.Init();
+
+      // Start a main-frame request which should cause network quality estimator
+      // to record accuracy UMA.
+      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();
+
+      if (accuracy_recording_delay != base::TimeDelta()) {
+        tick_clock_ptr->Advance(accuracy_recording_delay);
+
+        // Sleep to ensure that the delayed task is posted.
+        base::PlatformThread::Sleep(accuracy_recording_delay);
+        base::RunLoop().RunUntilIdle();
+      }
+
+      const int diff = std::abs(test.rtt.InMilliseconds() -
+                                test.recent_rtt.InMilliseconds());
+      const std::string diff_value =
+          base::IntToString(accuracy_recording_delay.InSeconds());
+
+      if (test.rtt >= test.recent_rtt) {
+        histogram_tester.ExpectUniqueSample(
+            "NQE.Accuracy.HttpRTT.EstimatedActualDiff." + diff_value +
+                ".60_140",
+            diff, 1);
+        histogram_tester.ExpectTotalCount(
+            "NQE.Accuracy.HttpRTT.ActualEstimatedDiff." + diff_value +
+                ".60_140",
+            0);
+        histogram_tester.ExpectUniqueSample(
+            "NQE.Accuracy.TransportRTT.EstimatedActualDiff." + diff_value +
+                ".60_140",
+            diff, 1);
+        histogram_tester.ExpectTotalCount(
+            "NQE.Accuracy.TransportRTT.ActualEstimatedDiff." + diff_value +
+                ".60_140",
+            0);
+      } else {
+        histogram_tester.ExpectTotalCount(
+            "NQE.Accuracy.HttpRTT.EstimatedActualDiff." + diff_value +
+                ".60_140",
+            0);
+        histogram_tester.ExpectUniqueSample(
+            "NQE.Accuracy.HttpRTT.ActualEstimatedDiff." + diff_value +
+                ".60_140",
+            diff, 1);
+        histogram_tester.ExpectTotalCount(
+            "NQE.Accuracy.TransportRTT.EstimatedActualDiff." + diff_value +
+                ".60_140",
+            0);
+        histogram_tester.ExpectUniqueSample(
+            "NQE.Accuracy.TransportRTT.ActualEstimatedDiff." + diff_value +
+                ".60_140",
+            diff, 1);
+      }
+    }
+  }
+}
+
 }  // namespace net