NetInfo default values

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 <limits>
 
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/TaskRunnerHelper.h"
@@ skipping 42 matching lines @@
     case WebEffectiveConnectionType::kType2G:
       return "2g";
     case WebEffectiveConnectionType::kType3G:
       return "3g";
   }
   NOTREACHED();
   return "4g";
 }
 
 // Rounds |rtt_msec| to the nearest 25 milliseconds as per the NetInfo spec.
-unsigned long RoundRtt(const Optional<TimeDelta>& rtt) {
+// If |rtt| has no value, |type| is used to determine a default value.
+unsigned long RoundTransportRtt(WebConnectionType type,
+                                const Optional<TimeDelta>& rtt) {
+  int rtt_msec = 0;
   if (!rtt.has_value()) {
-    // RTT is unavailable. So, return the fastest value.
-    return 0;
+    DCHECK(kWebConnectionTypeUnknown == type ||
+           kWebConnectionTypeNone == type || kWebConnectionTypeOther == type);
+    rtt_msec = 55;
+  } else {
+    rtt_msec = rtt.value().InMilliseconds();
+    if (rtt.value().InMilliseconds() > std::numeric_limits<int>::max())
+      rtt_msec = std::numeric_limits<int>::max();
   }
 
-  int rtt_msec = rtt.value().InMilliseconds();
-  if (rtt.value().InMilliseconds() > std::numeric_limits<int>::max())
-    rtt_msec = std::numeric_limits<int>::max();
-
   DCHECK_LE(0, 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(const Optional<double>& downlink_mbps) {
+// returned value is in Mbps. If |downlink_mbps| has no value, |type| is used to
+// determine a default value.
+double RoundMbps(WebConnectionType type,
+                 const Optional<double>& downlink_mbps) {
+  double downlink_kbps = std::numeric_limits<double>::infinity();
   if (!downlink_mbps.has_value()) {
-    // Throughput is unavailable. So, return the fastest value.
-    return std::numeric_limits<double>::infinity();
+    DCHECK(kWebConnectionTypeUnknown == type ||
+           kWebConnectionTypeNone == type || kWebConnectionTypeOther == type);
+    downlink_kbps = 1961;
+  } else {
+    downlink_kbps = downlink_mbps.value() * 1000;
   }
 
-  DCHECK_LE(0, downlink_mbps.value());
-  double downlink_kbps = downlink_mbps.value() * 1000;
+  DCHECK_LE(0, downlink_kbps);
   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);
 }
 
@@ skipping 24 matching lines @@
   if (!observing_) {
     return EffectiveConnectionTypeToString(
         GetNetworkStateNotifier().EffectiveType());
   }
 
   // If observing, return m_type which changes when the event fires, per spec.
   return EffectiveConnectionTypeToString(effective_type_);
 }
 
 unsigned long NetworkInformation::rtt() const {
-  if (!observing_)
-    return RoundRtt(GetNetworkStateNotifier().TransportRtt());
-
+  if (!observing_) {
+    return RoundTransportRtt(GetNetworkStateNotifier().ConnectionType(),
+                             GetNetworkStateNotifier().TransportRtt());
+  }
   return transport_rtt_msec_;
 }
 
 double NetworkInformation::downlink() const {
-  if (!observing_)
-    return RoundMbps(GetNetworkStateNotifier().DownlinkThroughputMbps());
-
+  if (!observing_) {
+    return RoundMbps(GetNetworkStateNotifier().ConnectionType(),
+                     GetNetworkStateNotifier().DownlinkThroughputMbps());
+  }
   return downlink_mbps_;
 }
 
 void NetworkInformation::ConnectionChange(
     WebConnectionType type,
     double downlink_max_mbps,
     WebEffectiveConnectionType effective_type,
     const Optional<TimeDelta>& http_rtt,
     const Optional<TimeDelta>& transport_rtt,
     const Optional<double>& downlink_mbps) {
   DCHECK(GetExecutionContext()->IsContextThread());
 
   effective_type_ = effective_type;
-  transport_rtt_msec_ = RoundRtt(transport_rtt);
-  downlink_mbps_ = RoundMbps(downlink_mbps);
+  transport_rtt_msec_ = RoundTransportRtt(type, transport_rtt);
+  downlink_mbps_ = RoundMbps(type, 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, 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;
@@ skipping 63 matching lines @@
         TaskRunnerHelper::Get(TaskType::kNetworking, GetExecutionContext()));
     observing_ = false;
   }
 }
 
 NetworkInformation::NetworkInformation(ExecutionContext* context)
     : ContextLifecycleObserver(context),
       type_(GetNetworkStateNotifier().ConnectionType()),
       downlink_max_mbps_(GetNetworkStateNotifier().MaxBandwidth()),
       effective_type_(GetNetworkStateNotifier().EffectiveType()),
-      transport_rtt_msec_(RoundRtt(GetNetworkStateNotifier().TransportRtt())),
+      transport_rtt_msec_(
+          RoundTransportRtt(type_, GetNetworkStateNotifier().TransportRtt())),
       downlink_mbps_(
-          RoundMbps(GetNetworkStateNotifier().DownlinkThroughputMbps())),
+          RoundMbps(type_, GetNetworkStateNotifier().DownlinkThroughputMbps())),
       observing_(false),
       context_stopped_(false) {}
 
 DEFINE_TRACE(NetworkInformation) {
   EventTargetWithInlineData::Trace(visitor);
   ContextLifecycleObserver::Trace(visitor);
 }
 
 }  // namespace blink