Expose RTT and downlink bandwidth using experimental Javascript API

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

 /*
  * Copyright (C) 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 40 matching lines @@
     : notifier_(notifier) {
   DCHECK(IsMainThread());
   before_ = notifier_.has_override_ ? notifier_.override_ : notifier_.state_;
 }
 
 NetworkStateNotifier::ScopedNotifier::~ScopedNotifier() {
   DCHECK(IsMainThread());
   const NetworkState& after =
       notifier_.has_override_ ? notifier_.override_ : notifier_.state_;
   if ((after.type != before_.type ||
-       after.max_bandwidth_mbps != before_.max_bandwidth_mbps) &&
+       after.max_bandwidth_mbps != before_.max_bandwidth_mbps ||
+       after.http_rtt != before_.http_rtt ||
+       after.transport_rtt != before_.transport_rtt ||
+       after.downlink_throughput_mbps != before_.downlink_throughput_mbps) &&
       before_.connection_initialized) {
     notifier_.NotifyObservers(notifier_.connection_observers_,
                               ObserverType::CONNECTION_TYPE, after);
   }
   if (after.on_line != before_.on_line && before_.on_line_initialized) {
     notifier_.NotifyObservers(notifier_.on_line_state_observers_,
                               ObserverType::ONLINE_STATE, after);
   }
 }
 
@@ skipping 12 matching lines @@
   DCHECK(IsMainThread());
   ScopedNotifier notifier(*this);
   {
     MutexLocker locker(mutex_);
     state_.connection_initialized = true;
     state_.type = type;
     state_.max_bandwidth_mbps = max_bandwidth_mbps;
   }
 }
 
+void NetworkStateNotifier::SetWebNetworkQuality(int http_rtt_msec,
+                                                int transport_rtt_msec,
+                                                int downlink_throughput_kbps) {
+  DCHECK(IsMainThread());
+  ScopedNotifier notifier(*this);
+  {
+    MutexLocker locker(mutex_);
+
+    state_.http_rtt = http_rtt_msec < 0
+                          ? Optional<TimeDelta>()
+                          : TimeDelta::FromMilliseconds(http_rtt_msec);
+
+    state_.transport_rtt =
+        transport_rtt_msec < 0
+            ? Optional<TimeDelta>()
+            : TimeDelta::FromMilliseconds(transport_rtt_msec);
+
+    state_.downlink_throughput_mbps =
+        downlink_throughput_kbps < 0
+            ? Optional<double>()
+            : static_cast<double>(downlink_throughput_kbps) / 1000;
+  }
+}
+
 void NetworkStateNotifier::AddConnectionObserver(
     NetworkStateObserver* observer,
     PassRefPtr<WebTaskRunner> task_runner) {
   AddObserver(connection_observers_, observer, std::move(task_runner));
 }
 
 void NetworkStateNotifier::AddOnLineObserver(
     NetworkStateObserver* observer,
     PassRefPtr<WebTaskRunner> task_runner) {
   AddObserver(on_line_state_observers_, observer, std::move(task_runner));
@@ skipping 69 matching lines @@
 
   for (size_t i = 0; i < observer_list->observers.size(); ++i) {
     // Observers removed during iteration are zeroed out, skip them.
     if (!observer_list->observers[i])
       continue;
     switch (type) {
       case ObserverType::ONLINE_STATE:
         observer_list->observers[i]->OnLineStateChange(state.on_line);
         continue;
       case ObserverType::CONNECTION_TYPE:
-        observer_list->observers[i]->ConnectionChange(state.type,
-                                                      state.max_bandwidth_mbps);
+        observer_list->observers[i]->ConnectionChange(
+            state.type, state.max_bandwidth_mbps, state.http_rtt,
+            state.transport_rtt, state.downlink_throughput_mbps);
         continue;
     }
     NOTREACHED();
   }
 
   observer_list->iterating = false;
 
   if (!observer_list->zeroed_observers.IsEmpty())
     CollectZeroedObservers(*map, observer_list, std::move(task_runner));
 }
@@ skipping 58 matching lines @@
 
   list->zeroed_observers.clear();
 
   if (list->observers.IsEmpty()) {
     MutexLocker locker(mutex_);
     map.erase(task_runner);  // deletes list
   }
 }
 
 }  // namespace blink