Mac OS X-specific implementation of Networking Private API.

components/wifi/wifi_service_mac.mm

+// Copyright 2013 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"
+
+#include "base/bind.h"
+#include "base/mac/scoped_nsautorelease_pool.h"
+#include "base/mac/scoped_nsobject.h"
+#include "base/message_loop/message_loop.h"
+#include "components/onc/onc_constants.h"
+
+#import <netinet/in.h>
+#import <CoreWLAN/CoreWLAN.h>
+#import <SystemConfiguration/SystemConfiguration.h>
+
+namespace {
+// Declare notification names from the 10.7 SDK.
+const char* kCWSSIDDidChangeNotification_chrome =
+    "com.apple.coreWLAN.notification.ssid";
+}  // namespace
+
+#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
+
+// Observe CoreWLAN notifications and call |WiFiServiceImpl| on worker thread.
+@interface WLANNotificationObserver : NSObject {
+  // Task runner for worker tasks.
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+  // Notification handler.
+  base::Closure notification_handler_;
+}
+@end
+
+@implementation WLANNotificationObserver
+
+// Upon receiving |notification| post |notification_handler_| to |task_runner_|.
+- (void)handleInterfaceNotification:(NSNotification*)notification {
+  DCHECK(task_runner_);
+  DCHECK(!notification_handler_.is_null());
+  task_runner_->PostTask(FROM_HERE, notification_handler_);
+}
+
+// Start listening for WLAN notifications.
+- (void)startListen:(base::Closure) notification_handler
+    usingTaskRunner:(scoped_refptr<base::SequencedTaskRunner>) task_runner {
+  notification_handler_ = notification_handler;
+  task_runner_ = task_runner;
+  [[NSNotificationCenter defaultCenter]
+      addObserver:self
+      selector:@selector(handleInterfaceNotification:)
+      name:[NSString stringWithUTF8String:kCWSSIDDidChangeNotification_chrome]
+      object:nil];
+}
+
+// Stop listening for WLAN notifications.
+- (void)stopListen
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+@end
+
+namespace wifi {
+
+// Implementation of WiFiService for Mac OS X.
+class WiFiServiceImpl : public WiFiService {
+ public:
+  WiFiServiceImpl();
+  virtual ~WiFiServiceImpl();
+
+  // 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:
+  // Check |nsError| and if is not |nil|, then store |error_name|
+  // into |error|.
+  bool CheckError(NSError* nsError,
+                  const char* error_name,
+                  std::string* error) const;
+
+  // Get |ssid| from unique |network_guid|.
+  NSString* SSIDFromGUID(const std::string& network_guid) const {
+    return [NSString stringWithUTF8String:network_guid.c_str()];
+  }
+
+  // Get unique |network_guid| string based on |ssid|.
+  std::string GUIDFromSSID(NSString* ssid) const {
+    if (ssid == nil)
+      return std::string();
+    return std::string([ssid UTF8String]);
+  }
+
+  // Populate |properties| from |network|.
+  void NetworkPropertiesFromCWNetwork(const CWNetwork* network,
+                                      NetworkProperties* properties) const;
+
+  // Convert |CWSecurityMode| into onc::wifi::k{WPA|WEP}* security constant.
+  std::string SecurityFromCWSecurityMode(CWSecurityMode security) const;
+
+  // Wait up to |kMaxAttempts| with |kAttemptDelayMs| delay for connection
+  // to network with |network_guid|. Notify that |NetworkChanged| upon success.
+  void WaitForNetworkConnect(const std::string& network_guid, int attempt);
+
+  // Get the list of visible wireless networks. If |network_guid| is not empty,
+  // then only return that network.
+  NSError* GetVisibleNetworkList(const std::string& network_guid,
+                                 NetworkList* network_list);
+
+  // Sort networks, so connected/connecting is up front, then by type:
+  // Ethernet, WiFi, Cellular, VPN
+  static void SortNetworks(NetworkList* networks);
+
+  // Handle notification from |WLANListener|;
+  void OnListenerNotification();
+
+  // Notify |network_list_changed_observer_| that list of visible networks has
+  // changed to |networks|.
+  void NotifyNetworkListChanged(const NetworkList& networks);
+
+  // Notify |networks_changed_observer_| that network |network_guid| status has
+  // changed.
+  void NotifyNetworkChanged(const std::string& network_guid);
+
+  // CoreWLAN.Framework bundle.
+  base::scoped_nsobject<NSBundle> bundle_;
+  // Default interface.
+  base::scoped_nsobject<CWInterface> interface_;
+  // WLAN Notifications observer.
+  base::scoped_nsobject<WLANNotificationObserver> 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_;
+  // If |false|, then |networks_changed_observer_| is not notified.
+  bool enable_notify_network_changed_;
+  // Number of attempts to check that network has connected successfully.
+  static const int kMaxAttempts = 200;
+  // Delay between attempts to check that network has connected successfully.
+  static const int kAttemptDelayMs = 100;
+};
+
+WiFiServiceImpl::WiFiServiceImpl() : enable_notify_network_changed_(true) {
+}
+
+WiFiServiceImpl::~WiFiServiceImpl() {
+}
+
+void WiFiServiceImpl::Initialize(
+  scoped_refptr<base::SequencedTaskRunner> task_runner) {
+  // As the WLAN api binding runs on its own thread, we need to provide our own
+  // auto release pool. It's simplest to do this as an automatic variable in
+  // each method that needs it, to ensure the scoping is correct and does not
+  // interfere with any other code using autorelease pools on the thread.
+  base::mac::ScopedNSAutoreleasePool auto_pool;
+
+  task_runner_.swap(task_runner);
+
+  bundle_.reset([[NSBundle alloc]
+      initWithPath:@"/System/Library/Frameworks/CoreWLAN.framework"]);
+  if (!bundle_) {
+    DVLOG(1) << "Failed to load the CoreWLAN framework bundle";
+    return;
+  }
+
+  Class cw_interface_class = [bundle_ classNamed:@"CWInterface"];
+  interface_.reset([[cw_interface_class interface] retain]);
+  if (!bundle_) {
+    DVLOG(1) << "Failed to initialize default interface";
+    return;
+  }
+
+  WLANNotificationObserver* observer = [[WLANNotificationObserver alloc] init];
+  [observer startListen:base::Bind(&WiFiServiceImpl::OnListenerNotification,
+                                   base::Unretained(this))
+        usingTaskRunner:task_runner_];
+  wlan_observer_.reset(observer);
+}
+
+void WiFiServiceImpl::UnInitialize() {
+  [wlan_observer_ stopListen];
+}
+
+void WiFiServiceImpl::GetProperties(const std::string& network_guid,
+                                    base::DictionaryValue* properties,
+                                    std::string* error) {
+  base::mac::ScopedNSAutoreleasePool auto_pool;
+
+  if (networks_.empty()) {
+    DVLOG(1) << "GetProperties";
+    NSError* nsError = GetVisibleNetworkList(std::string(), &networks_);
+    if (CheckError(nsError, "Error.GetProperties", error))
+      return;
+  }
+
+  for (WiFiService::NetworkList::iterator it = networks_.begin();
+       it != networks_.end();
+       ++it) {
+    if (it->guid == network_guid) {
+      bool is_connected = network_guid == GUIDFromSSID([interface_ ssid]);
+      it->connection_state =
+          is_connected ? onc::connection_state::kConnected :
+                         onc::connection_state::kNotConnected;
+      scoped_ptr<base::DictionaryValue> network(it->ToValue(false));
+      properties->Swap(network.get());
+      DVLOG(1) << *properties;
+      return;
+    }
+  }
+
+  *error = "Error.NotFound";
+}
+
+void WiFiServiceImpl::GetManagedProperties(
+    const std::string& network_guid,
+    base::DictionaryValue* managed_properties,
+    std::string* error) {
+  *error = "Error.NotImplemented";
+}
+
+void WiFiServiceImpl::GetState(const std::string& network_guid,
+                               base::DictionaryValue* properties,
+                               std::string* error) {
+  *error = "Error.NotImplemented";
+}
+
+void WiFiServiceImpl::SetProperties(
+    const std::string& network_guid,
+    scoped_ptr<base::DictionaryValue> properties,
+    std::string* error) {
+  base::mac::ScopedNSAutoreleasePool auto_pool;
+  network_properties_.SetWithoutPathExpansion(network_guid,
+                                              properties.release());
+}
+
+void WiFiServiceImpl::CreateNetwork(
+    bool shared,
+    scoped_ptr<base::DictionaryValue> properties,
+    std::string* network_guid,
+    std::string* error) {
+  *error = "Error.NotImplemented";
+}
+
+void WiFiServiceImpl::GetVisibleNetworks(const std::string& network_type,
+                                         base::ListValue* network_list) {
+  if (!network_type.empty() &&
+      network_type != onc::network_type::kAllTypes &&
+      network_type != onc::network_type::kWiFi) {
+    return;
+  }
+
+  DVLOG(1) << __FUNCTION__;
+
+  base::mac::ScopedNSAutoreleasePool auto_pool;
+
+  GetVisibleNetworkList(std::string(), &networks_);
+
+  SortNetworks(&networks_);
+  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 WiFiServiceImpl::RequestNetworkScan() {
+  base::mac::ScopedNSAutoreleasePool auto_pool;
+  NetworkList networks;
+  DVLOG(1) << __FUNCTION__;
+
+  NSError* nsError = GetVisibleNetworkList(std::string(), &networks);
+  if (nsError == nil && !networks.empty()) {
+    NotifyNetworkListChanged(networks);
+  }
+}
+
+void WiFiServiceImpl::StartConnect(const std::string& network_guid,
+                                   std::string* error) {
+  base::mac::ScopedNSAutoreleasePool auto_pool;
+  NSError* nsError = nil;
+
+  DVLOG(1) << "*** StartConnect: " << network_guid;
+  NSSet* networks = [interface_
+      scanForNetworksWithName:SSIDFromGUID(network_guid)
+                        error:&nsError];
+
+  if (CheckError(nsError, "Error.scanForNetworksWithName", error))
+    return;
+
+  CWNetwork* network = [networks anyObject];
+  if (network != nil) {

[stevenjb, 2013/12/27 19:53:44]

if (network == nil) {
  *error = "Error.NotFound";
  return;
}

[mef, 2013/12/27 21:08:12]

Done.

+    // Remember previously connected network.
+    std::string connected_network_guid = GUIDFromSSID([interface_ ssid]);
+    // Check, whether desired network is already connected.
+    if (network_guid == connected_network_guid) {
+      NotifyNetworkChanged(connected_network_guid);
+      return;
+    }
+    // Check whether WiFi Password is set in |network_properties_|
+    base::DictionaryValue* properties;
+    base::DictionaryValue* wifi;
+    std::string passphrase;
+    NSString* nsPassword = nil;
+    if (network_properties_.GetDictionaryWithoutPathExpansion(network_guid,
+                                                              &properties) &&
+        properties->GetDictionary(onc::network_type::kWiFi, &wifi) &&
+        wifi->GetString(onc::wifi::kPassphrase, &passphrase)) {
+      nsPassword = [NSString stringWithUTF8String:passphrase.c_str()];
+    }
+
+    // Disable automatic network change notifications as they get fired
+    // when network is just connected, but not yet accessible (doesn't
+    // have valid IP address).
+    enable_notify_network_changed_ = false;
+
+    // Try to associate to network at least 3 times.
+    for (int i = 0; i < 3; ++i) {

[stevenjb, 2013/12/27 19:53:44]

Avoid magic numbers; make 3 a constant and comment why 3. Maybe posting a
delayed task would be a better approach? i.e. add a WaitForNetworkAssociate
method similar to WaitForNetworkConnect?

[mef, 2013/12/27 21:08:12]

I've 'borrowed' this from ChromeCast setup app
(AssociateToNetworkAsyncOperation.m:204).
I don't think posting task is needed here as there is no delay between retries.
I've added a constant and a comment.

+      // Clear PMK for the interface.
+      [interface_ setPairwiseMasterKey:nil error:&nsError];
+      if ([interface_ associateToNetwork:network
+                                password:nsPassword
+                                   error:&nsError]) {
+        // Notify that previously connected network has changed.
+        NotifyNetworkChanged(connected_network_guid);
+
+        // Start waiting for network connection state change.
+        if (!networks_changed_observer_.is_null()) {
+          WaitForNetworkConnect(network_guid, 0);
+          return;
+        }
+      } else {
+        long error_code = [nsError code];
+        if (error_code != kCWTimeoutErr && error_code != kCWInvalidPMKErr) {
+          break;
+        }
+      }
+    }
+    enable_notify_network_changed_ = true;
+    CheckError(nsError, "Error.associateToNetwork", error);
+  } else {
+    *error = "Error.NotFound";
+  }
+}
+
+void WiFiServiceImpl::StartDisconnect(const std::string& network_guid,
+                                      std::string* error) {
+  base::mac::ScopedNSAutoreleasePool auto_pool;
+  DVLOG(1) << "*** StartDisconnect: " << network_guid;
+
+  if (network_guid == GUIDFromSSID([interface_ ssid])) {
+    [interface_ disassociate];
+    //[interface_ setPower:NO error:nil];
+    //[interface_ setPower:YES error:nil];

[stevenjb, 2013/12/27 19:53:44]

Remove (or comment better).

[mef, 2013/12/27 21:08:12]

Done.

+    NotifyNetworkChanged(network_guid);
+  } else {
+    *error = "not-connected";
+  }
+}
+
+void WiFiServiceImpl::SetEventObservers(
+    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    const NetworkGuidListCallback& networks_changed_observer,
+    const NetworkGuidListCallback& network_list_changed_observer) {
+  base::mac::ScopedNSAutoreleasePool auto_pool;
+  message_loop_proxy_.swap(message_loop_proxy);
+  networks_changed_observer_ = networks_changed_observer;
+  network_list_changed_observer_ = network_list_changed_observer;
+}
+
+void WiFiServiceImpl::WaitForNetworkConnect(const std::string& network_guid,
+                                            int attempt) {
+  // If network didn't get connected in |kMaxAttempts|, then restore automatic
+  // network change notifications and stop waiting.
+  if (attempt > kMaxAttempts) {
+    DLOG(ERROR) << kMaxAttempts << " attempts exceeded waiting for connect to "
+                << network_guid;
+    // Restore previously suppressed notifications.
+    enable_notify_network_changed_ = true;
+    return;
+  }
+
+  // Check whether WiFi network is reachable.
+  struct sockaddr_in localWiFiAddress;
+  bzero(&localWiFiAddress, sizeof(localWiFiAddress));
+  localWiFiAddress.sin_len = sizeof(localWiFiAddress);
+  localWiFiAddress.sin_family = AF_INET;
+  localWiFiAddress.sin_addr.s_addr = htonl(IN_LINKLOCALNETNUM);
+
+  SCNetworkReachabilityRef reachability =
+      SCNetworkReachabilityCreateWithAddress(
+          kCFAllocatorDefault,
+          (const struct sockaddr*)&localWiFiAddress);
+  SCNetworkReachabilityFlags flags = 0u;
+  if (SCNetworkReachabilityGetFlags(reachability, &flags) &&
+      (flags & kSCNetworkReachabilityFlagsReachable) &&
+      (flags & kSCNetworkReachabilityFlagsIsDirect)) {
+    DVLOG(1) << "WiFi Connected, Reachable: " << network_guid;
+    // Restore previously suppressed notifications.
+    enable_notify_network_changed_ = true;
+    NotifyNetworkChanged(network_guid);
+  } else {
+    DVLOG(1) << "Attempt:"  << attempt << ", reachability:" << flags;
+    // Continue waiting for network connection state change.
+    task_runner_->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&WiFiServiceImpl::WaitForNetworkConnect,
+                   base::Unretained(this),
+                   network_guid,
+                   ++attempt),
+        base::TimeDelta::FromMilliseconds(kAttemptDelayMs));
+  }
+
+  if (reachability)
+    CFRelease(reachability);
+}
+
+
+NSError* WiFiServiceImpl::GetVisibleNetworkList(const std::string& network_guid,
+                                                NetworkList* network_list) {
+
+  NSError* nsError = nil;
+  NSString* networkName = nil;
+
+  DVLOG(1) << "<<< GetVisibleNetworkList: " << network_guid;
+
+  if (!network_guid.empty())
+    networkName = SSIDFromGUID(network_guid);
+
+  NSSet* networks = [interface_ scanForNetworksWithName:networkName
+                                                  error:&nsError];
+  if (nsError != nil)
+    return nsError;
+
+  std::map<std::string, NetworkProperties&> network_guids;

[stevenjb, 2013/12/27 19:53:44]

Avoid using a & in a map, it's hard to read; use a * instead. Also, name this
something like network_property_map.

[mef, 2013/12/27 21:08:12]

Done.

+
+  CWNetwork* network;
+  for(network in networks) {
+    NetworkProperties network_properties;
+    NetworkPropertiesFromCWNetwork(network, &network_properties);
+
+    if (network_guids.find(network_properties.guid) == network_guids.end()) {
+      network_list->push_back(network_properties);
+      network_guids.insert(
+          std::pair<std::string, NetworkProperties&>(
+              network_properties.guid, network_list->back()));

[stevenjb, 2013/12/27 19:53:44]

network_guids[network_properties.guid] = &network_list->back();

[mef, 2013/12/27 21:08:12]

Done.

+    } else {
+      NetworkProperties& existing = network_guids.at(network_properties.guid);
+      existing.frequency_set.insert(*network_properties.frequency_set.begin());
+    }
+  }
+  DVLOG(1) << ">>> GetVisibleNetworkList: " << network_guid;
+
+  return nil;
+}
+
+bool WiFiServiceImpl::CheckError(NSError* nsError,
+                                 const char* error_name,
+                                 std::string* error) const {
+  if (nsError != nil) {
+    DLOG(ERROR) << "*** Error:" << error_name << ":" << [nsError code];
+    *error = error_name;
+    return true;
+  }
+  return false;
+}
+
+void WiFiServiceImpl::NetworkPropertiesFromCWNetwork(
+    const CWNetwork* network,
+    NetworkProperties* properties) const {
+
+  if (NSOrderedSame == [[network ssid] compare:[interface_ ssid]])
+    properties->connection_state = onc::connection_state::kConnected;
+  else
+    properties->connection_state = onc::connection_state::kNotConnected;
+
+  properties->ssid = [[network ssid] UTF8String];
+  properties->name = properties->ssid;
+  properties->guid = GUIDFromSSID([network ssid]);
+  properties->type = onc::network_type::kWiFi;
+
+  properties->bssid = [[network bssid] UTF8String];
+  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 WiFiServiceImpl::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:
+    default:

[stevenjb, 2013/12/27 19:53:44]

nit: Omit the default so that the compiler will catch any missing modes.

[mef, 2013/12/27 21:08:12]

Done.

+      return onc::wifi::kWPA_EAP;
+  }
+  return onc::wifi::kWPA_EAP;
+}
+
+void WiFiServiceImpl::SortNetworks(NetworkList* networks) {
+  networks->sort(NetworkProperties::OrderByType);
+}
+
+
+void WiFiServiceImpl::OnListenerNotification() {
+  std::string connected_network_guid = GUIDFromSSID([interface_ ssid]);
+  DVLOG(1) << " *** Got Notification: " << connected_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 {
+    NotifyNetworkChanged(connected_network_guid);
+  }
+}
+
+void WiFiServiceImpl::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 WiFiServiceImpl::NotifyNetworkChanged(const std::string& network_guid) {
+  if (!enable_notify_network_changed_ || 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));
+}
+
+WiFiService* WiFiService::Create() { return new WiFiServiceImpl(); }
+
+}  // namespace wifi