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

net/base/network_change_notifier_linux.cc

 // Copyright (c) 2011 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.
 //
 // This implementation of NetworkChangeNotifier's offline state detection
 // depends on D-Bus and NetworkManager, and is known to work on at least
 // GNOME version 2.30.  If D-Bus or NetworkManager are unavailable, this
 // implementation will always behave as if it is online.
 
 #include "net/base/network_change_notifier_linux.h"
@@ skipping 64 matching lines @@
         system_bus_(bus) { }
 
   ~NetworkManagerApi() { }
 
   // Should be called on a helper thread which must be of type IO.
   void Init();
 
   // Must be called by the helper thread's CleanUp() method.
   void CleanUp();
 
-  // Implementation of NetworkChangeNotifierLinux::IsCurrentlyOffline().
+  // Implementation of NetworkChangeNotifierLinux::GetCurrentConnectionState().
   // Safe to call from any thread, but will block until Init() has completed.
-  bool IsCurrentlyOffline();
+  NetworkChangeNotifier::ConnectionState GetCurrentConnectionState();
 
  private:
   // Callbacks for D-Bus API.
   void OnInitialResponse(dbus::Response* response) {
     HandleResponse(response);
     offline_state_initialized_.Signal();
   }
 
   void OnSignaled(dbus::Signal* signal);
 
@@ skipping 125 matching lines @@
     case NM_LEGACY_STATE_ASLEEP:
     case NM_STATE_ASLEEP:
       // Networking disabled or no devices on system
       return true;
     default:
       // Unknown status
       return false;
   }
 }
 
-bool NetworkManagerApi::IsCurrentlyOffline() {
+NetworkChangeNotifier::ConnectionState
+NetworkManagerApi::GetCurrentConnectionState() {
   offline_state_initialized_.Wait();
   base::AutoLock lock(is_offline_lock_);
-  return is_offline_;
+  return is_offline_ ? NetworkChangeNotifier::NONE :
+                       NetworkChangeNotifier::ETHERNET;

[joth, 2012/01/10 10:48:35]

again, seems like UNKNOWN would be a better fit?

 }
 
 class DNSWatchDelegate : public FilePathWatcher::Delegate {
  public:
   explicit DNSWatchDelegate(const base::Closure& callback)
       : callback_(callback) {}
   virtual ~DNSWatchDelegate() {}
   // FilePathWatcher::Delegate interface
   virtual void OnFilePathChanged(const FilePath& path) OVERRIDE;
   virtual void OnFilePathError(const FilePath& path) OVERRIDE;
@@ skipping 16 matching lines @@
 class NetworkChangeNotifierLinux::Thread
     : public base::Thread, public MessageLoopForIO::Watcher {
  public:
   explicit Thread(dbus::Bus* bus);
   virtual ~Thread();
 
   // MessageLoopForIO::Watcher:
   virtual void OnFileCanReadWithoutBlocking(int fd);
   virtual void OnFileCanWriteWithoutBlocking(int /* fd */);
 
-  // Plumbing for NetworkChangeNotifier::IsCurrentlyOffline.
+  // Plumbing for NetworkChangeNotifier::GetCurrentConnectionState.
   // Safe to call from any thread.
-  bool IsCurrentlyOffline() {
-    return network_manager_api_.IsCurrentlyOffline();
+  NetworkChangeNotifier::ConnectionState GetCurrentConnectionState() {
+    return network_manager_api_.GetCurrentConnectionState();
   }
 
  protected:
   // base::Thread
   virtual void Init();
   virtual void CleanUp();
 
  private:
   void NotifyObserversOfIPAddressChange() {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChange();
   }
 
   static void NotifyObserversOfDNSChange() {
     NetworkChangeNotifier::NotifyObserversOfDNSChange();
   }
 
-  static void NotifyObserversOfOnlineStateChange() {
-    NetworkChangeNotifier::NotifyObserversOfOnlineStateChange();
+  static void NotifyObserversOfConnectionStateChange() {
+    NetworkChangeNotifier::NotifyObserversOfConnectionStateChange();
   }
 
   // Starts listening for netlink messages.  Also handles the messages if there
   // are any available on the netlink socket.
   void ListenForNotifications();
 
   // Attempts to read from the netlink socket into |buf| of length |len|.
   // Returns the bytes read on synchronous success and ERR_IO_PENDING if the
   // recv() would block.  Otherwise, it returns a net error code.
   int ReadNotificationMessage(char* buf, size_t len);
 
   // The netlink socket descriptor.
   int netlink_fd_;
   MessageLoopForIO::FileDescriptorWatcher netlink_watcher_;
 
   // Technically only needed for ChromeOS, but it's ugly to #ifdef out.
   base::WeakPtrFactory<Thread> ptr_factory_;
 
   // Used to watch for changes to /etc/resolv.conf and /etc/hosts.
   scoped_ptr<base::files::FilePathWatcher> resolv_file_watcher_;
   scoped_ptr<base::files::FilePathWatcher> hosts_file_watcher_;
   scoped_refptr<DNSWatchDelegate> file_watcher_delegate_;
 
-  // Used to detect online/offline state changes.
+  // Used to detect connection state changes.
   NetworkManagerApi network_manager_api_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 NetworkChangeNotifierLinux::Thread::Thread(dbus::Bus* bus)
     : base::Thread("NetworkChangeNotifier"),
       netlink_fd_(kInvalidSocket),
       ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)),
       network_manager_api_(
           base::Bind(&NetworkChangeNotifierLinux::Thread
-                     ::NotifyObserversOfOnlineStateChange),
+                     ::NotifyObserversOfConnectionStateChange),
           bus) {
 }
 
 NetworkChangeNotifierLinux::Thread::~Thread() {
   DCHECK(!Thread::IsRunning());
 }
 
 void NetworkChangeNotifierLinux::Thread::Init() {
   resolv_file_watcher_.reset(new FilePathWatcher);
   hosts_file_watcher_.reset(new FilePathWatcher);
@@ skipping 111 matching lines @@
   base::Thread::Options thread_options(MessageLoop::TYPE_IO, 0);
   notifier_thread_->StartWithOptions(thread_options);
 }
 
 NetworkChangeNotifierLinux::~NetworkChangeNotifierLinux() {
   // Stopping from here allows us to sanity- check that the notifier
   // thread shut down properly.
   notifier_thread_->Stop();
 }
 
-bool NetworkChangeNotifierLinux::IsCurrentlyOffline() const {
-  return notifier_thread_->IsCurrentlyOffline();
+NetworkChangeNotifier::ConnectionState
+NetworkChangeNotifierMac::GetCurrentConnectionState() const {
+  return notifier_thread_->GetCurrentConnectionState();
 }
 
 }  // namespace net