Add connection type to NCN::MaxBandwidthChanged

net/base/network_change_notifier.cc

 // Copyright (c) 2012 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_change_notifier.h"
 
 #include <limits>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
@@ skipping 524 matching lines @@
 
 // static
 NetworkChangeNotifier::ConnectionType
 NetworkChangeNotifier::GetConnectionType() {
   return g_network_change_notifier ?
       g_network_change_notifier->GetCurrentConnectionType() :
       CONNECTION_UNKNOWN;
 }
 
 // static
-double NetworkChangeNotifier::GetMaxBandwidth() {
-  return g_network_change_notifier ?
-      g_network_change_notifier->GetCurrentMaxBandwidth() :
-      std::numeric_limits<double>::infinity();
+double NetworkChangeNotifier::GetMaxBandwidthAndConnectionType(
+    ConnectionType* connection_type) {
+  if (!g_network_change_notifier) {
+    if (connection_type != nullptr)
+      *connection_type = CONNECTION_UNKNOWN;
+    return GetMaxBandwidthForConnectionSubtype(SUBTYPE_UNKNOWN);
+  }
+
+  return g_network_change_notifier->GetCurrentMaxBandwidthAndConnectionType(
+      connection_type);
 }
 
 // static
 void NetworkChangeNotifier::GetDnsConfig(DnsConfig* config) {
   if (!g_network_change_notifier) {
     *config = DnsConfig();
   } else {
     g_network_change_notifier->network_state_->GetDnsConfig(config);
   }
 }
@@ skipping 226 matching lines @@
     g_network_change_notifier->NotifyObserversOfNetworkChangeImpl(type);
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadForTests() {
   if (g_network_change_notifier)
     g_network_change_notifier->NotifyObserversOfInitialDNSConfigReadImpl();
 }
 
 // static
+void NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChangeForTests(
+    ConnectionType type,
+    double max_bandwidth) {
+  if (g_network_change_notifier)
+    g_network_change_notifier->NotifyObserversOfMaxBandwidthChangeImpl(
+        type, max_bandwidth);
+}
+
+// static
 void NetworkChangeNotifier::SetTestNotificationsOnly(bool test_only) {
   DCHECK(!g_network_change_notifier);
   NetworkChangeNotifier::test_notifications_only_ = test_only;
 }
 
 NetworkChangeNotifier::NetworkChangeNotifier(
     const NetworkChangeCalculatorParams& params
     /*= NetworkChangeCalculatorParams()*/)
     : ip_address_observer_list_(
           new base::ObserverListThreadSafe<IPAddressObserver>(
@@ skipping 18 matching lines @@
   network_change_calculator_->Init();
 }
 
 #if defined(OS_LINUX)
 const internal::AddressTrackerLinux*
 NetworkChangeNotifier::GetAddressTrackerInternal() const {
   return NULL;
 }
 #endif
 
-double NetworkChangeNotifier::GetCurrentMaxBandwidth() const {
+double NetworkChangeNotifier::GetCurrentMaxBandwidthAndConnectionType(
+    ConnectionType* connection_type) const {
   // This default implementation conforms to the NetInfo V3 specification but
   // should be overridden to provide specific bandwidth data based on the
   // platform.
-  if (GetCurrentConnectionType() == CONNECTION_NONE)
-    return 0.0;
-  return std::numeric_limits<double>::infinity();
+  if (connection_type != nullptr)
+    *connection_type = GetCurrentConnectionType();
+  return *connection_type == CONNECTION_NONE
+             ? GetMaxBandwidthForConnectionSubtype(SUBTYPE_NONE)
+             : GetMaxBandwidthForConnectionSubtype(SUBTYPE_UNKNOWN);
 }
 
 // static
 double NetworkChangeNotifier::GetMaxBandwidthForConnectionSubtype(
     ConnectionSubtype subtype) {
   switch (subtype) {
     case SUBTYPE_GSM:
       return 0.01;
     case SUBTYPE_IDEN:
       return 0.064;
@@ skipping 85 matching lines @@
 void NetworkChangeNotifier::NotifyObserversOfNetworkChange(
     ConnectionType type) {
   if (g_network_change_notifier &&
       !NetworkChangeNotifier::test_notifications_only_) {
     g_network_change_notifier->NotifyObserversOfNetworkChangeImpl(type);
   }
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChange(
+    ConnectionType type,
     double max_bandwidth_mbps) {
   if (g_network_change_notifier &&
       !NetworkChangeNotifier::test_notifications_only_) {
     g_network_change_notifier->NotifyObserversOfMaxBandwidthChangeImpl(
-        max_bandwidth_mbps);
+        type, max_bandwidth_mbps);
   }
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfDNSChange() {
   if (g_network_change_notifier &&
       !NetworkChangeNotifier::test_notifications_only_) {
     g_network_change_notifier->NotifyObserversOfDNSChangeImpl();
   }
 }
@@ skipping 48 matching lines @@
 void NetworkChangeNotifier::NotifyObserversOfDNSChangeImpl() {
   resolver_state_observer_list_->Notify(FROM_HERE, &DNSObserver::OnDNSChanged);
 }
 
 void NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadImpl() {
   resolver_state_observer_list_->Notify(FROM_HERE,
                                         &DNSObserver::OnInitialDNSConfigRead);
 }
 
 void NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChangeImpl(
+    ConnectionType type,
     double max_bandwidth_mbps) {
   max_bandwidth_observer_list_->Notify(
-      FROM_HERE, &MaxBandwidthObserver::OnMaxBandwidthChanged,
+      FROM_HERE, &MaxBandwidthObserver::OnMaxBandwidthChanged, type,
       max_bandwidth_mbps);
 }
 
 NetworkChangeNotifier::DisableForTest::DisableForTest()
     : network_change_notifier_(g_network_change_notifier) {
   DCHECK(g_network_change_notifier);
   g_network_change_notifier = NULL;
 }
 
 NetworkChangeNotifier::DisableForTest::~DisableForTest() {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = network_change_notifier_;
 }
 
 void NetworkChangeNotifier::DNSObserver::OnInitialDNSConfigRead() {
 }
 
 }  // namespace net