Expose RTT and downlink bandwidth using experimental Javascript API

third_party/WebKit/Source/platform/network/NetworkStateNotifierTest.cpp

 /*
  * Copyright (c) 2014, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 28 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 using scheduler::FakeWebTaskRunner;
 
 namespace {
 const double kNoneMaxBandwidthMbps = 0.0;
 const double kBluetoothMaxBandwidthMbps = 1.0;
 const double kEthernetMaxBandwidthMbps = 2.0;
+const int kEthernetHttpRtt = 50;
+const int kEthernetTransportRtt = 25;
+const double kEthernetThroughputMbps = 75.0;
+const int kUnknownRtt = -1;
+const double kUnknownThroughputMbps = -1.0;
 }
 
 class StateObserver : public NetworkStateNotifier::NetworkStateObserver {
  public:
   StateObserver()
       : observed_type_(kWebConnectionTypeNone),
         observed_max_bandwidth_mbps_(0.0),
+        observed_http_rtt_msec_(kUnknownRtt),
+        observed_transport_rtt_msec_(kUnknownRtt),
+        observed_downlink_throughput_mbps_(kUnknownThroughputMbps),
         observed_on_line_state_(false),
         callback_count_(0) {}
 
   virtual void ConnectionChange(WebConnectionType type,
-                                double max_bandwidth_mbps) {
+                                double max_bandwidth_mbps,
+                                int http_rtt_msec,
+                                int transport_rtt_msec,
+                                double downlink_throughput_mbps) {
     observed_type_ = type;
     observed_max_bandwidth_mbps_ = max_bandwidth_mbps;
+    observed_http_rtt_msec_ = http_rtt_msec;
+    observed_transport_rtt_msec_ = transport_rtt_msec;
+    observed_downlink_throughput_mbps_ = downlink_throughput_mbps;
     callback_count_ += 1;
 
     if (closure_)
       (*closure_)();
   }
 
   virtual void OnLineStateChange(bool on_line) {
     observed_on_line_state_ = on_line;
     callback_count_ += 1;
 
     if (closure_)
       (*closure_)();
   }
 
   WebConnectionType ObservedType() const { return observed_type_; }
   double ObservedMaxBandwidth() const { return observed_max_bandwidth_mbps_; }
+  double ObservedHttpRttMsec() const { return observed_http_rtt_msec_; }
+  double ObservedTransportRttMsec() const {
+    return observed_transport_rtt_msec_;
+  }
+  double ObservedDownlinkThroughputMbps() const {
+    return observed_downlink_throughput_mbps_;
+  }
   bool ObservedOnLineState() const { return observed_on_line_state_; }
   int CallbackCount() const { return callback_count_; }
 
   void SetNotificationCallback(std::unique_ptr<WTF::Closure> closure) {
     closure_ = std::move(closure);
   }
 
  private:
   std::unique_ptr<WTF::Closure> closure_;
   WebConnectionType observed_type_;
   double observed_max_bandwidth_mbps_;
+  int observed_http_rtt_msec_;
+  int observed_transport_rtt_msec_;
+  double observed_downlink_throughput_mbps_;
   bool observed_on_line_state_;
   int callback_count_;
 };
 
 class NetworkStateNotifierTest : public ::testing::Test {
  public:
   NetworkStateNotifierTest()
       : task_runner_(AdoptRef(new FakeWebTaskRunner())),
         task_runner2_(AdoptRef(new FakeWebTaskRunner())) {
     // Initialize connection, so that future calls to setWebConnection issue
@@ skipping 10 matching lines @@
     task_runner_ = nullptr;
     task_runner2_ = nullptr;
   }
 
  protected:
   void RunPendingTasks() {
     task_runner_->RunUntilIdle();
     task_runner2_->RunUntilIdle();
   }
 
-  void SetConnection(WebConnectionType type, double max_bandwidth_mbps) {
+  void SetConnection(WebConnectionType type,
+                     double max_bandwidth_mbps,
+                     int http_rtt_msec,
+                     int transport_rtt_msec,
+                     int downlink_throughput_mbps) {
     notifier_.SetWebConnection(type, max_bandwidth_mbps);
+    notifier_.SetWebNetworkQuality(http_rtt_msec, transport_rtt_msec,
+                                   downlink_throughput_mbps * 1000);
     RunPendingTasks();
   }
   void SetOnLine(bool on_line) {
     notifier_.SetOnLine(on_line);
     RunPendingTasks();
   }
 
   void AddObserverOnNotification(StateObserver* observer,
                                  StateObserver* observer_to_add) {
     observer->SetNotificationCallback(
         Bind(&NetworkStateNotifier::AddConnectionObserver,
              WTF::Unretained(&notifier_), WTF::Unretained(observer_to_add),
              WTF::Unretained(GetTaskRunner())));
   }
 
   void RemoveObserverOnNotification(StateObserver* observer,
                                     StateObserver* observer_to_remove) {
     observer->SetNotificationCallback(
         Bind(&NetworkStateNotifier::RemoveConnectionObserver,
              WTF::Unretained(&notifier_), WTF::Unretained(observer_to_remove),
              WTF::Unretained(GetTaskRunner())));
   }
 
   bool VerifyObservations(const StateObserver& observer,
                           WebConnectionType type,
-                          double max_bandwidth_mbps) {
-    EXPECT_EQ(observer.ObservedType(), type);
-    EXPECT_EQ(observer.ObservedMaxBandwidth(), max_bandwidth_mbps);
+                          double max_bandwidth_mbps,
+                          double http_rtt_msec,
+                          double transport_rtt_msec,
+                          double downlink_throughput_mbps) const {
+    EXPECT_EQ(type, observer.ObservedType());
+    EXPECT_EQ(max_bandwidth_mbps, observer.ObservedMaxBandwidth());
+    EXPECT_EQ(http_rtt_msec, observer.ObservedHttpRttMsec());
+    EXPECT_EQ(transport_rtt_msec, observer.ObservedTransportRttMsec());
+    EXPECT_EQ(downlink_throughput_mbps,
+              observer.ObservedDownlinkThroughputMbps());
+
     return observer.ObservedType() == type &&
-           observer.ObservedMaxBandwidth() == max_bandwidth_mbps;
+           observer.ObservedMaxBandwidth() == max_bandwidth_mbps &&
+           observer.ObservedHttpRttMsec() == http_rtt_msec &&
+           observer.ObservedTransportRttMsec() == transport_rtt_msec &&
+           observer.ObservedDownlinkThroughputMbps() ==
+               downlink_throughput_mbps;
   }
 
   RefPtr<FakeWebTaskRunner> task_runner_;
   RefPtr<FakeWebTaskRunner> task_runner2_;
   NetworkStateNotifier notifier_;
 };
 
 TEST_F(NetworkStateNotifierTest, AddObserver) {
   StateObserver observer;
   notifier_.AddConnectionObserver(&observer, GetTaskRunner());
   EXPECT_TRUE(VerifyObservations(observer, kWebConnectionTypeNone,
-                                 kNoneMaxBandwidthMbps));
+                                 kNoneMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kEthernetHttpRtt, kEthernetTransportRtt,
+                kEthernetThroughputMbps);
+  EXPECT_TRUE(VerifyObservations(
+      observer, kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+      kEthernetHttpRtt, kEthernetTransportRtt, kEthernetThroughputMbps));
+  EXPECT_EQ(observer.CallbackCount(), 2);

[jkarlin, 2017/05/16 14:32:59]

Can you verify that changing just the connection type or just the throughput/rtt
incurs an increment of 1 to callback count?

[tbansal1, 2017/05/16 18:23:28]

Done.

 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
-  EXPECT_TRUE(VerifyObservations(observer, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
-  EXPECT_EQ(observer.CallbackCount(), 1);
   notifier_.RemoveConnectionObserver(&observer, GetTaskRunner());
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveObserver) {
   StateObserver observer1, observer2;
   notifier_.AddConnectionObserver(&observer1, GetTaskRunner());
   notifier_.RemoveConnectionObserver(&observer1, GetTaskRunner());
   notifier_.AddConnectionObserver(&observer2, GetTaskRunner());
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kEthernetHttpRtt, kEthernetTransportRtt,
+                kEthernetThroughputMbps);
+
   EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeNone,
-                                 kNoneMaxBandwidthMbps));
-  EXPECT_TRUE(VerifyObservations(observer2, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kNoneMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
+  EXPECT_TRUE(VerifyObservations(
+      observer2, kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+      kEthernetHttpRtt, kEthernetTransportRtt, kEthernetThroughputMbps));
   notifier_.RemoveConnectionObserver(&observer2, GetTaskRunner());
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveSoleObserver) {
   StateObserver observer1;
   notifier_.AddConnectionObserver(&observer1, GetTaskRunner());
   notifier_.RemoveConnectionObserver(&observer1, GetTaskRunner());
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kEthernetHttpRtt, kEthernetTransportRtt,
+                kEthernetThroughputMbps);
   EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeNone,
-                                 kNoneMaxBandwidthMbps));
+                                 kNoneMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, AddObserverWhileNotifying) {
   StateObserver observer1, observer2;
   notifier_.AddConnectionObserver(&observer1, GetTaskRunner());
   AddObserverOnNotification(&observer1, &observer2);
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kUnknownRtt, kUnknownRtt, kUnknownThroughputMbps);
   EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_TRUE(VerifyObservations(observer2, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   notifier_.RemoveConnectionObserver(&observer1, GetTaskRunner());
   notifier_.RemoveConnectionObserver(&observer2, GetTaskRunner());
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveSoleObserverWhileNotifying) {
   StateObserver observer1;
   notifier_.AddConnectionObserver(&observer1, GetTaskRunner());
   RemoveObserverOnNotification(&observer1, &observer1);
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kUnknownRtt, kUnknownRtt, kUnknownThroughputMbps);
   EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownRtt));
 
-  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps,
+                kUnknownRtt, kUnknownRtt, kUnknownThroughputMbps);
   EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveCurrentObserverWhileNotifying) {
   StateObserver observer1, observer2;
   notifier_.AddConnectionObserver(&observer1, GetTaskRunner());
   notifier_.AddConnectionObserver(&observer2, GetTaskRunner());
   RemoveObserverOnNotification(&observer1, &observer1);
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kUnknownRtt, kUnknownRtt, kUnknownThroughputMbps);
   EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_TRUE(VerifyObservations(observer2, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
 
-  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps,
+                kUnknownRtt, kUnknownRtt, kUnknownThroughputMbps);
   EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_TRUE(VerifyObservations(observer2, kWebConnectionTypeEthernet,
-                                 kEthernetMaxBandwidthMbps));
+                                 kEthernetMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
 
   notifier_.RemoveConnectionObserver(&observer1, GetTaskRunner());
   notifier_.RemoveConnectionObserver(&observer2, GetTaskRunner());
 }
 
 TEST_F(NetworkStateNotifierTest, RemovePastObserverWhileNotifying) {
   StateObserver observer1, observer2;
   notifier_.AddConnectionObserver(&observer1, GetTaskRunner());
   notifier_.AddConnectionObserver(&observer2, GetTaskRunner());
   RemoveObserverOnNotification(&observer2, &observer1);
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kUnknownRtt, kUnknownRtt, kUnknownThroughputMbps);
   EXPECT_EQ(observer1.ObservedType(), kWebConnectionTypeBluetooth);
   EXPECT_EQ(observer2.ObservedType(), kWebConnectionTypeBluetooth);
 
-  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps,
+                kUnknownRtt, kUnknownRtt, kUnknownThroughputMbps);
   EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_TRUE(VerifyObservations(observer2, kWebConnectionTypeEthernet,
-                                 kEthernetMaxBandwidthMbps));
+                                 kEthernetMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
 
   notifier_.RemoveConnectionObserver(&observer1, GetTaskRunner());
   notifier_.RemoveConnectionObserver(&observer2, GetTaskRunner());
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveFutureObserverWhileNotifying) {
   StateObserver observer1, observer2, observer3;
   notifier_.AddConnectionObserver(&observer1, GetTaskRunner());
   notifier_.AddConnectionObserver(&observer2, GetTaskRunner());
   notifier_.AddConnectionObserver(&observer3, GetTaskRunner());
   RemoveObserverOnNotification(&observer1, &observer2);
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kUnknownRtt, kUnknownRtt, kUnknownThroughputMbps);
   EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_TRUE(VerifyObservations(observer2, kWebConnectionTypeNone,
-                                 kNoneMaxBandwidthMbps));
+                                 kNoneMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_TRUE(VerifyObservations(observer3, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
 
   notifier_.RemoveConnectionObserver(&observer1, GetTaskRunner());
   notifier_.RemoveConnectionObserver(&observer2, GetTaskRunner());
   notifier_.RemoveConnectionObserver(&observer3, GetTaskRunner());
 }
 
 TEST_F(NetworkStateNotifierTest, MultipleContextsAddObserver) {
   StateObserver observer1, observer2;
   notifier_.AddConnectionObserver(&observer1, GetTaskRunner());
   notifier_.AddConnectionObserver(&observer2, GetTaskRunner2());
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
-  EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
-  EXPECT_TRUE(VerifyObservations(observer2, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kEthernetHttpRtt, kEthernetTransportRtt,
+                kEthernetThroughputMbps);
+  EXPECT_TRUE(VerifyObservations(
+      observer1, kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+      kEthernetHttpRtt, kEthernetTransportRtt, kEthernetThroughputMbps));
+  EXPECT_TRUE(VerifyObservations(
+      observer2, kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+      kEthernetHttpRtt, kEthernetTransportRtt, kEthernetThroughputMbps));
 
   notifier_.RemoveConnectionObserver(&observer1, GetTaskRunner());
   notifier_.RemoveConnectionObserver(&observer2, GetTaskRunner2());
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveContext) {
   StateObserver observer1, observer2;
   notifier_.AddConnectionObserver(&observer1, GetTaskRunner());
   notifier_.AddConnectionObserver(&observer2, GetTaskRunner2());
   notifier_.RemoveConnectionObserver(&observer2, GetTaskRunner2());
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
-  EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kEthernetHttpRtt, kEthernetTransportRtt,
+                kEthernetThroughputMbps);
+  EXPECT_TRUE(VerifyObservations(
+      observer1, kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+      kEthernetHttpRtt, kEthernetTransportRtt, kEthernetThroughputMbps));
   EXPECT_TRUE(VerifyObservations(observer2, kWebConnectionTypeNone,
-                                 kNoneMaxBandwidthMbps));
+                                 kNoneMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
 
   notifier_.RemoveConnectionObserver(&observer1, GetTaskRunner());
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveAllContexts) {
   StateObserver observer1, observer2;
   notifier_.AddConnectionObserver(&observer1, GetTaskRunner());
   notifier_.AddConnectionObserver(&observer2, GetTaskRunner2());
   notifier_.RemoveConnectionObserver(&observer1, GetTaskRunner());
   notifier_.RemoveConnectionObserver(&observer2, GetTaskRunner2());
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kEthernetHttpRtt, kEthernetTransportRtt,
+                kEthernetThroughputMbps);
   EXPECT_TRUE(VerifyObservations(observer1, kWebConnectionTypeNone,
-                                 kNoneMaxBandwidthMbps));
+                                 kNoneMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_TRUE(VerifyObservations(observer2, kWebConnectionTypeNone,
-                                 kNoneMaxBandwidthMbps));
+                                 kNoneMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, SetOverride) {
   StateObserver observer;
   notifier_.AddConnectionObserver(&observer, GetTaskRunner());
 
   notifier_.SetOnLine(true);
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kUnknownRtt, kUnknownRtt, kUnknownThroughputMbps);
   EXPECT_TRUE(VerifyObservations(observer, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
+                                 kBluetoothMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_TRUE(notifier_.OnLine());
   EXPECT_EQ(kWebConnectionTypeBluetooth, notifier_.ConnectionType());
   EXPECT_EQ(kBluetoothMaxBandwidthMbps, notifier_.MaxBandwidth());
 
   notifier_.SetOverride(true, kWebConnectionTypeEthernet,
                         kEthernetMaxBandwidthMbps);
   RunPendingTasks();
   EXPECT_TRUE(VerifyObservations(observer, kWebConnectionTypeEthernet,
-                                 kEthernetMaxBandwidthMbps));
+                                 kEthernetMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_TRUE(notifier_.OnLine());
   EXPECT_EQ(kWebConnectionTypeEthernet, notifier_.ConnectionType());
   EXPECT_EQ(kEthernetMaxBandwidthMbps, notifier_.MaxBandwidth());
 
   // When override is active, calls to setOnLine and setConnection are temporary
   // ignored.
   notifier_.SetOnLine(false);
-  SetConnection(kWebConnectionTypeNone, kNoneMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeNone, kNoneMaxBandwidthMbps, kUnknownRtt,
+                kUnknownRtt, kUnknownThroughputMbps);
   RunPendingTasks();
   EXPECT_TRUE(VerifyObservations(observer, kWebConnectionTypeEthernet,
-                                 kEthernetMaxBandwidthMbps));
+                                 kEthernetMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_TRUE(notifier_.OnLine());
   EXPECT_EQ(kWebConnectionTypeEthernet, notifier_.ConnectionType());
   EXPECT_EQ(kEthernetMaxBandwidthMbps, notifier_.MaxBandwidth());
 
   notifier_.ClearOverride();
   RunPendingTasks();
   EXPECT_TRUE(VerifyObservations(observer, kWebConnectionTypeNone,
-                                 kNoneMaxBandwidthMbps));
+                                 kNoneMaxBandwidthMbps, kUnknownRtt,
+                                 kUnknownRtt, kUnknownThroughputMbps));
   EXPECT_FALSE(notifier_.OnLine());
   EXPECT_EQ(kWebConnectionTypeNone, notifier_.ConnectionType());
   EXPECT_EQ(kNoneMaxBandwidthMbps, notifier_.MaxBandwidth());
 
   notifier_.RemoveConnectionObserver(&observer, GetTaskRunner());
 }
 
 TEST_F(NetworkStateNotifierTest, NoExtraNotifications) {
   StateObserver observer;
   notifier_.AddConnectionObserver(&observer, GetTaskRunner());
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
-  EXPECT_TRUE(VerifyObservations(observer, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
-  EXPECT_EQ(observer.CallbackCount(), 1);
-
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
-  EXPECT_EQ(observer.CallbackCount(), 1);
-
-  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps);
-  EXPECT_TRUE(VerifyObservations(observer, kWebConnectionTypeEthernet,
-                                 kEthernetMaxBandwidthMbps));
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kEthernetHttpRtt, kEthernetTransportRtt,
+                kEthernetThroughputMbps);
+  EXPECT_TRUE(VerifyObservations(
+      observer, kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+      kEthernetHttpRtt, kEthernetTransportRtt, kEthernetThroughputMbps));
   EXPECT_EQ(observer.CallbackCount(), 2);
 
-  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps);
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kEthernetHttpRtt, kEthernetTransportRtt,
+                kEthernetThroughputMbps);
   EXPECT_EQ(observer.CallbackCount(), 2);
 
-  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
-  EXPECT_TRUE(VerifyObservations(observer, kWebConnectionTypeBluetooth,
-                                 kBluetoothMaxBandwidthMbps));
-  EXPECT_EQ(observer.CallbackCount(), 3);
+  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps,
+                kEthernetHttpRtt * 2, kEthernetTransportRtt * 2,
+                kEthernetThroughputMbps * 2);
+  EXPECT_TRUE(VerifyObservations(
+      observer, kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps,
+      kEthernetHttpRtt * 2, kEthernetTransportRtt * 2,
+      kEthernetThroughputMbps * 2));
+  EXPECT_EQ(observer.CallbackCount(), 4);
+
+  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps,
+                kEthernetHttpRtt * 2, kEthernetTransportRtt * 2,
+                kEthernetThroughputMbps * 2);
+  EXPECT_EQ(observer.CallbackCount(), 4);
+
+  SetConnection(kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+                kEthernetHttpRtt, kEthernetTransportRtt,
+                kEthernetThroughputMbps);
+  EXPECT_TRUE(VerifyObservations(
+      observer, kWebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps,
+      kEthernetHttpRtt, kEthernetTransportRtt, kEthernetThroughputMbps));
+  EXPECT_EQ(observer.CallbackCount(), 6);
 
   notifier_.RemoveConnectionObserver(&observer, GetTaskRunner());
 }
 
 TEST_F(NetworkStateNotifierTest, NoNotificationOnInitialization) {
   NetworkStateNotifier notifier;
   StateObserver observer;
 
   notifier.AddConnectionObserver(&observer, GetTaskRunner());
   notifier.AddOnLineObserver(&observer, GetTaskRunner());
@@ skipping 62 matching lines @@
   EXPECT_EQ(observer2.CallbackCount(), 1);
 
   notifier_.SetOnLine(false);
   RunPendingTasks();
   EXPECT_FALSE(observer1.ObservedOnLineState());
   EXPECT_FALSE(observer2.ObservedOnLineState());
   EXPECT_EQ(observer1.CallbackCount(), 2);
   EXPECT_EQ(observer2.CallbackCount(), 2);
 
   notifier_.SetOnLine(true);
-  notifier_.SetWebConnection(kWebConnectionTypeEthernet,
-                             kEthernetMaxBandwidthMbps);
-  RunPendingTasks();
+  SetConnection(kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps,
+                kEthernetHttpRtt, kEthernetTransportRtt,
+                kEthernetThroughputMbps);
+
   EXPECT_TRUE(observer1.ObservedOnLineState());
   EXPECT_TRUE(observer2.ObservedOnLineState());
-  EXPECT_TRUE(VerifyObservations(observer2, kWebConnectionTypeEthernet,
-                                 kEthernetMaxBandwidthMbps));
+  EXPECT_TRUE(VerifyObservations(
+      observer2, kWebConnectionTypeEthernet, kEthernetMaxBandwidthMbps,
+      kEthernetHttpRtt, kEthernetTransportRtt, kEthernetThroughputMbps));
   EXPECT_EQ(observer1.CallbackCount(), 3);
-  EXPECT_EQ(observer2.CallbackCount(), 4);
+  EXPECT_EQ(observer2.CallbackCount(), 5);
 
   notifier_.RemoveConnectionObserver(&observer1, GetTaskRunner());
   notifier_.RemoveConnectionObserver(&observer2, GetTaskRunner());
 }
 
 }  // namespace blink