API for connection type (Ethernet/WIFI/WWAN ...) in NetworkChangeNotifier.

net/base/network_change_notifier_mac.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_mac.h"
 
 #include <netinet/in.h>
 
 namespace net {
 
-static bool CalculateReachability(SCNetworkConnectionFlags flags) {
+static NetworkChangeNotifier::ConnectionType

[wtc, 2012/05/11 01:35:05]

Nit: NetworkChangeNotifier::ConnectionType is very long.
It may make sense to un-nest it and name it
NetworkConnectionType.

+CalculateReachability(SCNetworkConnectionFlags flags) {

[wtc, 2012/05/11 01:35:05]

IMPORTANT: It seems wrong for a function named
CalculateReachability to return a connection type.

Are you sure we need to modify this function?

It seems that the only function in this file that we need
to modify is the NetworkChangeNotifierMac::GetCurrentConnectionType()
function.  We will change
  return online_state_ == OFFLINE;
to
  return online_state_ == OFFLINE ?
      NetworkChangeNotifier::CONNECTION_NONE :
      NetworkChangeNotifier::CONNECTION_UNKNOWN;

   bool reachable = flags & kSCNetworkFlagsReachable;
   bool connection_required = flags & kSCNetworkFlagsConnectionRequired;
-  return reachable && !connection_required;
+  // TODO: Return something more detailed than CONNECTION_UNKNOWN.
+  return (reachable && !connection_required) ?
+      NetworkChangeNotifier::CONNECTION_UNKNOWN :
+      NetworkChangeNotifier::CONNECTION_NONE;
 }
 
 NetworkChangeNotifierMac::NetworkChangeNotifierMac()
-    : online_state_(UNINITIALIZED),
-      initial_state_cv_(&online_state_lock_),
+    : connection_type_(CONNECTION_UNKNOWN),
+      initialized_(false),
+      initial_state_cv_(&connection_type_lock_),
       forwarder_(this) {
   // Must be initialized after the rest of this object, as it may call back into
   // SetInitialState().
   config_watcher_.reset(new NetworkConfigWatcherMac(&forwarder_));
 }
 
 NetworkChangeNotifierMac::~NetworkChangeNotifierMac() {
   // Delete the ConfigWatcher to join the notifier thread, ensuring that
   // StartReachabilityNotifications() has an opportunity to run to completion.
   config_watcher_.reset();
 
   // Now that StartReachabilityNotifications() has either run to completion or
   // never run at all, unschedule reachability_ if it was previously scheduled.
   if (reachability_.get() && run_loop_.get()) {
     SCNetworkReachabilityUnscheduleFromRunLoop(reachability_.get(),
                                                run_loop_.get(),
                                                kCFRunLoopCommonModes);
   }
 }
 
-bool NetworkChangeNotifierMac::IsCurrentlyOffline() const {
-  base::AutoLock lock(online_state_lock_);
+NetworkChangeNotifier::ConnectionType
+NetworkChangeNotifierMac::GetCurrentConnectionType() const {
+  base::AutoLock lock(connection_type_lock_);
   // Make sure the initial state is set before returning.
-  while (online_state_ == UNINITIALIZED) {
+  while (!initialized_) {
     initial_state_cv_.Wait();
   }
-  return online_state_ == OFFLINE;
+  return connection_type_;
 }
 
 void NetworkChangeNotifierMac::SetInitialState() {
   // Called on notifier thread.
 
   // Try to reach 0.0.0.0. This is the approach taken by Firefox:
   //
   // http://mxr.mozilla.org/mozilla2.0/source/netwerk/system/mac/nsNetworkLinkService.mm
   //
   // From my (adamk) testing on Snow Leopard, 0.0.0.0
   // seems to be reachable if any network connection is available.
   struct sockaddr_in addr = {0};
   addr.sin_len = sizeof(addr);
   addr.sin_family = AF_INET;
   reachability_.reset(SCNetworkReachabilityCreateWithAddress(
       kCFAllocatorDefault, reinterpret_cast<struct sockaddr*>(&addr)));
 
   SCNetworkConnectionFlags flags;
-  bool reachable = true;
+  ConnectionType reachable = CONNECTION_UNKNOWN;
   if (SCNetworkReachabilityGetFlags(reachability_, &flags))
     reachable = CalculateReachability(flags);
   else
     LOG(ERROR) << "Could not get initial network state, assuming online.";
   {
-    base::AutoLock lock(online_state_lock_);
-    online_state_ = reachable ? ONLINE : OFFLINE;
+    base::AutoLock lock(connection_type_lock_);
+    connection_type_ = reachable;
+    initialized_ = true;
     initial_state_cv_.Signal();
   }
 }
 
 void NetworkChangeNotifierMac::StartReachabilityNotifications() {
   // Called on notifier thread.
   run_loop_.reset(CFRunLoopGetCurrent());
   CFRetain(run_loop_.get());
 
   DCHECK(reachability_);
@@ skipping 63 matching lines @@
 // static
 void NetworkChangeNotifierMac::ReachabilityCallback(
     SCNetworkReachabilityRef target,
     SCNetworkConnectionFlags flags,
     void* notifier) {
   NetworkChangeNotifierMac* notifier_mac =
       static_cast<NetworkChangeNotifierMac*>(notifier);
 
   DCHECK_EQ(notifier_mac->run_loop_.get(), CFRunLoopGetCurrent());
 
-  OnlineState new_state = CalculateReachability(flags) ? ONLINE : OFFLINE;
-  OnlineState old_state;
+  ConnectionType new_type = CalculateReachability(flags);
+  ConnectionType old_type;
   {
-    base::AutoLock lock(notifier_mac->online_state_lock_);
-    old_state = notifier_mac->online_state_;
-    notifier_mac->online_state_ = new_state;
+    base::AutoLock lock(notifier_mac->connection_type_lock_);
+    old_type = notifier_mac->connection_type_;
+    notifier_mac->connection_type_ = new_type;
   }
-  if (old_state != new_state)
-    NotifyObserversOfOnlineStateChange();
+  if (old_type != new_type)
+    NotifyObserversOfConnectionTypeChange();
 }
 
 }  // namespace net