Notify NQE of TCP RTT values

net/base/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/base/network_quality_estimator.h"
 
 #include <stdint.h>

[bengr, 2016/02/08 18:51:14]

Add a blank line.

[tbansal1, 2016/02/08 21:33:26]

Done.

 #include <limits>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_samples.h"
@@ skipping 17 matching lines @@
 
 // Helps in setting the current network type and id.
 class TestNetworkQualityEstimator : public net::NetworkQualityEstimator {
  public:
   TestNetworkQualityEstimator(
       const std::map<std::string, std::string>& variation_params,
       scoped_ptr<net::ExternalEstimateProvider> external_estimate_provider)
       : NetworkQualityEstimator(std::move(external_estimate_provider),
                                 variation_params,
                                 true,
-                                true) {
+                                true),
+        watcher_reset_notification_received_(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)
@@ skipping 21 matching lines @@
     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 OnWatcherReset() override {
+    watcher_reset_notification_received_ = true;
+  }
+
+  bool watcher_reset_notification_received() const {
+    return watcher_reset_notification_received_;
+  }
+
   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_);
   }
 
   net::NetworkChangeNotifier::ConnectionType current_network_type_;
   std::string current_network_id_;
 
   // Embedded server used for testing.
   net::EmbeddedTestServer embedded_test_server_;
 
+  bool watcher_reset_notification_received_;
+
   DISALLOW_COPY_AND_ASSIGN(TestNetworkQualityEstimator);
 };
 
 class TestRTTObserver : public net::NetworkQualityEstimator::RTTObserver {
  public:
   struct Observation {
     Observation(int32_t ms,
                 const base::TimeTicks& ts,
                 net::NetworkQualityEstimator::ObservationSource src)
         : rtt_ms(ms), timestamp(ts), source(src) {}
@@ skipping 972 matching lines @@
   quic_watcher->OnUpdatedRTTAvailable(quic_rtt);
 
   EXPECT_EQ(4U, rtt_observer.observations().size());
   EXPECT_EQ(2U, throughput_observer.observations().size());
 
   EXPECT_EQ(tcp_rtt.InMilliseconds(), rtt_observer.observations().at(2).rtt_ms);
   EXPECT_EQ(quic_rtt.InMilliseconds(),
             rtt_observer.observations().at(3).rtt_ms);
 }
 
+// TestTCPSocketRTT requires kernel support for tcp_info struct, and so it is
+// enabled only on the Linux platform.
+#if defined(OS_LINUX)
+#define MAYBE_TestTCPSocketRTT TestTCPSocketRTT
+#else
+#define MAYBE_TestTCPSocketRTT DISABLED_TestTCPSocketRTT
+#endif
+// Tests that TCP RTTs are notified by the TCP socket to the Network quality

[bengr, 2016/02/08 18:51:14]

Capitalize "Quality Estimator."

[tbansal1, 2016/02/08 21:33:26]

Done.

+// estimator, which in turn notifies to the registered RTT observers.
+TEST(NetworkQualityEstimatorTest, MAYBE_TestTCPSocketRTT) {
+  TestRTTObserver rtt_observer;
+  std::map<std::string, std::string> variation_params;

[bengr, 2016/02/08 18:51:14]

#include <string>

[tbansal1, 2016/02/08 21:33:26]

Done.

+  TestNetworkQualityEstimator estimator(variation_params);
+  estimator.AddRTTObserver(&rtt_observer);
+
+  TestDelegate test_delegate;
+  TestURLRequestContext context(true);
+  context.set_network_quality_estimator(&estimator);
+
+  scoped_ptr<HttpNetworkSession::Params> params(new HttpNetworkSession::Params);

[bengr, 2016/02/08 18:51:14]

#include "net/http/http_network_session.h"

[tbansal1, 2016/02/08 21:33:26]

Done.

+  // |estimator| should be notified of TCP RTT observations.
+  params->socket_performance_watcher_factory = &estimator;
+  context.set_http_network_session_params(std::move(params));
+  context.Init();
+
+  EXPECT_EQ(0U, rtt_observer.observations().size());
+  EXPECT_FALSE(estimator.watcher_reset_notification_received());
+
+  // 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 (auto observation : rtt_observer.observations()) {
+      if (observation.source == NetworkQualityEstimator::TCP)
+        before_count_tcp_rtt_observations++;

[bengr, 2016/02/08 18:51:14]

++before_count_tcp_rtt_observations;

[tbansal1, 2016/02/08 21:33:26]

Done.

+    }

[bengr, 2016/02/08 18:51:14]

Can you expect also that at some point, rtt_observer.observations().size() == 2?
Can you write a test where there's a deterministic number of observations?

[tbansal1, 2016/02/08 21:33:26]

I do not think it is possible to write a test with deterministic number of
observations. Reason being that TCP may break the payload arbitrarily. It might
break a 100 byte webpage into 100 packets (each of 1 byte). There are no
guarantees.

It is possible to write test that generates more than 1 RTT observation for a
single URL request. e.g., by creating URL request that fetches a large webpage
from the embedded test web server.

[bengr, 2016/02/08 23:42:06]

Acknowledged.

+
+    scoped_ptr<URLRequest> request(context.CreateRequest(
+        estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
+    request->Start();

[bengr, 2016/02/08 18:51:14]

#include "net/url_request/url_request.h"

[tbansal1, 2016/02/08 21:33:26]

Done.

+    base::RunLoop().Run();
+
+    size_t after_count_tcp_rtt_observations = 0;
+    for (auto observation : rtt_observer.observations()) {
+      if (observation.source == NetworkQualityEstimator::TCP)
+        after_count_tcp_rtt_observations++;

[bengr, 2016/02/08 18:51:14]

++after_count_tcp_rtt_observations;

[tbansal1, 2016/02/08 21:33:26]

Done.

+    }
+    EXPECT_LT(before_count_tcp_rtt_observations,
+              after_count_tcp_rtt_observations)
+        << i;
+  }
+
+  EXPECT_TRUE(estimator.watcher_reset_notification_received());
+}
+
 }  // namespace net