[CrOS Tether] Transform NetworkConnectionHandler to an interface.

chromeos/network/network_connection_handler.cc

Index: chromeos/network/network_connection_handler.cc
diff --git a/chromeos/network/network_connection_handler.cc b/chromeos/network/network_connection_handler.cc
index 69483bfb0cdf3d07bd25abf79e9cba5648f144e4..8d8ab4c243bf28af31bd2f7d36f44dcfefb7b385 100644
--- a/chromeos/network/network_connection_handler.cc
+++ b/chromeos/network/network_connection_handler.cc
@@ -10,6 +10,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_service_client.h"
@@ -93,6 +94,7 @@ std::string GetDefaultUserProfilePath(const NetworkState* network) {
 
 }  // namespace
 
+// Static constants.
 const char NetworkConnectionHandler::kErrorNotFound[] = "not-found";
 const char NetworkConnectionHandler::kErrorConnected[] = "connected";
 const char NetworkConnectionHandler::kErrorConnecting[] = "connecting";
@@ -124,38 +126,225 @@ const char
     NetworkConnectionHandler::kErrorTetherConnectionAttemptWithNoDelegate[] =
         "tether-with-no-delegate";
 
-struct NetworkConnectionHandler::ConnectRequest {
-  ConnectRequest(const std::string& service_path,
-                 const std::string& profile_path,
-                 const base::Closure& success,
-                 const network_handler::ErrorCallback& error)
-      : service_path(service_path),
-        profile_path(profile_path),
-        connect_state(CONNECT_REQUESTED),
-        success_callback(success),
-        error_callback(error) {
-  }
-  enum ConnectState {
-    CONNECT_REQUESTED = 0,
-    CONNECT_STARTED = 1,
-    CONNECT_CONNECTING = 2
+// Implementation.

[stevenjb, 2017/05/03 22:05:38]

Move this to a separate file.

[Kyle Horimoto, 2017/05/03 22:38:29]

Done.

+class CHROMEOS_EXPORT NetworkConnectionHandlerImpl
+    : public NetworkConnectionHandler,
+      public base::SupportsWeakPtr<NetworkConnectionHandlerImpl> {
+ public:
+  NetworkConnectionHandlerImpl();
+  ~NetworkConnectionHandlerImpl() override;
+
+  // NetworkConnectionHandler:
+  void ConnectToNetwork(const std::string& service_path,
+                        const base::Closure& success_callback,
+                        const network_handler::ErrorCallback& error_callback,
+                        bool check_error_state) override;
+  void DisconnectNetwork(
+      const std::string& service_path,
+      const base::Closure& success_callback,
+      const network_handler::ErrorCallback& error_callback) override;
+  bool HasConnectingNetwork(const std::string& service_path) override;
+  bool HasPendingConnectRequest() override;
+
+  // NetworkStateHandlerObserver
+  void NetworkListChanged() override;
+  void NetworkPropertiesUpdated(const NetworkState* network) override;
+
+  // LoginState::Observer
+  void LoggedInStateChanged() override;
+
+  // CertLoader::Observer
+  void OnCertificatesLoaded(const net::CertificateList& cert_list,
+                            bool initial_load) override;
+
+ protected:
+  void Init(NetworkStateHandler* network_state_handler,
+            NetworkConfigurationHandler* network_configuration_handler,
+            ManagedNetworkConfigurationHandler*
+                managed_network_configuration_handler) override;
+
+ private:
+  //////////////////////////////////////////////////////////////////////////////
+  friend class NetworkHandler;
+  friend class NetworkConnectionHandlerTest;
+
+  struct ConnectRequest {
+    ConnectRequest(const std::string& service_path,
+                   const std::string& profile_path,
+                   const base::Closure& success,
+                   const network_handler::ErrorCallback& error)
+        : service_path(service_path),
+          profile_path(profile_path),
+          connect_state(CONNECT_REQUESTED),
+          success_callback(success),
+          error_callback(error) {}
+    enum ConnectState {
+      CONNECT_REQUESTED = 0,
+      CONNECT_STARTED = 1,
+      CONNECT_CONNECTING = 2
+    };
+    std::string service_path;
+    std::string profile_path;
+    ConnectState connect_state;
+    base::Closure success_callback;
+    network_handler::ErrorCallback error_callback;
   };
-  std::string service_path;
-  std::string profile_path;
-  ConnectState connect_state;
-  base::Closure success_callback;
-  network_handler::ErrorCallback error_callback;
+
+  ConnectRequest* GetPendingRequest(const std::string& service_path);
+
+  // Callback from Shill.Service.GetProperties. Parses |properties| to verify
+  // whether or not the network appears to be configured. If configured,
+  // attempts a connection, otherwise invokes error_callback from
+  // pending_requests_[service_path]. |check_error_state| is passed from
+  // ConnectToNetwork(), see comment for info.
+  void VerifyConfiguredAndConnect(bool check_error_state,
+                                  const std::string& service_path,
+                                  const base::DictionaryValue& properties);
+
+  bool IsNetworkProhibitedByPolicy(const std::string& type,
+                                   const std::string& guid,
+                                   const std::string& profile_path);
+
+  // Queues a connect request until certificates have loaded.
+  void QueueConnectRequest(const std::string& service_path);
+
+  // Checks to see if certificates have loaded and if not, cancels any queued
+  // connect request and notifies the user.
+  void CheckCertificatesLoaded();
+
+  // Handles connecting to a queued network after certificates are loaded or
+  // handle cert load timeout.
+  void ConnectToQueuedNetwork();
+
+  // Calls Shill.Manager.Connect asynchronously.
+  void CallShillConnect(const std::string& service_path);
+
+  // Handles failure from ConfigurationHandler calls.
+  void HandleConfigurationFailure(
+      const std::string& service_path,
+      const std::string& error_name,
+      std::unique_ptr<base::DictionaryValue> error_data);
+
+  // Handles success or failure from Shill.Service.Connect.
+  void HandleShillConnectSuccess(const std::string& service_path);
+  void HandleShillConnectFailure(const std::string& service_path,
+                                 const std::string& error_name,
+                                 const std::string& error_message);
+
+  // Note: |service_path| is passed by value here, because in some cases
+  // the value may be located in the map and then it can be deleted, producing
+  // a reference to invalid memory.
+  void CheckPendingRequest(const std::string service_path);
+
+  void CheckAllPendingRequests();
+
+  // Look up the ConnectRequest for |service_path| and call
+  // InvokeConnectErrorCallback.
+  void ErrorCallbackForPendingRequest(const std::string& service_path,
+                                      const std::string& error_name);
+
+  // Calls Shill.Manager.Disconnect asynchronously.
+  void CallShillDisconnect(
+      const std::string& service_path,
+      const base::Closure& success_callback,
+      const network_handler::ErrorCallback& error_callback);
+
+  // Handle success from Shill.Service.Disconnect.
+  void HandleShillDisconnectSuccess(const std::string& service_path,
+                                    const base::Closure& success_callback);
+
+  // Local references to the associated handler instances.
+  CertLoader* cert_loader_;
+  NetworkStateHandler* network_state_handler_;
+  NetworkConfigurationHandler* configuration_handler_;
+  ManagedNetworkConfigurationHandler* managed_configuration_handler_;
+
+  // Map of pending connect requests, used to prevent repeated attempts while
+  // waiting for Shill and to trigger callbacks on eventual success or failure.
+  std::map<std::string, ConnectRequest> pending_requests_;
+  std::unique_ptr<ConnectRequest> queued_connect_;
+
+  // Track certificate loading state.
+  bool logged_in_;
+  bool certificates_loaded_;
+  base::TimeTicks logged_in_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkConnectionHandlerImpl);
 };
 
+// NetworkConnectionHandler implementation.
+
+// static
+std::unique_ptr<NetworkConnectionHandler> NetworkConnectionHandler::Create() {
+  return base::MakeUnique<NetworkConnectionHandlerImpl>();
+}
+
 NetworkConnectionHandler::NetworkConnectionHandler()
+    : tether_delegate_(nullptr), weak_ptr_factory_(this) {}
+
+NetworkConnectionHandler::~NetworkConnectionHandler() {}
+
+void NetworkConnectionHandler::AddObserver(
+    NetworkConnectionObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void NetworkConnectionHandler::RemoveObserver(
+    NetworkConnectionObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void NetworkConnectionHandler::SetTetherDelegate(
+    TetherDelegate* tether_delegate) {
+  tether_delegate_ = tether_delegate;
+}
+
+void NetworkConnectionHandler::InvokeConnectSuccessCallback(
+    const std::string& service_path,
+    const base::Closure& success_callback) {
+  NET_LOG_EVENT("Connect Request Succeeded", service_path);
+  if (!success_callback.is_null())
+    success_callback.Run();
+  for (auto& observer : observers_)
+    observer.ConnectSucceeded(service_path);
+}
+
+void NetworkConnectionHandler::InvokeConnectErrorCallback(
+    const std::string& service_path,
+    const network_handler::ErrorCallback& error_callback,
+    const std::string& error_name) {
+  NET_LOG_ERROR("Connect Failure: " + error_name, service_path);
+  network_handler::RunErrorCallback(error_callback, service_path, error_name,
+                                    "");
+  for (auto& observer : observers_)
+    observer.ConnectFailed(service_path, error_name);
+}
+
+void NetworkConnectionHandler::InitiateTetherNetworkConnection(
+    const std::string& tether_network_guid,
+    const base::Closure& success_callback,
+    const network_handler::ErrorCallback& error_callback) {
+  DCHECK(tether_delegate_);
+  tether_delegate_->ConnectToNetwork(
+      tether_network_guid,
+      base::Bind(&NetworkConnectionHandlerImpl::InvokeConnectSuccessCallback,
+                 weak_ptr_factory_.GetWeakPtr(), tether_network_guid,
+                 success_callback),
+      base::Bind(&NetworkConnectionHandlerImpl::InvokeConnectErrorCallback,
+                 weak_ptr_factory_.GetWeakPtr(), tether_network_guid,
+                 error_callback));
+}
+
+// NetworkConnectionHandlerImpl implementation.
+
+NetworkConnectionHandlerImpl::NetworkConnectionHandlerImpl()
     : cert_loader_(NULL),
       network_state_handler_(NULL),
       configuration_handler_(NULL),
       logged_in_(false),
-      certificates_loaded_(false),
-      tether_delegate_(nullptr) {}
+      certificates_loaded_(false) {}
 
-NetworkConnectionHandler::~NetworkConnectionHandler() {
+NetworkConnectionHandlerImpl::~NetworkConnectionHandlerImpl() {
   if (network_state_handler_)
     network_state_handler_->RemoveObserver(this, FROM_HERE);
   if (cert_loader_)
@@ -164,7 +353,7 @@ NetworkConnectionHandler::~NetworkConnectionHandler() {
     LoginState::Get()->RemoveObserver(this);
 }
 
-void NetworkConnectionHandler::Init(
+void NetworkConnectionHandlerImpl::Init(
     NetworkStateHandler* network_state_handler,
     NetworkConfigurationHandler* network_configuration_handler,
     ManagedNetworkConfigurationHandler* managed_network_configuration_handler) {
@@ -191,24 +380,14 @@ void NetworkConnectionHandler::Init(
   configuration_handler_ = network_configuration_handler;
   managed_configuration_handler_ = managed_network_configuration_handler;
 
-  // After this point, the NetworkConnectionHandler is fully initialized (all
-  // handler references set, observers registered, ...).
+  // After this point, the NetworkConnectionHandlerImpl is fully initialized
+  // (all handler references set, observers registered, ...).
 
   if (LoginState::IsInitialized())
     LoggedInStateChanged();
 }
 
-void NetworkConnectionHandler::AddObserver(
-    NetworkConnectionObserver* observer) {
-  observers_.AddObserver(observer);
-}
-
-void NetworkConnectionHandler::RemoveObserver(
-    NetworkConnectionObserver* observer) {
-  observers_.RemoveObserver(observer);
-}
-
-void NetworkConnectionHandler::LoggedInStateChanged() {
+void NetworkConnectionHandlerImpl::LoggedInStateChanged() {
   LoginState* login_state = LoginState::Get();
   if (logged_in_ || !login_state->IsUserLoggedIn())
     return;
@@ -217,7 +396,7 @@ void NetworkConnectionHandler::LoggedInStateChanged() {
   logged_in_time_ = base::TimeTicks::Now();
 }
 
-void NetworkConnectionHandler::OnCertificatesLoaded(
+void NetworkConnectionHandlerImpl::OnCertificatesLoaded(
     const net::CertificateList& cert_list,
     bool initial_load) {
   certificates_loaded_ = true;
@@ -226,20 +405,7 @@ void NetworkConnectionHandler::OnCertificatesLoaded(
     ConnectToQueuedNetwork();
 }
 
-void NetworkConnectionHandler::InitiateTetherNetworkConnection(
-    const std::string& tether_network_guid,
-    const base::Closure& success_callback,
-    const network_handler::ErrorCallback& error_callback) {
-  DCHECK(tether_delegate_);
-  tether_delegate_->ConnectToNetwork(
-      tether_network_guid,
-      base::Bind(&NetworkConnectionHandler::InvokeConnectSuccessCallback,
-                 AsWeakPtr(), tether_network_guid, success_callback),
-      base::Bind(&NetworkConnectionHandler::InvokeConnectErrorCallback,
-                 AsWeakPtr(), tether_network_guid, error_callback));
-}
-
-void NetworkConnectionHandler::ConnectToNetwork(
+void NetworkConnectionHandlerImpl::ConnectToNetwork(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback,
@@ -334,13 +500,13 @@ void NetworkConnectionHandler::ConnectToNetwork(
   // are up to date after any recent configuration.
   configuration_handler_->GetShillProperties(
       service_path,
-      base::Bind(&NetworkConnectionHandler::VerifyConfiguredAndConnect,
+      base::Bind(&NetworkConnectionHandlerImpl::VerifyConfiguredAndConnect,
                  AsWeakPtr(), check_error_state),
-      base::Bind(&NetworkConnectionHandler::HandleConfigurationFailure,
+      base::Bind(&NetworkConnectionHandlerImpl::HandleConfigurationFailure,
                  AsWeakPtr(), service_path));
 }
 
-void NetworkConnectionHandler::DisconnectNetwork(
+void NetworkConnectionHandlerImpl::DisconnectNetwork(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
@@ -366,32 +532,28 @@ void NetworkConnectionHandler::DisconnectNetwork(
   CallShillDisconnect(service_path, success_callback, error_callback);
 }
 
-bool NetworkConnectionHandler::HasConnectingNetwork(
+bool NetworkConnectionHandlerImpl::HasConnectingNetwork(
     const std::string& service_path) {
   return pending_requests_.count(service_path) != 0;
 }
 
-bool NetworkConnectionHandler::HasPendingConnectRequest() {
+bool NetworkConnectionHandlerImpl::HasPendingConnectRequest() {
   return pending_requests_.size() > 0;
 }
 
-void NetworkConnectionHandler::SetTetherDelegate(
-    TetherDelegate* tether_delegate) {
-  tether_delegate_ = tether_delegate;
-}
-
-void NetworkConnectionHandler::NetworkListChanged() {
+void NetworkConnectionHandlerImpl::NetworkListChanged() {
   CheckAllPendingRequests();
 }
 
-void NetworkConnectionHandler::NetworkPropertiesUpdated(
+void NetworkConnectionHandlerImpl::NetworkPropertiesUpdated(
     const NetworkState* network) {
   if (HasConnectingNetwork(network->path()))
     CheckPendingRequest(network->path());
 }
 
-NetworkConnectionHandler::ConnectRequest*
-NetworkConnectionHandler::GetPendingRequest(const std::string& service_path) {
+NetworkConnectionHandlerImpl::ConnectRequest*
+NetworkConnectionHandlerImpl::GetPendingRequest(
+    const std::string& service_path) {
   std::map<std::string, ConnectRequest>::iterator iter =
       pending_requests_.find(service_path);
   return iter != pending_requests_.end() ? &(iter->second) : NULL;
@@ -399,7 +561,7 @@ NetworkConnectionHandler::GetPendingRequest(const std::string& service_path) {
 
 // ConnectToNetwork implementation
 
-void NetworkConnectionHandler::VerifyConfiguredAndConnect(
+void NetworkConnectionHandlerImpl::VerifyConfiguredAndConnect(
     bool check_error_state,
     const std::string& service_path,
     const base::DictionaryValue& service_properties) {
@@ -558,9 +720,9 @@ void NetworkConnectionHandler::VerifyConfiguredAndConnect(
     configuration_handler_->SetShillProperties(
         service_path, config_properties,
         NetworkConfigurationObserver::SOURCE_USER_ACTION,
-        base::Bind(&NetworkConnectionHandler::CallShillConnect, AsWeakPtr(),
+        base::Bind(&NetworkConnectionHandlerImpl::CallShillConnect, AsWeakPtr(),
                    service_path),
-        base::Bind(&NetworkConnectionHandler::HandleConfigurationFailure,
+        base::Bind(&NetworkConnectionHandlerImpl::HandleConfigurationFailure,
                    AsWeakPtr(), service_path));
     return;
   }
@@ -575,7 +737,7 @@ void NetworkConnectionHandler::VerifyConfiguredAndConnect(
     CallShillConnect(service_path);
 }
 
-bool NetworkConnectionHandler::IsNetworkProhibitedByPolicy(
+bool NetworkConnectionHandlerImpl::IsNetworkProhibitedByPolicy(
     const std::string& type,
     const std::string& guid,
     const std::string& profile_path) {
@@ -599,7 +761,7 @@ bool NetworkConnectionHandler::IsNetworkProhibitedByPolicy(
       guid, profile_path, nullptr /* onc_source */);
 }
 
-void NetworkConnectionHandler::QueueConnectRequest(
+void NetworkConnectionHandlerImpl::QueueConnectRequest(
     const std::string& service_path) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
@@ -626,12 +788,13 @@ void NetworkConnectionHandler::QueueConnectRequest(
   // haven't, and queued_connect_ has not been cleared (e.g. by a successful
   // connect request), cancel the request and notify the user.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&NetworkConnectionHandler::CheckCertificatesLoaded,
-                            AsWeakPtr()),
+      FROM_HERE,
+      base::Bind(&NetworkConnectionHandlerImpl::CheckCertificatesLoaded,
+                 AsWeakPtr()),
       base::TimeDelta::FromSeconds(kMaxCertLoadTimeSeconds) - dtime);
 }
 
-void NetworkConnectionHandler::CheckCertificatesLoaded() {
+void NetworkConnectionHandlerImpl::CheckCertificatesLoaded() {
   if (certificates_loaded_)
     return;
   // If queued_connect_ has been cleared (e.g. another connect request occurred
@@ -646,7 +809,7 @@ void NetworkConnectionHandler::CheckCertificatesLoaded() {
   queued_connect_.reset();
 }
 
-void NetworkConnectionHandler::ConnectToQueuedNetwork() {
+void NetworkConnectionHandlerImpl::ConnectToQueuedNetwork() {
   DCHECK(queued_connect_);
 
   // Make a copy of |queued_connect_| parameters, because |queued_connect_|
@@ -661,19 +824,19 @@ void NetworkConnectionHandler::ConnectToQueuedNetwork() {
                    false /* check_error_state */);
 }
 
-void NetworkConnectionHandler::CallShillConnect(
+void NetworkConnectionHandlerImpl::CallShillConnect(
     const std::string& service_path) {
   NET_LOG_EVENT("Sending Connect Request to Shill", service_path);
   network_state_handler_->ClearLastErrorForNetwork(service_path);
   DBusThreadManager::Get()->GetShillServiceClient()->Connect(
       dbus::ObjectPath(service_path),
-      base::Bind(&NetworkConnectionHandler::HandleShillConnectSuccess,
+      base::Bind(&NetworkConnectionHandlerImpl::HandleShillConnectSuccess,
                  AsWeakPtr(), service_path),
-      base::Bind(&NetworkConnectionHandler::HandleShillConnectFailure,
+      base::Bind(&NetworkConnectionHandlerImpl::HandleShillConnectFailure,
                  AsWeakPtr(), service_path));
 }
 
-void NetworkConnectionHandler::HandleConfigurationFailure(
+void NetworkConnectionHandlerImpl::HandleConfigurationFailure(
     const std::string& service_path,
     const std::string& error_name,
     std::unique_ptr<base::DictionaryValue> error_data) {
@@ -689,7 +852,7 @@ void NetworkConnectionHandler::HandleConfigurationFailure(
                              kErrorConfigureFailed);
 }
 
-void NetworkConnectionHandler::HandleShillConnectSuccess(
+void NetworkConnectionHandlerImpl::HandleShillConnectSuccess(
     const std::string& service_path) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
@@ -706,7 +869,7 @@ void NetworkConnectionHandler::HandleShillConnectSuccess(
   CheckPendingRequest(service_path);
 }
 
-void NetworkConnectionHandler::HandleShillConnectFailure(
+void NetworkConnectionHandlerImpl::HandleShillConnectFailure(
     const std::string& service_path,
     const std::string& dbus_error_name,
     const std::string& dbus_error_message) {
@@ -731,7 +894,7 @@ void NetworkConnectionHandler::HandleShillConnectFailure(
   InvokeConnectErrorCallback(service_path, error_callback, error);
 }
 
-void NetworkConnectionHandler::CheckPendingRequest(
+void NetworkConnectionHandlerImpl::CheckPendingRequest(
     const std::string service_path) {
   ConnectRequest* request = GetPendingRequest(service_path);
   DCHECK(request);
@@ -786,7 +949,7 @@ void NetworkConnectionHandler::CheckPendingRequest(
   InvokeConnectErrorCallback(service_path, error_callback, error_name);
 }
 
-void NetworkConnectionHandler::CheckAllPendingRequests() {
+void NetworkConnectionHandlerImpl::CheckAllPendingRequests() {
   for (std::map<std::string, ConnectRequest>::iterator iter =
            pending_requests_.begin(); iter != pending_requests_.end(); ++iter) {
     CheckPendingRequest(iter->first);
@@ -795,17 +958,7 @@ void NetworkConnectionHandler::CheckAllPendingRequests() {
 
 // Connect callbacks
 
-void NetworkConnectionHandler::InvokeConnectSuccessCallback(
-    const std::string& service_path,
-    const base::Closure& success_callback) {
-  NET_LOG_EVENT("Connect Request Succeeded", service_path);
-  if (!success_callback.is_null())
-    success_callback.Run();
-  for (auto& observer : observers_)
-    observer.ConnectSucceeded(service_path);
-}
-
-void NetworkConnectionHandler::ErrorCallbackForPendingRequest(
+void NetworkConnectionHandlerImpl::ErrorCallbackForPendingRequest(
     const std::string& service_path,
     const std::string& error_name) {
   ConnectRequest* request = GetPendingRequest(service_path);
@@ -820,33 +973,22 @@ void NetworkConnectionHandler::ErrorCallbackForPendingRequest(
   InvokeConnectErrorCallback(service_path, error_callback, error_name);
 }
 
-void NetworkConnectionHandler::InvokeConnectErrorCallback(
-    const std::string& service_path,
-    const network_handler::ErrorCallback& error_callback,
-    const std::string& error_name) {
-  NET_LOG_ERROR("Connect Failure: " + error_name, service_path);
-  network_handler::RunErrorCallback(error_callback, service_path, error_name,
-                                    "");
-  for (auto& observer : observers_)
-    observer.ConnectFailed(service_path, error_name);
-}
-
 // Disconnect
 
-void NetworkConnectionHandler::CallShillDisconnect(
+void NetworkConnectionHandlerImpl::CallShillDisconnect(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
   NET_LOG_USER("Disconnect Request", service_path);
   DBusThreadManager::Get()->GetShillServiceClient()->Disconnect(
       dbus::ObjectPath(service_path),
-      base::Bind(&NetworkConnectionHandler::HandleShillDisconnectSuccess,
+      base::Bind(&NetworkConnectionHandlerImpl::HandleShillDisconnectSuccess,
                  AsWeakPtr(), service_path, success_callback),
       base::Bind(&network_handler::ShillErrorCallbackFunction,
                  kErrorDisconnectFailed, service_path, error_callback));
 }
 
-void NetworkConnectionHandler::HandleShillDisconnectSuccess(
+void NetworkConnectionHandlerImpl::HandleShillDisconnectSuccess(
     const std::string& service_path,
     const base::Closure& success_callback) {
   NET_LOG_EVENT("Disconnect Request Sent", service_path);