components/wifi/wifi_service_mac.mm

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/wifi/wifi_service.h"
   6
   7 #import <netinet/in.h>
   8 #import <CoreWLAN/CoreWLAN.h>
   9 #import <SystemConfiguration/SystemConfiguration.h>
  10
  11 #include "base/bind.h"
  12 #include "base/mac/foundation_util.h"
  13 #include "base/mac/scoped_cftyperef.h"
  14 #include "base/mac/scoped_nsobject.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/strings/sys_string_conversions.h"
  17 #include "components/onc/onc_constants.h"
  18
  19 #if !defined(MAC_OS_X_VERSION_10_7) || \
  20     MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
  21
  22 // Local definitions of API added in Mac OS X 10.7
  23
  24 @interface CWInterface (LionAPI)
  25 - (BOOL)associateToNetwork:(CWNetwork*)network
  26                   password:(NSString*)password
  27                      error:(NSError**)error;
  28 - (NSSet*)scanForNetworksWithName:(NSString*)networkName
  29                             error:(NSError**)error;
  30 @end
  31
  32 enum CWChannelBand {
  33   kCWChannelBandUnknown = 0,
  34   kCWChannelBand2GHz = 1,
  35   kCWChannelBand5GHz = 2,
  36 };
  37
  38 @interface CWChannel : NSObject
  39 @property(readonly) CWChannelBand channelBand;
  40 @end
  41
  42 @interface CWNetwork (LionAPI)
  43 @property(readonly) CWChannel* wlanChannel;
  44 @end
  45
  46 #endif  // 10.7
  47
  48 namespace wifi {
  49
  50 const char kErrorAssociateToNetwork[] = "Error.AssociateToNetwork";
  51 const char kErrorInvalidData[] = "Error.InvalidData";
  52 const char kErrorNotConnected[] = "Error.NotConnected";
  53 const char kErrorNotFound[] = "Error.NotFound";
  54 const char kErrorNotImplemented[] = "Error.NotImplemented";
  55 const char kErrorScanForNetworksWithName[] = "Error.ScanForNetworksWithName";
  56
  57 // Implementation of WiFiService for Mac OS X.
  58 class WiFiServiceMac : public WiFiService {
  59  public:
  60   WiFiServiceMac();
  61   virtual ~WiFiServiceMac();
  62
  63   // WiFiService interface implementation.
  64   virtual void Initialize(
  65       scoped_refptr<base::SequencedTaskRunner> task_runner) OVERRIDE;
  66
  67   virtual void UnInitialize() OVERRIDE;
  68
  69   virtual void GetProperties(const std::string& network_guid,
  70                              base::DictionaryValue* properties,
  71                              std::string* error) OVERRIDE;
  72
  73   virtual void GetManagedProperties(const std::string& network_guid,
  74                                     base::DictionaryValue* managed_properties,
  75                                     std::string* error) OVERRIDE;
  76
  77   virtual void GetState(const std::string& network_guid,
  78                         base::DictionaryValue* properties,
  79                         std::string* error) OVERRIDE;
  80
  81   virtual void SetProperties(const std::string& network_guid,
  82                              scoped_ptr<base::DictionaryValue> properties,
  83                              std::string* error) OVERRIDE;
  84
  85   virtual void CreateNetwork(bool shared,
  86                              scoped_ptr<base::DictionaryValue> properties,
  87                              std::string* network_guid,
  88                              std::string* error) OVERRIDE;
  89
  90   virtual void GetVisibleNetworks(const std::string& network_type,
  91                                   base::ListValue* network_list) OVERRIDE;
  92
  93   virtual void RequestNetworkScan() OVERRIDE;
  94
  95   virtual void StartConnect(const std::string& network_guid,
  96                             std::string* error) OVERRIDE;
  97
  98   virtual void StartDisconnect(const std::string& network_guid,
  99                                std::string* error) OVERRIDE;
 100
 101   virtual void GetKeyFromSystem(const std::string& network_guid,
 102                                 std::string* key_data,
 103                                 std::string* error) OVERRIDE;
 104
 105   virtual void SetEventObservers(
 106       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
 107       const NetworkGuidListCallback& networks_changed_observer,
 108       const NetworkGuidListCallback& network_list_changed_observer) OVERRIDE;
 109
 110   virtual void RequestConnectedNetworkUpdate() OVERRIDE;
 111
 112  private:
 113   // Checks |ns_error| and if is not |nil|, then stores |error_name|
 114   // into |error|.
 115   bool CheckError(NSError* ns_error,
 116                   const char* error_name,
 117                   std::string* error) const;
 118
 119   // Gets |ssid| from unique |network_guid|.
 120   NSString* SSIDFromGUID(const std::string& network_guid) const {
 121     return base::SysUTF8ToNSString(network_guid);
 122   }
 123
 124   // Gets unique |network_guid| string based on |ssid|.
 125   std::string GUIDFromSSID(NSString* ssid) const {
 126     return base::SysNSStringToUTF8(ssid);
 127   }
 128
 129   // Populates |properties| from |network|.
 130   void NetworkPropertiesFromCWNetwork(const CWNetwork* network,
 131                                       NetworkProperties* properties) const;
 132
 133   // Converts |CWSecurityMode| into onc::wifi::k{WPA|WEP}* security constant.
 134   std::string SecurityFromCWSecurityMode(CWSecurityMode security) const;
 135
 136   // Converts |CWChannelBand| into WiFiService::Frequency constant.
 137   Frequency FrequencyFromCWChannelBand(CWChannelBand band) const;
 138
 139   // Gets current |onc::connection_state| for given |network_guid|.
 140   std::string GetNetworkConnectionState(const std::string& network_guid) const;
 141
 142   // Updates |networks_| with the list of visible wireless networks.
 143   void UpdateNetworks();
 144
 145   // Find network by |network_guid| and return iterator to its entry in
 146   // |networks_|.
 147   NetworkList::iterator FindNetwork(const std::string& network_guid);
 148
 149   // Handles notification from |wlan_observer_|.
 150   void OnWlanObserverNotification();
 151
 152   // Notifies |network_list_changed_observer_| that list of visible networks has
 153   // changed to |networks|.
 154   void NotifyNetworkListChanged(const NetworkList& networks);
 155
 156   // Notifies |networks_changed_observer_| that network |network_guid|
 157   // connection state has changed.
 158   void NotifyNetworkChanged(const std::string& network_guid);
 159
 160   // Default interface.
 161   base::scoped_nsobject<CWInterface> interface_;
 162   // WLAN Notifications observer. |this| doesn't own this reference.
 163   id wlan_observer_;
 164
 165   // Observer to get notified when network(s) have changed (e.g. connect).
 166   NetworkGuidListCallback networks_changed_observer_;
 167   // Observer to get notified when network list has changed.
 168   NetworkGuidListCallback network_list_changed_observer_;
 169   // MessageLoopProxy to which events should be posted.
 170   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
 171   // Task runner for worker tasks.
 172   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 173   // Cached list of visible networks. Updated by |UpdateNetworks|.
 174   NetworkList networks_;
 175   // Guid of last known connected network.
 176   std::string connected_network_guid_;
 177   // Temporary storage of network properties indexed by |network_guid|.
 178   base::DictionaryValue network_properties_;
 179
 180   DISALLOW_COPY_AND_ASSIGN(WiFiServiceMac);
 181 };
 182
 183 WiFiServiceMac::WiFiServiceMac() : wlan_observer_(nil) {
 184 }
 185
 186 WiFiServiceMac::~WiFiServiceMac() {
 187 }
 188
 189 void WiFiServiceMac::Initialize(
 190   scoped_refptr<base::SequencedTaskRunner> task_runner) {
 191   task_runner_.swap(task_runner);
 192   interface_.reset([[CWInterface interface] retain]);
 193   if (!interface_) {
 194     DVLOG(1) << "Failed to initialize default interface.";
 195     return;
 196   }
 197
 198   if (![interface_
 199           respondsToSelector:@selector(associateToNetwork:password:error:)]) {
 200     DVLOG(1) << "CWInterface does not support associateToNetwork.";
 201     interface_.reset();
 202     return;
 203   }
 204 }
 205
 206 void WiFiServiceMac::UnInitialize() {
 207   if (wlan_observer_)
 208     [[NSNotificationCenter defaultCenter] removeObserver:wlan_observer_];
 209   interface_.reset();
 210 }
 211
 212 void WiFiServiceMac::GetProperties(const std::string& network_guid,
 213                                    base::DictionaryValue* properties,
 214                                    std::string* error) {
 215   NetworkList::iterator it = FindNetwork(network_guid);
 216   if (it == networks_.end()) {
 217     DVLOG(1) << "Network not found:" << network_guid;
 218     *error = kErrorNotFound;
 219     return;
 220   }
 221
 222   it->connection_state = GetNetworkConnectionState(network_guid);
 223   scoped_ptr<base::DictionaryValue> network(it->ToValue(false));
 224   properties->Swap(network.get());
 225   DVLOG(1) << *properties;
 226 }
 227
 228 void WiFiServiceMac::GetManagedProperties(
 229     const std::string& network_guid,
 230     base::DictionaryValue* managed_properties,
 231     std::string* error) {
 232   *error = kErrorNotImplemented;
 233 }
 234
 235 void WiFiServiceMac::GetState(const std::string& network_guid,
 236                               base::DictionaryValue* properties,
 237                               std::string* error) {
 238   *error = kErrorNotImplemented;
 239 }
 240
 241 void WiFiServiceMac::SetProperties(
 242     const std::string& network_guid,
 243     scoped_ptr<base::DictionaryValue> properties,
 244     std::string* error) {
 245   base::DictionaryValue* existing_properties;
 246   // If the network properties already exist, don't override previously set
 247   // properties, unless they are set in |properties|.
 248   if (network_properties_.GetDictionaryWithoutPathExpansion(
 249           network_guid, &existing_properties)) {
 250     existing_properties->MergeDictionary(properties.get());
 251   } else {
 252     network_properties_.SetWithoutPathExpansion(network_guid,
 253                                                 properties.release());
 254   }
 255 }
 256
 257 void WiFiServiceMac::CreateNetwork(
 258     bool shared,
 259     scoped_ptr<base::DictionaryValue> properties,
 260     std::string* network_guid,
 261     std::string* error) {
 262   WiFiService::NetworkProperties network_properties;
 263   if (!network_properties.UpdateFromValue(*properties)) {
 264     *error = kErrorInvalidData;
 265     return;
 266   }
 267
 268   std::string guid = network_properties.ssid;
 269   if (FindNetwork(guid) != networks_.end()) {
 270     *error = kErrorInvalidData;
 271     return;
 272   }
 273   network_properties_.SetWithoutPathExpansion(guid,
 274                                               properties.release());
 275   *network_guid = guid;
 276 }
 277
 278 void WiFiServiceMac::GetVisibleNetworks(const std::string& network_type,
 279                                         base::ListValue* network_list) {
 280   if (!network_type.empty() &&
 281       network_type != onc::network_type::kAllTypes &&
 282       network_type != onc::network_type::kWiFi) {
 283     return;
 284   }
 285
 286   if (networks_.empty())
 287     UpdateNetworks();
 288
 289   for (WiFiService::NetworkList::const_iterator it = networks_.begin();
 290        it != networks_.end();
 291        ++it) {
 292     scoped_ptr<base::DictionaryValue> network(it->ToValue(true));
 293     network_list->Append(network.release());
 294   }
 295 }
 296
 297 void WiFiServiceMac::RequestNetworkScan() {
 298   DVLOG(1) << "*** RequestNetworkScan";
 299   UpdateNetworks();
 300 }
 301
 302 void WiFiServiceMac::StartConnect(const std::string& network_guid,
 303                                   std::string* error) {
 304   NSError* ns_error = nil;
 305
 306   DVLOG(1) << "*** StartConnect: " << network_guid;
 307   // Remember previously connected network.
 308   std::string connected_network_guid = GUIDFromSSID([interface_ ssid]);
 309   // Check whether desired network is already connected.
 310   if (network_guid == connected_network_guid)
 311     return;
 312
 313   NSSet* networks = [interface_
 314       scanForNetworksWithName:SSIDFromGUID(network_guid)
 315                         error:&ns_error];
 316
 317   if (CheckError(ns_error, kErrorScanForNetworksWithName, error))
 318     return;
 319
 320   CWNetwork* network = [networks anyObject];
 321   if (network == nil) {
 322     // System can't find the network, remove it from the |networks_| and notify
 323     // observers.
 324     NetworkList::iterator it = FindNetwork(connected_network_guid);
 325     if (it != networks_.end()) {
 326       networks_.erase(it);
 327       // Notify observers that list has changed.
 328       NotifyNetworkListChanged(networks_);
 329     }
 330
 331     *error = kErrorNotFound;
 332     return;
 333   }
 334
 335   // Check whether WiFi Password is set in |network_properties_|.
 336   base::DictionaryValue* properties;
 337   base::DictionaryValue* wifi;
 338   std::string passphrase;
 339   NSString* ns_password = nil;
 340   if (network_properties_.GetDictionaryWithoutPathExpansion(network_guid,
 341                                                             &properties) &&
 342       properties->GetDictionary(onc::network_type::kWiFi, &wifi) &&
 343       wifi->GetString(onc::wifi::kPassphrase, &passphrase)) {
 344     ns_password = base::SysUTF8ToNSString(passphrase);
 345   }
 346
 347   // Number of attempts to associate to network.
 348   static const int kMaxAssociationAttempts = 3;
 349   // Try to associate to network several times if timeout or PMK error occurs.
 350   for (int i = 0; i < kMaxAssociationAttempts; ++i) {
 351     // Nil out the PMK to prevent stale data from causing invalid PMK error
 352     // (CoreWLANTypes -3924).
 353     [interface_ setPairwiseMasterKey:nil error:&ns_error];
 354     if (![interface_ associateToNetwork:network
 355                               password:ns_password
 356                                  error:&ns_error]) {
 357       NSInteger error_code = [ns_error code];
 358       if (error_code != kCWTimeoutErr && error_code != kCWInvalidPMKErr) {
 359         break;
 360       }
 361     }
 362   }
 363   CheckError(ns_error, kErrorAssociateToNetwork, error);
 364 }
 365
 366 void WiFiServiceMac::StartDisconnect(const std::string& network_guid,
 367                                      std::string* error) {
 368   DVLOG(1) << "*** StartDisconnect: " << network_guid;
 369
 370   if (network_guid == GUIDFromSSID([interface_ ssid])) {
 371     // Power-cycle the interface to disconnect from current network and connect
 372     // to default network.
 373     NSError* ns_error = nil;
 374     [interface_ setPower:NO error:&ns_error];
 375     CheckError(ns_error, kErrorAssociateToNetwork, error);
 376     [interface_ setPower:YES error:&ns_error];
 377     CheckError(ns_error, kErrorAssociateToNetwork, error);
 378   } else {
 379     *error = kErrorNotConnected;
 380   }
 381 }
 382
 383 void WiFiServiceMac::GetKeyFromSystem(const std::string& network_guid,
 384                                       std::string* key_data,
 385                                       std::string* error) {
 386   static const char kAirPortServiceName[] = "AirPort";
 387
 388   UInt32 password_length = 0;
 389   void *password_data = NULL;
 390   OSStatus status = SecKeychainFindGenericPassword(NULL,
 391                                                    strlen(kAirPortServiceName),
 392                                                    kAirPortServiceName,
 393                                                    network_guid.length(),
 394                                                    network_guid.c_str(),
 395                                                    &password_length,
 396                                                    &password_data,
 397                                                    NULL);
 398   if (status != errSecSuccess) {
 399     *error = kErrorNotFound;
 400     return;
 401   }
 402
 403   if (password_data) {
 404     *key_data = std::string(reinterpret_cast<char*>(password_data),
 405                             password_length);
 406     SecKeychainItemFreeContent(NULL, password_data);
 407   }
 408 }
 409
 410 void WiFiServiceMac::SetEventObservers(
 411     scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
 412     const NetworkGuidListCallback& networks_changed_observer,
 413     const NetworkGuidListCallback& network_list_changed_observer) {
 414   message_loop_proxy_.swap(message_loop_proxy);
 415   networks_changed_observer_ = networks_changed_observer;
 416   network_list_changed_observer_ = network_list_changed_observer;
 417
 418   // Remove previous OS notifications observer.
 419   if (wlan_observer_) {
 420     [[NSNotificationCenter defaultCenter] removeObserver:wlan_observer_];
 421     wlan_observer_ = nil;
 422   }
 423
 424   // Subscribe to OS notifications.
 425   if (!networks_changed_observer_.is_null()) {
 426     void (^ns_observer) (NSNotification* notification) =
 427         ^(NSNotification* notification) {
 428             DVLOG(1) << "Received CWSSIDDidChangeNotification";
 429             task_runner_->PostTask(
 430                 FROM_HERE,
 431                 base::Bind(&WiFiServiceMac::OnWlanObserverNotification,
 432                            base::Unretained(this)));
 433     };
 434
 435     wlan_observer_ = [[NSNotificationCenter defaultCenter]
 436         addObserverForName:kCWSSIDDidChangeNotification
 437                     object:nil
 438                      queue:nil
 439                 usingBlock:ns_observer];
 440   }
 441 }
 442
 443 void WiFiServiceMac::RequestConnectedNetworkUpdate() {
 444   OnWlanObserverNotification();
 445 }
 446
 447 std::string WiFiServiceMac::GetNetworkConnectionState(
 448     const std::string& network_guid) const {
 449   if (network_guid != GUIDFromSSID([interface_ ssid]))
 450     return onc::connection_state::kNotConnected;
 451
 452   // Check whether WiFi network is reachable.
 453   struct sockaddr_in local_wifi_address;
 454   bzero(&local_wifi_address, sizeof(local_wifi_address));
 455   local_wifi_address.sin_len = sizeof(local_wifi_address);
 456   local_wifi_address.sin_family = AF_INET;
 457   local_wifi_address.sin_addr.s_addr = htonl(IN_LINKLOCALNETNUM);
 458   base::ScopedCFTypeRef<SCNetworkReachabilityRef> reachability(
 459       SCNetworkReachabilityCreateWithAddress(
 460           kCFAllocatorDefault,
 461           reinterpret_cast<const struct sockaddr*>(&local_wifi_address)));
 462   SCNetworkReachabilityFlags flags = 0u;
 463   if (SCNetworkReachabilityGetFlags(reachability, &flags) &&
 464       (flags & kSCNetworkReachabilityFlagsReachable) &&
 465       (flags & kSCNetworkReachabilityFlagsIsDirect)) {
 466     // Network is reachable, report is as |kConnected|.
 467     return onc::connection_state::kConnected;
 468   }
 469   // Network is not reachable yet, so it must be |kConnecting|.
 470   return onc::connection_state::kConnecting;
 471 }
 472
 473 void WiFiServiceMac::UpdateNetworks() {
 474   NSError* ns_error = nil;
 475   NSSet* cw_networks = [interface_ scanForNetworksWithName:nil
 476                                                      error:&ns_error];
 477   if (ns_error != nil)
 478     return;
 479
 480   std::string connected_bssid = base::SysNSStringToUTF8([interface_ bssid]);
 481   std::map<std::string, NetworkProperties*> network_properties_map;
 482   networks_.clear();
 483
 484   // There is one |cw_network| per BSS in |cw_networks|, so go through the set
 485   // and combine them, paying attention to supported frequencies.
 486   for (CWNetwork* cw_network in cw_networks) {
 487     std::string network_guid = GUIDFromSSID([cw_network ssid]);
 488     bool update_all_properties = false;
 489
 490     if (network_properties_map.find(network_guid) ==
 491             network_properties_map.end()) {
 492       networks_.push_back(NetworkProperties());
 493       network_properties_map[network_guid] = &networks_.back();
 494       update_all_properties = true;
 495     }
 496     // If current network is connected, use its properties for this network.
 497     if (base::SysNSStringToUTF8([cw_network bssid]) == connected_bssid)
 498       update_all_properties = true;
 499
 500     NetworkProperties* properties = network_properties_map.at(network_guid);
 501     if (update_all_properties) {
 502       NetworkPropertiesFromCWNetwork(cw_network, properties);
 503     } else {
 504       properties->frequency_set.insert(FrequencyFromCWChannelBand(
 505           [[cw_network wlanChannel] channelBand]));
 506     }
 507   }
 508   // Sort networks, so connected/connecting is up front.
 509   networks_.sort(NetworkProperties::OrderByType);
 510   // Notify observers that list has changed.
 511   NotifyNetworkListChanged(networks_);
 512 }
 513
 514 bool WiFiServiceMac::CheckError(NSError* ns_error,
 515                                 const char* error_name,
 516                                 std::string* error) const {
 517   if (ns_error != nil) {
 518     DLOG(ERROR) << "*** Error:" << error_name << ":" << [ns_error code];
 519     *error = error_name;
 520     return true;
 521   }
 522   return false;
 523 }
 524
 525 void WiFiServiceMac::NetworkPropertiesFromCWNetwork(
 526     const CWNetwork* network,
 527     NetworkProperties* properties) const {
 528   std::string network_guid = GUIDFromSSID([network ssid]);
 529
 530   properties->connection_state = GetNetworkConnectionState(network_guid);
 531   properties->ssid = base::SysNSStringToUTF8([network ssid]);
 532   properties->name = properties->ssid;
 533   properties->guid = network_guid;
 534   properties->type = onc::network_type::kWiFi;
 535
 536   properties->bssid = base::SysNSStringToUTF8([network bssid]);
 537   properties->frequency = FrequencyFromCWChannelBand(
 538       static_cast<CWChannelBand>([[network wlanChannel] channelBand]));
 539   properties->frequency_set.insert(properties->frequency);
 540   properties->security = SecurityFromCWSecurityMode(
 541       static_cast<CWSecurityMode>([[network securityMode] intValue]));
 542
 543   properties->signal_strength = [[network rssi] intValue];
 544 }
 545
 546 std::string WiFiServiceMac::SecurityFromCWSecurityMode(
 547     CWSecurityMode security) const {
 548   switch (security) {
 549     case kCWSecurityModeWPA_Enterprise:
 550     case kCWSecurityModeWPA2_Enterprise:
 551       return onc::wifi::kWPA_EAP;
 552     case kCWSecurityModeWPA_PSK:
 553     case kCWSecurityModeWPA2_PSK:
 554       return onc::wifi::kWPA_PSK;
 555     case kCWSecurityModeWEP:
 556       return onc::wifi::kWEP_PSK;
 557     case kCWSecurityModeOpen:
 558       return onc::wifi::kNone;
 559     // TODO(mef): Figure out correct mapping.
 560     case kCWSecurityModeWPS:
 561     case kCWSecurityModeDynamicWEP:
 562       return onc::wifi::kWPA_EAP;
 563   }
 564   return onc::wifi::kWPA_EAP;
 565 }
 566
 567
 568 WiFiService::Frequency WiFiServiceMac::FrequencyFromCWChannelBand(
 569     CWChannelBand band) const {
 570   return band == kCWChannelBand2GHz ? kFrequency2400 : kFrequency5000;
 571 }
 572
 573 WiFiService::NetworkList::iterator WiFiServiceMac::FindNetwork(
 574     const std::string& network_guid) {
 575   for (NetworkList::iterator it = networks_.begin();
 576        it != networks_.end();
 577        ++it) {
 578     if (it->guid == network_guid)
 579       return it;
 580   }
 581   return networks_.end();
 582 }
 583
 584 void WiFiServiceMac::OnWlanObserverNotification() {
 585   std::string connected_network_guid = GUIDFromSSID([interface_ ssid]);
 586   DVLOG(1) << " *** Got Notification: " << connected_network_guid;
 587   // Connected network has changed, mark previous one disconnected.
 588   if (connected_network_guid != connected_network_guid_) {
 589     // Update connection_state of newly connected network.
 590     NetworkList::iterator it = FindNetwork(connected_network_guid_);
 591     if (it != networks_.end()) {
 592       it->connection_state = onc::connection_state::kNotConnected;
 593       NotifyNetworkChanged(connected_network_guid_);
 594     }
 595     connected_network_guid_ = connected_network_guid;
 596   }
 597
 598   if (!connected_network_guid.empty()) {
 599     // Update connection_state of newly connected network.
 600     NetworkList::iterator it = FindNetwork(connected_network_guid);
 601     if (it != networks_.end()) {
 602       it->connection_state = GetNetworkConnectionState(connected_network_guid);
 603     } else {
 604       // Can't find |connected_network_guid| in |networks_|, try to update it.
 605       UpdateNetworks();
 606     }
 607     // Notify that network is connecting.
 608     NotifyNetworkChanged(connected_network_guid);
 609     // Further network change notification will be sent by detector.
 610   }
 611 }
 612
 613 void WiFiServiceMac::NotifyNetworkListChanged(const NetworkList& networks) {
 614   if (network_list_changed_observer_.is_null())
 615     return;
 616
 617   NetworkGuidList current_networks;
 618   for (NetworkList::const_iterator it = networks.begin();
 619        it != networks.end();
 620        ++it) {
 621     current_networks.push_back(it->guid);
 622   }
 623
 624   message_loop_proxy_->PostTask(
 625       FROM_HERE,
 626       base::Bind(network_list_changed_observer_, current_networks));
 627 }
 628
 629 void WiFiServiceMac::NotifyNetworkChanged(const std::string& network_guid) {
 630   if (networks_changed_observer_.is_null())
 631     return;
 632
 633   DVLOG(1) << "NotifyNetworkChanged: " << network_guid;
 634   NetworkGuidList changed_networks(1, network_guid);
 635   message_loop_proxy_->PostTask(
 636       FROM_HERE,
 637       base::Bind(networks_changed_observer_, changed_networks));
 638 }
 639
 640 // static
 641 WiFiService* WiFiService::Create() { return new WiFiServiceMac(); }
 642
 643 }  // namespace wifi