Implement NetworkChangeNotifier::IsCurrentlyOffline() for Mac.

net/base/network_change_notifier_mac.cc

 // Copyright (c) 2010 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>
 #include <SystemConfiguration/SCDynamicStoreKey.h>
+#include <SystemConfiguration/SCNetworkReachability.h>
 #include <SystemConfiguration/SCSchemaDefinitions.h>
 
 #include "base/mac/scoped_cftyperef.h"
 
 namespace net {
 
 NetworkChangeNotifierMac::NetworkChangeNotifierMac()
     : forwarder_(this),
-      config_watcher_(&forwarder_) {}
-NetworkChangeNotifierMac::~NetworkChangeNotifierMac() {}
+      config_watcher_(&forwarder_),
+      network_reachable_(true) {}
+
+NetworkChangeNotifierMac::~NetworkChangeNotifierMac() {
+  CleanUp();

[Mark Mentovai, 2011/06/02 16:26:57]

Which thread does this happen on?

[adamk, 2011/06/02 16:43:50]

Ugh, good point, this is why I put it in the delegate interface in the first
place.  So this is clearly not the right answer.

+}
 
 bool NetworkChangeNotifierMac::IsCurrentlyOffline() const {
-  // TODO(eroman): http://crbug.com/53473
-  return false;
+  return !network_reachable_;
 }
 
 void NetworkChangeNotifierMac::SetDynamicStoreNotificationKeys(
     SCDynamicStoreRef store) {
   // Called on notifier thread.

[Mark Mentovai, 2011/06/02 16:26:57]

Every time you have this comment:

Is this something you can DCHECK for?

[adamk, 2011/06/02 16:43:50]

Not without some additional machinery.  Possibly this method could save a
MessageLoopProxy of that thread, which could allow the destructor to at least
attempt to run CleanUp() on the proper thread.  But that still isn't quite
right, as it'd have to Join the thread.  More thought necessary...I think the
ideal would be that this object is simply never destroyed.

[Mark Mentovai, 2011/06/02 16:47:20]

adamk wrote:
Since this is platform-specific code, you can save a pthread_t from
pthread_self(). That’s probably most lightweight of all, and is certainly easy
to do, and a very small amount of code.

But I’ll leave this to you to rethink a bit, since the threading model as it
stands now is off (and any DCHECK you introduce would wind up getting tripped).

   base::mac::ScopedCFTypeRef<CFMutableArrayRef> notification_keys(
       CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks));
   base::mac::ScopedCFTypeRef<CFStringRef> key(
       SCDynamicStoreKeyCreateNetworkGlobalEntity(
           NULL, kSCDynamicStoreDomainState, kSCEntNetInterface));
   CFArrayAppendValue(notification_keys.get(), key.get());
   key.reset(SCDynamicStoreKeyCreateNetworkGlobalEntity(
       NULL, kSCDynamicStoreDomainState, kSCEntNetIPv4));
   CFArrayAppendValue(notification_keys.get(), key.get());
   key.reset(SCDynamicStoreKeyCreateNetworkGlobalEntity(
       NULL, kSCDynamicStoreDomainState, kSCEntNetIPv6));
   CFArrayAppendValue(notification_keys.get(), key.get());
 
   // Set the notification keys.  This starts us receiving notifications.
   bool ret = SCDynamicStoreSetNotificationKeys(
       store, notification_keys.get(), NULL);
   // TODO(willchan): Figure out a proper way to handle this rather than crash.
   CHECK(ret);
+
+  // 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)));
+  SCNetworkReachabilityContext reachability_context = {
+    0,     // version
+    this,  // user data
+    NULL,  // retain
+    NULL,  // release
+    NULL   // description
+  };
+  if (!SCNetworkReachabilitySetCallback(
+          reachability_.get(),
+          &NetworkChangeNotifierMac::ReachabilityCallback,
+          &reachability_context)) {
+    LOG(DFATAL) << "Could not set network reachability callback";
+    reachability_.reset();
+  } else if (!SCNetworkReachabilityScheduleWithRunLoop(reachability_.get(),
+                                                       CFRunLoopGetCurrent(),
+                                                       kCFRunLoopCommonModes)) {
+    LOG(DFATAL) << "Could not schedule network reachability on run loop";
+    reachability_.reset();
+  }
 }
 
 void NetworkChangeNotifierMac::OnNetworkConfigChange(CFArrayRef changed_keys) {
   // Called on notifier thread.
-
   for (CFIndex i = 0; i < CFArrayGetCount(changed_keys); ++i) {
     CFStringRef key = static_cast<CFStringRef>(
         CFArrayGetValueAtIndex(changed_keys, i));
     if (CFStringHasSuffix(key, kSCEntNetIPv4) ||
         CFStringHasSuffix(key, kSCEntNetIPv6)) {
       NotifyObserversOfIPAddressChange();
       return;
     }
     if (CFStringHasSuffix(key, kSCEntNetInterface)) {
       // TODO(willchan): Does not appear to be working.  Look into this.
       // Perhaps this isn't needed anyway.
     } else {
       NOTREACHED();
     }
   }
 }
 
+// static
+void NetworkChangeNotifierMac::ReachabilityCallback(
+    SCNetworkReachabilityRef target,
+    SCNetworkConnectionFlags flags,
+    void* notifier) {
+  // Called on notifier thread.
+  bool reachable = flags & kSCNetworkFlagsReachable;
+  bool connection_required = flags & kSCNetworkFlagsConnectionRequired;
+  NetworkChangeNotifierMac* notifier_mac =
+      static_cast<NetworkChangeNotifierMac*>(notifier);
+  bool old_reachability = notifier_mac->network_reachable_;
+  notifier_mac->network_reachable_ = reachable && !connection_required;
+  if (old_reachability != notifier_mac->network_reachable_)
+    notifier_mac->NotifyObserversOfOnlineStateChange();
+}
+
+void NetworkChangeNotifierMac::CleanUp() {
+  // Called on notifier thread.
+  if (!reachability_.get())
+    return;
+  SCNetworkReachabilityUnscheduleFromRunLoop(reachability_.get(),
+                                             CFRunLoopGetCurrent(),
+                                             kCFRunLoopCommonModes);
+  reachability_.reset();
+}
+
 }  // namespace net