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>

[Mark Mentovai, 2011/06/01 21:05:59]

These shouldn’t be in a separate group from the SystemConfiguration headers. The
group for “C system headers” doesn’t distinguish between POSIX and non-POSIX.

[adamk, 2011/06/01 21:42:53]

Done.

+#include <string.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_) {}
+      config_watcher_(&forwarder_),
+      network_reachable_(true) {}
 NetworkChangeNotifierMac::~NetworkChangeNotifierMac() {}
 
 bool NetworkChangeNotifierMac::IsCurrentlyOffline() const {
-  // TODO(eroman): http://crbug.com/53473
-  return false;
+  return !network_reachable_;
 }
 
 void NetworkChangeNotifierMac::SetDynamicStoreNotificationKeys(
     SCDynamicStoreRef store) {
   // Called on notifier thread.
   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;

[Mark Mentovai, 2011/06/01 21:05:59]

I would just say |struct sockaddr_in addr = { 0 };| and let the compiler memset
it for me.

[adamk, 2011/06/01 21:42:53]

I don't think the 0 does anything here.  I've rewritten it as "= {};" (which
should default-initialize the whole thing.

[Mark Mentovai, 2011/06/01 22:02:45]

adamk wrote:
We normally use { 0 }, which does in fact zero out the entire structure.

http://groups.google.com/group/chromium-dev/browse_thread/thread/498891cd7b06...

There are a couple of weak reasons to use this instead of {}:

1. { 0 }, as a pattern, is understood to mean and look like “zero.”

2. We normally use this when we’re trying to zero-initialize C structs, and are
thinking in C-ish terms, and the empty {} is not valid C.

I don’t mind if you want to leave it as {}, but I mention this because you
asserted that { 0 } wouldn’t do anything.

[adamk, 2011/06/01 22:09:34]

Sorry, I meant to say "{ 0 }" wouldn't do anything different: it'll set the
first member of the struct to 0 and the rest of the members to
default-initialized (which happens to be 0 for this case).  I'm happy to put the
0 there for aesthetic purposes, as it seems more common in Chromium.

[Mark Mentovai, 2011/06/01 22:10:43]

adamk wrote:
Gotcha, I misread what you meant by “don’t think the 0 does anything.” Like I
said, your call on this one.

+  memset(&addr, 0, sizeof(addr));
+  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
+  };
+  // TODO(adamk): Either of these calls could fail, can we do any better
+  // in handling this?
+  ret = SCNetworkReachabilitySetCallback(
+      reachability_.get(),
+      &NetworkChangeNotifierMac::ReachabilityCallback,
+      &reachability_context);

[Mark Mentovai, 2011/06/01 21:05:59]

I hope SC copies what it needs from this structure, since reachability_context
is invalid as soon as this function goes out of scope.

(I think you’re OK here, and we have other uses that do this too.)

[adamk, 2011/06/01 21:42:53]

I have to imagine they copy what they need...

+  DCHECK(ret) << "Could not set network reachability callback";
+  ret = SCNetworkReachabilityScheduleWithRunLoop(reachability_.get(),

[Mark Mentovai, 2011/06/01 21:05:59]

I think you’d want to avoid doing this (and maybe do reachability_.reset()) if
the preceding call failed.

[adamk, 2011/06/01 21:42:53]

Changed the structure around and added some resets (also switched to
LOG(DFATAL).  PTAL and see if this meets what you had in mind.

+                                                 CFRunLoopGetCurrent(),
+                                                 kCFRunLoopCommonModes);
+  DCHECK(ret) << "Could not schedule network reachability on run loop";
 }
 
 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);

[Mark Mentovai, 2011/06/01 21:05:59]

No parentheses on this line, the next, or line 111.

[adamk, 2011/06/01 21:42:53]

Done.

+  bool connection_required = (flags & kSCNetworkFlagsConnectionRequired);
+  NetworkChangeNotifierMac* notifier_mac =
+      static_cast<NetworkChangeNotifierMac*>(notifier);
+  notifier_mac->network_reachable_ = (reachable && !connection_required);
+  notifier_mac->NotifyObserversOfOnlineStateChange();
+}
+
+void NetworkChangeNotifierMac::CleanUp() {
+  // Called on notifier thread.
+  if (!reachability_.get())
+    return;
+  SCNetworkReachabilityUnscheduleFromRunLoop(reachability_.get(),
+                                             CFRunLoopGetCurrent(),
+                                             kCFRunLoopCommonModes);
+  reachability_.reset();
+}
+
 }  // namespace net