Expose RTT and downlink bandwidth using experimental Javascript API

third_party/WebKit/Source/modules/netinfo/NetworkInformation.cpp

 // Copyright 2014 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 "modules/netinfo/NetworkInformation.h"
 
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/Event.h"
 #include "modules/EventTargetModules.h"
@@ skipping 22 matching lines @@
       return "other";
     case kWebConnectionTypeNone:
       return "none";
     case kWebConnectionTypeUnknown:
       return "unknown";
   }
   NOTREACHED();
   return "none";
 }
 
+// Rounds |rtt_msec| to the nearest 25 milliseconds as per the NetInfo spec.
+int roundRtt(int rtt_msec) {
+  if (rtt_msec < 0)
+    return rtt_msec;
+  return std::round(static_cast<double>(rtt_msec) / 25) * 25;
+}
+
+// Rounds |downlink_mbps| to the nearest 25 kbps as per the NetInfo spec. The
+// returned value is in Mbps.
+double roundMbps(double downlink_mbps) {
+  if (downlink_mbps < 0)
+    return downlink_mbps;
+  double downlink_kbps = downlink_mbps * 1000;
+  double downlink_kbps_rounded = std::round(downlink_kbps / 25) * 25;
+  return downlink_kbps_rounded / 1000;
+}
+
 }  // namespace
 
 NetworkInformation* NetworkInformation::Create(ExecutionContext* context) {
   return new NetworkInformation(context);
 }
 
 NetworkInformation::~NetworkInformation() {
   DCHECK(!observing_);
 }
 
 String NetworkInformation::type() const {
   // m_type is only updated when listening for events, so ask
   // networkStateNotifier if not listening (crbug.com/379841).
   if (!observing_)
     return ConnectionTypeToString(GetNetworkStateNotifier().ConnectionType());
 
   // If observing, return m_type which changes when the event fires, per spec.
   return ConnectionTypeToString(type_);
 }
 
 double NetworkInformation::downlinkMax() const {
   if (!observing_)
     return GetNetworkStateNotifier().MaxBandwidth();
 
   return downlink_max_mbps_;
 }
 
+double NetworkInformation::rtt() const {
+  if (!observing_)
+    return roundRtt(GetNetworkStateNotifier().TransportRttMsec());
+
+  return transport_rtt_msec_;
+}
+
+double NetworkInformation::downlink() const {
+  if (!observing_)
+    return roundMbps(GetNetworkStateNotifier().DownlinkThroughputMbps());
+
+  return downlink_mbps_;
+}
+
 void NetworkInformation::ConnectionChange(WebConnectionType type,
-                                          double downlink_max_mbps) {
+                                          double downlink_max_mbps,
+                                          int http_rtt_msec,
+                                          int transport_rtt_msec,
+                                          double downlink_mbps) {
   DCHECK(GetExecutionContext()->IsContextThread());
 
+  transport_rtt_msec_ = roundRtt(transport_rtt_msec);
+  downlink_mbps_ = roundMbps(downlink_mbps);
+  // TODO(tbansal): https://crbug.com/719108. Dispatch |change| event if the
+  // expected network quality has changed.
+
   // This can happen if the observer removes and then adds itself again
-  // during notification.
+  // during notification, or if HTTP RTT was the only metric that changed.
   if (type_ == type && downlink_max_mbps_ == downlink_max_mbps)
     return;
 
   type_ = type;
   downlink_max_mbps_ = downlink_max_mbps;
+
   DispatchEvent(Event::Create(EventTypeNames::typechange));
 
   if (RuntimeEnabledFeatures::netInfoDownlinkMaxEnabled())
     DispatchEvent(Event::Create(EventTypeNames::change));
 }
 
 const AtomicString& NetworkInformation::InterfaceName() const {
   return EventTargetNames::NetworkInformation;
 }
 
@@ skipping 61 matching lines @@
       downlink_max_mbps_(GetNetworkStateNotifier().MaxBandwidth()),
       observing_(false),
       context_stopped_(false) {}
 
 DEFINE_TRACE(NetworkInformation) {
   EventTargetWithInlineData::Trace(visitor);
   ContextLifecycleObserver::Trace(visitor);
 }
 
 }  // namespace blink