Mac OS X-specific implementation of Networking Private API.

components/wifi/wifi_service_mac.mm

+// Copyright 2014 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 "components/wifi/wifi_service.h"
+
+#import <netinet/in.h>
+#import <CoreWLAN/CoreWLAN.h>
+#import <SystemConfiguration/SystemConfiguration.h>
+
+#include "base/bind.h"
+#include "base/mac/scoped_cftyperef.h"
+#include "base/mac/scoped_nsobject.h"
+#include "base/message_loop/message_loop.h"
+#include "base/strings/sys_string_conversions.h"
+#include "components/onc/onc_constants.h"
+
+#if !defined(MAC_OS_X_VERSION_10_7) || \
+    MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
+
+// Local definitions of API added in Mac OS X 10.7
+
+@interface CWInterface (LionAPI)
+- (BOOL)associateToNetwork:(CWNetwork*)network
+                  password:(NSString*)password
+                     error:(NSError**)error;
+- (NSSet*)scanForNetworksWithName:(NSString*)networkName
+                            error:(NSError**)error;
+@end
+
+enum CWChannelBand {
+  kCWChannelBandUnknown = 0,
+  kCWChannelBand2GHz = 1,
+  kCWChannelBand5GHz = 2,
+};
+
+@interface CWChannel : NSObject
+@property(readonly) CWChannelBand channelBand;
+@end
+
+@interface CWNetwork (LionAPI)
+@property(readonly) CWChannel* wlanChannel;
+@end
+
+#endif  // 10.7
+
+namespace wifi {
+
+const char kErrorAssociateToNetwork[] = "Error.AssociateToNetwork";
+const char kErrorNotConnected[] = "Error.NotConnected";
+const char kErrorNotFound[] = "Error.NotFound";
+const char kErrorNotImplemented[] = "Error.NotImplemented";
+const char kErrorScanForNetworksWithName[] = "Error.ScanForNetworksWithName";
+
+// Implementation of WiFiService for Mac OS X.
+class WiFiServiceMac : public WiFiService {
+ public:
+  WiFiServiceMac();
+  virtual ~WiFiServiceMac();
+
+  // WiFiService interface implementation.
+  virtual void Initialize(
+      scoped_refptr<base::SequencedTaskRunner> task_runner) OVERRIDE;
+
+  virtual void UnInitialize() OVERRIDE;
+
+  virtual void GetProperties(const std::string& network_guid,
+                             base::DictionaryValue* properties,
+                             std::string* error) OVERRIDE;
+
+  virtual void GetManagedProperties(const std::string& network_guid,
+                                    base::DictionaryValue* managed_properties,
+                                    std::string* error) OVERRIDE;
+
+  virtual void GetState(const std::string& network_guid,
+                        base::DictionaryValue* properties,
+                        std::string* error) OVERRIDE;
+
+  virtual void SetProperties(const std::string& network_guid,
+                             scoped_ptr<base::DictionaryValue> properties,
+                             std::string* error) OVERRIDE;
+
+  virtual void CreateNetwork(bool shared,
+                             scoped_ptr<base::DictionaryValue> properties,
+                             std::string* network_guid,
+                             std::string* error) OVERRIDE;
+
+  virtual void GetVisibleNetworks(const std::string& network_type,
+                                  base::ListValue* network_list) OVERRIDE;
+
+  virtual void RequestNetworkScan() OVERRIDE;
+
+  virtual void StartConnect(const std::string& network_guid,
+                            std::string* error) OVERRIDE;
+
+  virtual void StartDisconnect(const std::string& network_guid,
+                               std::string* error) OVERRIDE;
+
+  virtual void SetEventObservers(
+      scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+      const NetworkGuidListCallback& networks_changed_observer,
+      const NetworkGuidListCallback& network_list_changed_observer) OVERRIDE;
+
+ private:
+  // Checks |ns_error| and if is not |nil|, then stores |error_name|
+  // into |error|.
+  bool CheckError(NSError* ns_error,
+                  const char* error_name,
+                  std::string* error) const;
+
+  // Gets |ssid| from unique |network_guid|.
+  NSString* SSIDFromGUID(const std::string& network_guid) const {
+    return base::SysUTF8ToNSString(network_guid);
+  }
+
+  // Gets unique |network_guid| string based on |ssid|.
+  std::string GUIDFromSSID(NSString* ssid) const {
+    return base::SysNSStringToUTF8(ssid);
+  }
+
+  // Populates |properties| from |network|.
+  void NetworkPropertiesFromCWNetwork(const CWNetwork* network,
+                                      NetworkProperties* properties) const;
+
+  // Convert s|CWSecurityMode| into onc::wifi::k{WPA|WEP}* security constant.
+  std::string SecurityFromCWSecurityMode(CWSecurityMode security) const;
+
+  // Waits up to |kMaxAttempts| with |kAttemptDelayMs| delay for connection to
+  // network with |network_guid|. Notifies that |NetworkChanged| upon success.
+  void WaitForNetworkConnect(const std::string& network_guid, int attempt);
+
+  // Gets current |onc::connection_state| for given |network_guid|.
+  std::string GetNetworkConnectionState(const std::string& network_guid) const;
+
+  // Updates |networks_| with the list of visible wireless networks.
+  void UpdateNetworks();
+
+  // Handles notification from |wlan_observer_|.
+  void OnWlanObserverNotification();
+
+  // Notifies |network_list_changed_observer_| that list of visible networks has
+  // changed to |networks|.
+  void NotifyNetworkListChanged(const NetworkList& networks);
+
+  // Notifies |networks_changed_observer_| that network |network_guid|
+  // connection state has changed.
+  void NotifyNetworkChanged(const std::string& network_guid);
+
+  // Default interface.
+  base::scoped_nsobject<CWInterface> interface_;
+  // WLAN Notifications observer.
+  base::scoped_nsobject<NSObject> wlan_observer_;
+
+  // Observer to get notified when network(s) have changed (e.g. connect).
+  NetworkGuidListCallback networks_changed_observer_;
+  // Observer to get notified when network list has changed (scan complete).
+  NetworkGuidListCallback network_list_changed_observer_;
+  // MessageLoopProxy to post events on UI thread.
+  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+  // Task runner for worker tasks.
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+  // Cache of network list collected by GetVisibleNetworks.
+  NetworkList networks_;
+  // Temporary storage of network properties indexed by |network_guid|.
+  base::DictionaryValue network_properties_;
+  // Number of attempts to check that network has connected successfully.
+  static const int kConnectionCheckMaxAttempts = 200;
+  // Delay between attempts to check that network has connected successfully.
+  static const int kConnectionCheckAttemptDelayMs = 100;
+};
+
+WiFiServiceMac::WiFiServiceMac() {
+}
+
+WiFiServiceMac::~WiFiServiceMac() {
+}
+
+void WiFiServiceMac::Initialize(
+  scoped_refptr<base::SequencedTaskRunner> task_runner) {
+  task_runner_.swap(task_runner);
+  interface_.reset([[CWInterface interface] retain]);
+  if (!interface_) {
+    DVLOG(1) << "Failed to initialize default interface.";
+    return;
+  }
+
+  if (![interface_
+          respondsToSelector:@selector(associateToNetwork:password:error:)]) {
+    DVLOG(1) << "CWInterface does not support associateToNetwork.";
+    interface_.reset();
+    return;
+  }
+}
+
+void WiFiServiceMac::UnInitialize() {

[Robert Sesek, 2014/01/13 19:10:28]

Should you interface_.reset() here too?

[mef, 2014/01/13 22:05:34]

Done.

+  [[NSNotificationCenter defaultCenter] removeObserver:wlan_observer_];
+}
+
+void WiFiServiceMac::GetProperties(const std::string& network_guid,
+                                    base::DictionaryValue* properties,

[Robert Sesek, 2014/01/13 19:10:28]

nit: alignment

[mef, 2014/01/13 22:05:34]

Done.

+                                    std::string* error) {
+  for (WiFiService::NetworkList::iterator it = networks_.begin();
+       it != networks_.end();
+       ++it) {
+    if (it->guid == network_guid) {
+      it->connection_state = GetNetworkConnectionState(network_guid);
+      scoped_ptr<base::DictionaryValue> network(it->ToValue(false));
+      properties->Swap(network.get());
+      DVLOG(1) << *properties;
+      return;
+    }
+  }
+
+  *error = kErrorNotFound;

[Robert Sesek, 2014/01/13 19:10:28]

Is it assumed that *error == "" at entry?

[mef, 2014/01/13 22:05:34]

Yes. Should I explicitly set it this way in public interface methods?

+}
+
+void WiFiServiceMac::GetManagedProperties(
+    const std::string& network_guid,
+    base::DictionaryValue* managed_properties,
+    std::string* error) {
+  *error = kErrorNotImplemented;
+}
+
+void WiFiServiceMac::GetState(const std::string& network_guid,
+                               base::DictionaryValue* properties,

[Robert Sesek, 2014/01/13 19:10:28]

nit: alignment

[mef, 2014/01/13 22:05:34]

Done. I think those are artifacts of Renaming WiFiServiceImpl ->
WiFiServiceMac...

+                               std::string* error) {
+  *error = kErrorNotImplemented;
+}
+
+void WiFiServiceMac::SetProperties(
+    const std::string& network_guid,
+    scoped_ptr<base::DictionaryValue> properties,
+    std::string* error) {
+  network_properties_.SetWithoutPathExpansion(network_guid,
+                                              properties.release());
+}
+
+void WiFiServiceMac::CreateNetwork(
+    bool shared,
+    scoped_ptr<base::DictionaryValue> properties,
+    std::string* network_guid,
+    std::string* error) {
+  *error = kErrorNotImplemented;
+}
+
+void WiFiServiceMac::GetVisibleNetworks(const std::string& network_type,
+                                         base::ListValue* network_list) {

[Robert Sesek, 2014/01/13 19:10:28]

nit: alignment

[mef, 2014/01/13 22:05:34]

Done.

+  if (!network_type.empty() &&
+      network_type != onc::network_type::kAllTypes &&
+      network_type != onc::network_type::kWiFi) {
+    return;
+  }
+
+  if (networks_.empty())
+    RequestNetworkScan();

[Robert Sesek, 2014/01/13 19:10:28]

This will trigger a NetworkListChanged callback, right? Is that expected to
happen from within GetVisibleNewtworks?

[mef, 2014/01/13 22:05:34]

Good question. Toni?

[tbarzic, 2014/01/16 19:41:48]

It's not required, but it's ok if rescan happens here (and if we rescan, the
event should be sent). This seems more like lazy initialization of the network
list. Maybe it could be moved when the service starts? I'm fine with this being
here, though.

[mef, 2014/01/16 23:42:48]

Done.

+
+  for (WiFiService::NetworkList::const_iterator it = networks_.begin();
+       it != networks_.end();
+       ++it) {
+    scoped_ptr<base::DictionaryValue> network(it->ToValue(true));
+    network_list->Append(network.release());
+  }
+}
+
+void WiFiServiceMac::RequestNetworkScan() {
+  UpdateNetworks();
+  NotifyNetworkListChanged(networks_);

[tbarzic, 2014/01/13 19:39:30]

NotifyNetworkListChanged should be part of UpdateNetworks. And potentially, we
should check if the network list really changed before sending the event

[mef, 2014/01/14 22:10:31]

Done.

+}
+
+void WiFiServiceMac::StartConnect(const std::string& network_guid,
+                                   std::string* error) {

[Robert Sesek, 2014/01/13 19:10:28]

nit: alignment

[mef, 2014/01/13 22:05:34]

Done.

+  NSError* ns_error = nil;
+
+  DVLOG(1) << "*** StartConnect: " << network_guid;
+  // Remember previously connected network.
+  std::string connected_network_guid = GUIDFromSSID([interface_ ssid]);
+  // Check, whether desired network is already connected.

[Robert Sesek, 2014/01/13 19:10:28]

nit: remove ,

[mef, 2014/01/13 22:05:34]

Done.

+  if (network_guid == connected_network_guid) {
+    NotifyNetworkChanged(connected_network_guid);

[tbarzic, 2014/01/13 19:39:30]

no need for this, as there are no changes to the network here.

[mef, 2014/01/14 22:10:31]

From my observations the extension didn't seem to recognize that mac is already
connected to the network unless I've issued this notification.

[tbarzic, 2014/01/16 19:41:48]

hm, that looks like a bug. either in the extension or here.
Can you see what's the network's ConnectionState in this case (as seen by the
extension)?
The fact that interface_ already has the targeted ssid, means that a network
changed event should have already been sent (and the extension hasn't yet
received it or processed it, but in either way, it should really soon detect
that the connection status changed). So it seems that the NetworkChanged event
was not sent when the network's connection properties changed to
'Connected'/'Connecting'. Maybe the connection state is not correctly set for
the network that's connected (either reachable or not) when the wifi service is
started?

Other option is that the extension sent startConnect request even though the
network's connection state is 'Connected'.

If you suspect a bug in the extension, feel free to send me the extension logs
(and leave this as it is for now).

[mef, 2014/01/16 23:42:48]

I'll try to debug this.

+    return;
+  }
+
+  NSSet* networks = [interface_

[tbarzic, 2014/01/13 19:39:30]

If the scan does not find the network, if should be removed from |networks_| and
NetworkListChanged should be sent.

Also, what do you think about checking whether the network in contained in
|networks_| before the scan; and failing if it's not? 
I can think of two cases where this may happen:
1. A bug in the calling code where wrong guid is used for StartConnect.
2. |networks_| has just been updated, but the observer hasn't yet received
NetworkListChanged notification, in which case there's a reason the network was
removed from |networks_|.

[mef, 2014/01/14 22:10:31]

Sounds good.
3. Hidden network will not show up in |networks_|. Although proper handling of
that should probably involve implementation of |CreateNetwork| to at least add
its guid as valid.

[tbarzic, 2014/01/16 19:41:48]

Yeah, proper handling in this case would be to create network first (as the API
generaly does not assume ssid == guid), so it cannot really know the guid for a
non-visible network :)

[mef, 2014/01/16 23:42:48]

Done. Implemented |CreateNetwork| to store network properties and return network
guid.

+      scanForNetworksWithName:SSIDFromGUID(network_guid)
+                        error:&ns_error];
+
+  if (CheckError(ns_error, kErrorScanForNetworksWithName, error))
+    return;
+
+  CWNetwork* network = [networks anyObject];
+  if (network == nil) {
+    *error = kErrorNotFound;
+    return;
+  }
+
+  // Check whether WiFi Password is set in |network_properties_|

[Robert Sesek, 2014/01/13 19:10:28]

nit: end with punctuation

[mef, 2014/01/13 22:05:34]

Done.

+  base::DictionaryValue* properties;
+  base::DictionaryValue* wifi;
+  std::string passphrase;
+  NSString* ns_password = nil;
+  if (network_properties_.GetDictionaryWithoutPathExpansion(network_guid,
+                                                            &properties) &&
+      properties->GetDictionary(onc::network_type::kWiFi, &wifi) &&
+      wifi->GetString(onc::wifi::kPassphrase, &passphrase)) {
+    ns_password = base::SysUTF8ToNSString(passphrase);
+  }
+
+  // Number of attempts to associate to network.
+  static const int kMaxAssociationAttempts = 3;
+  // Try to associate to network several times if timeout or PMK error occurs.
+  for (int i = 0; i < kMaxAssociationAttempts; ++i) {
+    // Nil out the PMK to prevent stale data from causing invalid PMK error
+    // (CoreWLANTypes -3924).
+    [interface_ setPairwiseMasterKey:nil error:&ns_error];
+    if ([interface_ associateToNetwork:network
+                              password:ns_password
+                                 error:&ns_error]) {
+      // Notify that previously connected network has changed.

[tbarzic, 2014/01/13 19:39:30]

Can't this be done in OnWlanObserverNotification (there should be a wlan
notification on success, right?).

[mef, 2014/01/14 22:10:31]

Done.

+      NotifyNetworkChanged(connected_network_guid);
+
+      // Start waiting for network connection state change. WaiForNetworkConnect
+      // is async and  it'll reset enable_notify_network_changed_.

[tbarzic, 2014/01/13 19:39:30]

the comment is outdated; you've gotten rid of enable_notify_network_changed_

[mef, 2014/01/14 22:10:31]

Done.

+      if (!networks_changed_observer_.is_null()) {
+        WaitForNetworkConnect(network_guid, 0);
+        return;
+      }
+    } else {
+      NSInteger error_code = [ns_error code];
+      if (error_code != kCWTimeoutErr && error_code != kCWInvalidPMKErr) {
+        break;
+      }
+    }
+  }
+  CheckError(ns_error, kErrorAssociateToNetwork, error);
+}
+
+void WiFiServiceMac::StartDisconnect(const std::string& network_guid,
+                                      std::string* error) {

[Robert Sesek, 2014/01/13 19:10:28]

nit: alignment

[mef, 2014/01/13 22:05:34]

Done.

+  DVLOG(1) << "*** StartDisconnect: " << network_guid;
+
+  if (network_guid == GUIDFromSSID([interface_ ssid])) {
+    [interface_ disassociate];
+  } else {
+    *error = kErrorNotConnected;
+  }
+}
+
+void WiFiServiceMac::SetEventObservers(
+    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    const NetworkGuidListCallback& networks_changed_observer,
+    const NetworkGuidListCallback& network_list_changed_observer) {
+  message_loop_proxy_.swap(message_loop_proxy);
+  networks_changed_observer_ = networks_changed_observer;
+  network_list_changed_observer_ = network_list_changed_observer;
+
+  // Subscribe to OS notifications.
+  wlan_observer_.reset([[NSNotificationCenter defaultCenter]

[Robert Sesek, 2014/01/13 19:10:28]

If SetEventObservers() is called twice, then you'll leak the previous observer.
But also note that you do not own the reference returned from -addObserver… so
this should not be in a scoper.

There shouldn't be an observer if the callbacks is_null(), either.

[mef, 2014/01/13 22:05:34]

Done.

+      addObserverForName:kCWSSIDDidChangeNotification
+                  object:nil
+                   queue:nil
+              usingBlock:^(NSNotification* notification) {
+          task_runner_->PostTask(

[Robert Sesek, 2014/01/13 19:10:28]

nit: this is supposed to be indented 4 spaces from the line that opened the
block. Since that will cause wrapping issues, pull the block out into a local:

http://google-styleguide.googlecode.com/svn/trunk/objcguide.xml?showone=Block...

[mef, 2014/01/13 22:05:34]

Done. I think.

+              FROM_HERE,
+              base::Bind(&WiFiServiceMac::OnWlanObserverNotification,
+                         base::Unretained(this)));
+        }]);
+}
+
+void WiFiServiceMac::WaitForNetworkConnect(const std::string& network_guid,
+                                            int attempt) {

[Robert Sesek, 2014/01/13 19:10:28]

nit: alignment

[mef, 2014/01/13 22:05:34]

Done.

+  // If network didn't get connected in |kMaxAttempts|, then stop waiting.
+  if (attempt > kConnectionCheckMaxAttempts) {
+    DLOG(ERROR) << kConnectionCheckMaxAttempts
+                << " attempts exceeded waiting for connect to "
+                << network_guid;
+    return;
+  }
+
+  if (GetNetworkConnectionState(network_guid) ==
+          onc::connection_state::kConnected) {
+    DVLOG(1) << "WiFi Connected, Reachable: " << network_guid;
+    NotifyNetworkChanged(network_guid);
+  } else {
+    // Continue waiting for network connection state change.

[Robert Sesek, 2014/01/13 19:10:28]

Do you need to poll for this, or can you use SCNetworkReachability to be
notified of reachability changes?

[mef, 2014/01/13 22:05:34]

I think reachability is better, I'll try to use it.

+    task_runner_->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&WiFiServiceMac::WaitForNetworkConnect,
+                   base::Unretained(this),
+                   network_guid,
+                   ++attempt),
+        base::TimeDelta::FromMilliseconds(kConnectionCheckAttemptDelayMs));
+  }
+}
+
+std::string WiFiServiceMac::GetNetworkConnectionState(
+  const std::string& network_guid) const {

[Robert Sesek, 2014/01/13 19:10:28]

nit: indent 2 more spaces

[mef, 2014/01/13 22:05:34]

Done.

+  if(network_guid != GUIDFromSSID([interface_ ssid]))

[Robert Sesek, 2014/01/13 19:10:28]

nit: space before (

[mef, 2014/01/13 22:05:34]

Done.

+    return onc::connection_state::kNotConnected;
+
+  // Check whether WiFi network is reachable.
+  struct sockaddr_in local_wifi_address;
+  bzero(&local_wifi_address, sizeof(local_wifi_address));
+  local_wifi_address.sin_len = sizeof(local_wifi_address);
+  local_wifi_address.sin_family = AF_INET;
+  local_wifi_address.sin_addr.s_addr = htonl(IN_LINKLOCALNETNUM);
+  base::ScopedCFTypeRef<SCNetworkReachabilityRef> reachability(
+      SCNetworkReachabilityCreateWithAddress(
+          kCFAllocatorDefault,
+          reinterpret_cast<const struct sockaddr*>(&local_wifi_address)));
+  SCNetworkReachabilityFlags flags = 0u;
+  if (SCNetworkReachabilityGetFlags(reachability, &flags) &&
+      (flags & kSCNetworkReachabilityFlagsReachable) &&
+      (flags & kSCNetworkReachabilityFlagsIsDirect)) {
+    // Network is reachable, report is as |kConnected|.
+    return onc::connection_state::kConnected;
+  }
+  // Network is not reachable yet, so it must be |kConnecting|.
+  return onc::connection_state::kConnecting;
+}
+
+
+void WiFiServiceMac::UpdateNetworks() {
+

[Robert Sesek, 2014/01/13 19:10:28]

nit: remove

[mef, 2014/01/13 22:05:34]

Done.

+  NSError* ns_error = nil;
+  NSSet* cw_networks = [interface_ scanForNetworksWithName:nil
+                                                     error:&ns_error];
+
+  if (ns_error != nil)
+    return;
+
+  std::map<std::string, NetworkProperties*> network_properties_map;
+  networks_.clear();

[tbarzic, 2014/01/13 19:39:30]

it would be nice to gather the list of networks whose properties have changed
ans trigger NetworksChanged notification for them.

[mef, 2014/01/14 22:10:31]

I should be able to do that, just what about networks that have appeared or
disappeared? Should they also be included in NetworksChanged notification, or
just NetworkListChanged?

[tbarzic, 2014/01/16 19:41:48]

hm, I think that ChromeOS version does send NetworksChanged in these cases, but
I'm not sure. From the cast extension's point of view, it's fine either way (it
uses primarily onNetworkListChange to detect network addition/removal).

I'm also fine if you leave this for a follow up.

[mef, 2014/01/16 23:42:48]

Sounds good. I'll add that to my TODO list for a follow up.

+
+  CWNetwork* cw_network;

[Robert Sesek, 2014/01/13 19:10:28]

You can move this into the for() loop expression.

[mef, 2014/01/13 22:05:34]

Done.

+  // There is one |cw_network| per BSS in |cw_networks|, so go through the set
+  // and combine them, paying attention to supported frequencies.
+  for (cw_network in cw_networks) {
+    NetworkProperties network_properties;
+    NetworkPropertiesFromCWNetwork(cw_network, &network_properties);
+
+    if (network_properties_map.find(network_properties.guid) ==
+        network_properties_map.end()) {

[Robert Sesek, 2014/01/13 19:10:28]

nit: indent 4 spaces more

[mef, 2014/01/13 22:05:34]

Done.

+      networks_.push_back(network_properties);
+      network_properties_map[network_properties.guid] = &networks_.back();
+    } else {

[Robert Sesek, 2014/01/13 19:10:28]

Do you need to update the networks_ list in case network_properties is
different?

[mef, 2014/01/13 22:05:34]

I'm just trying to coalesce all networks with same SSID into single
NetworkProperies object with multiple frequencies.

+      NetworkProperties* existing = network_properties_map.at(
+          network_properties.guid);
+      existing->frequency_set.insert(*network_properties.frequency_set.begin());
+    }
+  }
+  // Sort networks, so connected/connecting is up front.
+  networks_.sort(NetworkProperties::OrderByType);
+}
+
+bool WiFiServiceMac::CheckError(NSError* ns_error,
+                                 const char* error_name,

[Robert Sesek, 2014/01/13 19:10:28]

nit: alignment

[mef, 2014/01/13 22:05:34]

Done.

+                                 std::string* error) const {
+  if (ns_error != nil) {
+    DLOG(ERROR) << "*** Error:" << error_name << ":" << [ns_error code];
+    *error = error_name;
+    return true;
+  }
+  return false;
+}
+
+void WiFiServiceMac::NetworkPropertiesFromCWNetwork(
+    const CWNetwork* network,
+    NetworkProperties* properties) const {
+  std::string network_guid = GUIDFromSSID([network ssid]);
+
+  properties->connection_state = GetNetworkConnectionState(network_guid);
+  properties->ssid = base::SysNSStringToUTF8([network ssid]);
+  properties->name = properties->ssid;
+  properties->guid = network_guid;
+  properties->type = onc::network_type::kWiFi;
+
+  properties->bssid = base::SysNSStringToUTF8([network bssid]);
+  if ([[network wlanChannel] channelBand] == kCWChannelBand2GHz)
+    properties->frequency = kFrequency2400;
+  else
+    properties->frequency = kFrequency5000;
+  properties->frequency_set.insert(properties->frequency);
+  properties->security = SecurityFromCWSecurityMode(
+      static_cast<CWSecurityMode>([[network securityMode] intValue]));
+
+  properties->signal_strength = [[network rssi] intValue];
+}
+
+std::string WiFiServiceMac::SecurityFromCWSecurityMode(
+    CWSecurityMode security) const {
+  switch (security) {
+    case kCWSecurityModeWPA_Enterprise:
+    case kCWSecurityModeWPA2_Enterprise:
+      return onc::wifi::kWPA_EAP;
+    case kCWSecurityModeWPA_PSK:
+    case kCWSecurityModeWPA2_PSK:
+      return onc::wifi::kWPA_PSK;
+    case kCWSecurityModeWEP:
+      return onc::wifi::kWEP_PSK;
+    case kCWSecurityModeOpen:
+      return onc::wifi::kNone;
+    // TODO(mef): Figure out correct mapping.
+    case kCWSecurityModeWPS:
+    case kCWSecurityModeDynamicWEP:
+      return onc::wifi::kWPA_EAP;
+  }
+  return onc::wifi::kWPA_EAP;
+}
+
+void WiFiServiceMac::OnWlanObserverNotification() {
+  std::string connected_network_guid = GUIDFromSSID([interface_ ssid]);
+  DVLOG(1) << " *** Got Notification: " << connected_network_guid;
+  // There are 2 notifications for every network switch:
+  //  1. When old WLAN is disconnected, |connected_network_guid| is empty.
+  //  2. When new WLAN is connected, |connected_network_guid| is new network
+  //     guid.
+  if (connected_network_guid.empty()) {
+    // Find previously connected network and notify that it is disconnected.
+    for (WiFiService::NetworkList::iterator it = networks_.begin();
+         it != networks_.end();
+         ++it) {
+      if (it->connection_state == onc::connection_state::kConnected) {
+        it->connection_state = onc::connection_state::kNotConnected;
+        NotifyNetworkChanged(it->guid);
+      }
+    }
+  } else {
+    // Update connection_state of newly connected network.
+    for (WiFiService::NetworkList::iterator it = networks_.begin();
+         it != networks_.end();
+         ++it) {
+      if (it->guid == connected_network_guid) {
+        it->connection_state =
+            GetNetworkConnectionState(connected_network_guid);
+        NotifyNetworkChanged(connected_network_guid);
+        return;
+      }
+    }
+    // Can't find |connected_network_guid| in |networks_|, try to update it.
+    UpdateNetworks();
+    NotifyNetworkChanged(connected_network_guid);

[tbarzic, 2014/01/13 19:39:30]

WaitForNetworkConnect should probably be done here (instead of in start
connect), so we send an event when the network's connection state changes to
'Connected' (in case it's initially 'Connecting')

[mef, 2014/01/14 22:10:31]

Done.

+  }
+}
+
+void WiFiServiceMac::NotifyNetworkListChanged(const NetworkList& networks) {
+  if (network_list_changed_observer_.is_null())
+    return;
+
+  NetworkGuidList current_networks;
+  for (NetworkList::const_iterator it = networks.begin();
+       it != networks.end();
+       ++it) {
+    current_networks.push_back(it->guid);
+  }
+
+  message_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(network_list_changed_observer_, current_networks));
+}
+
+void WiFiServiceMac::NotifyNetworkChanged(const std::string& network_guid) {
+  if (networks_changed_observer_.is_null())
+    return;
+
+  DVLOG(1) << "NotifyNetworkChanged: " << network_guid;
+  NetworkGuidList changed_networks(1, network_guid);
+  message_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(networks_changed_observer_, changed_networks));
+}
+
+// static
+WiFiService* WiFiService::Create() { return new WiFiServiceMac(); }
+
+}  // namespace wifi