[CrOS Tether] Transform NetworkConnectionHandler to an interface.

chromeos/network/network_connection_handler.cc

 // Copyright (c) 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 "chromeos/network/network_connection_handler.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #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"
 #include "chromeos/network/certificate_pattern.h"
 #include "chromeos/network/client_cert_resolver.h"
 #include "chromeos/network/client_cert_util.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_profile_handler.h"
@@ skipping 63 matching lines @@
     return NetworkProfileHandler::GetSharedProfilePath();
   }
   const NetworkProfile* profile  =
       NetworkHandler::Get()->network_profile_handler()->GetDefaultUserProfile();
   return profile ? profile->path
                  : NetworkProfileHandler::GetSharedProfilePath();
 }
 
 }  // namespace
 
+// Static constants.
 const char NetworkConnectionHandler::kErrorNotFound[] = "not-found";
 const char NetworkConnectionHandler::kErrorConnected[] = "connected";
 const char NetworkConnectionHandler::kErrorConnecting[] = "connecting";
 const char NetworkConnectionHandler::kErrorNotConnected[] = "not-connected";
 const char NetworkConnectionHandler::kErrorPassphraseRequired[] =
     "passphrase-required";
 const char NetworkConnectionHandler::kErrorBadPassphrase[] = "bad-passphrase";
 const char NetworkConnectionHandler::kErrorCertificateRequired[] =
     "certificate-required";
 const char NetworkConnectionHandler::kErrorConfigurationRequired[] =
@@ skipping 11 matching lines @@
     "cert-load-timeout";
 const char NetworkConnectionHandler::kErrorUnmanagedNetwork[] =
     "unmanaged-network";
 const char NetworkConnectionHandler::kErrorActivateFailed[] = "activate-failed";
 const char NetworkConnectionHandler::kErrorEnabledOrDisabledWhenNotAvailable[] =
     "not-available";
 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) {}
-
-NetworkConnectionHandler::~NetworkConnectionHandler() {
+      certificates_loaded_(false) {}
+
+NetworkConnectionHandlerImpl::~NetworkConnectionHandlerImpl() {
   if (network_state_handler_)
     network_state_handler_->RemoveObserver(this, FROM_HERE);
   if (cert_loader_)
     cert_loader_->RemoveObserver(this);
   if (LoginState::IsInitialized())
     LoginState::Get()->RemoveObserver(this);
 }
 
-void NetworkConnectionHandler::Init(
+void NetworkConnectionHandlerImpl::Init(
     NetworkStateHandler* network_state_handler,
     NetworkConfigurationHandler* network_configuration_handler,
     ManagedNetworkConfigurationHandler* managed_network_configuration_handler) {
   if (LoginState::IsInitialized())
     LoginState::Get()->AddObserver(this);
 
   if (CertLoader::IsInitialized()) {
     cert_loader_ = CertLoader::Get();
     cert_loader_->AddObserver(this);
     if (cert_loader_->certificates_loaded()) {
       NET_LOG_EVENT("Certificates Loaded", "");
       certificates_loaded_ = true;
     }
   } else {
     // TODO(tbarzic): Require a mock or stub cert_loader in tests.
     NET_LOG_EVENT("Certificate Loader not initialized", "");
     certificates_loaded_ = true;
   }
 
   if (network_state_handler) {
     network_state_handler_ = network_state_handler;
     network_state_handler_->AddObserver(this, FROM_HERE);
   }
   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;
 
   logged_in_ = true;
   logged_in_time_ = base::TimeTicks::Now();
 }
 
-void NetworkConnectionHandler::OnCertificatesLoaded(
+void NetworkConnectionHandlerImpl::OnCertificatesLoaded(
     const net::CertificateList& cert_list,
     bool initial_load) {
   certificates_loaded_ = true;
   NET_LOG_EVENT("Certificates Loaded", "");
   if (queued_connect_)
     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,
     bool check_error_state) {
   NET_LOG_USER("ConnectToNetwork", service_path);
   for (auto& observer : observers_)
     observer.ConnectToNetworkRequested(service_path);
 
   // Clear any existing queued connect request.
   queued_connect_.reset();
@@ skipping 74 matching lines @@
 
     CallShillConnect(service_path);
     return;
   }
 
   // Request additional properties to check. VerifyConfiguredAndConnect will
   // use only these properties, not cached properties, to ensure that they
   // 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) {
   NET_LOG_USER("DisconnectNetwork", service_path);
   for (auto& observer : observers_)
     observer.DisconnectRequested(service_path);
 
   const NetworkState* network =
       network_state_handler_->GetNetworkState(service_path);
   if (!network) {
     NET_LOG_ERROR("Disconnect Error: Not Found", service_path);
     network_handler::RunErrorCallback(error_callback, service_path,
                                       kErrorNotFound, "");
     return;
   }
   if (!network->IsConnectedState() && !network->IsConnectingState()) {
     NET_LOG_ERROR("Disconnect Error: Not Connected", service_path);
     network_handler::RunErrorCallback(error_callback, service_path,
                                       kErrorNotConnected, "");
     return;
   }
   pending_requests_.erase(service_path);
   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;
 }
 
 // ConnectToNetwork implementation
 
-void NetworkConnectionHandler::VerifyConfiguredAndConnect(
+void NetworkConnectionHandlerImpl::VerifyConfiguredAndConnect(
     bool check_error_state,
     const std::string& service_path,
     const base::DictionaryValue& service_properties) {
   NET_LOG_EVENT("VerifyConfiguredAndConnect", service_path);
 
   // If 'passphrase_required' is still true, then the 'Passphrase' property
   // has not been set to a minimum length value.
   bool passphrase_required = false;
   service_properties.GetBooleanWithoutPathExpansion(
       shill::kPassphraseRequiredProperty, &passphrase_required);
@@ skipping 138 matching lines @@
       CallShillConnect(service_path);
       return;
     }
   }
 
   if (!config_properties.empty()) {
     NET_LOG_EVENT("Configuring Network", service_path);
     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;
   }
 
   // Otherwise, we probably still need to configure the network since
   // 'Connectable' is false. If |check_error_state| is true, signal an
   // error, otherwise attempt to connect to possibly gain additional error
   // state from Shill (or in case 'Connectable' is improperly unset).
   if (check_error_state)
     ErrorCallbackForPendingRequest(service_path, kErrorConfigurationRequired);
   else
     CallShillConnect(service_path);
 }
 
-bool NetworkConnectionHandler::IsNetworkProhibitedByPolicy(
+bool NetworkConnectionHandlerImpl::IsNetworkProhibitedByPolicy(
     const std::string& type,
     const std::string& guid,
     const std::string& profile_path) {
   if (!logged_in_)
     return false;
   if (type != shill::kTypeWifi)
     return false;
   const base::DictionaryValue* global_network_config =
       managed_configuration_handler_->GetGlobalConfigFromPolicy(
           std::string() /* no username hash, device policy */);
   if (!global_network_config)
     return false;
   bool policy_prohibites = false;
   if (!global_network_config->GetBooleanWithoutPathExpansion(
           ::onc::global_network_config::kAllowOnlyPolicyNetworksToConnect,
           &policy_prohibites) ||
       !policy_prohibites) {
     return false;
   }
   return !managed_configuration_handler_->FindPolicyByGuidAndProfile(
       guid, profile_path, nullptr /* onc_source */);
 }
 
-void NetworkConnectionHandler::QueueConnectRequest(
+void NetworkConnectionHandlerImpl::QueueConnectRequest(
     const std::string& service_path) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
     NET_LOG_ERROR("No pending request to queue", service_path);
     return;
   }
 
   const int kMaxCertLoadTimeSeconds = 15;
   base::TimeDelta dtime = base::TimeTicks::Now() - logged_in_time_;
   if (dtime > base::TimeDelta::FromSeconds(kMaxCertLoadTimeSeconds)) {
     NET_LOG_ERROR("Certificate load timeout", service_path);
     InvokeConnectErrorCallback(service_path, request->error_callback,
                                kErrorCertLoadTimeout);
     return;
   }
 
   NET_LOG_EVENT("Connect Request Queued", service_path);
   queued_connect_.reset(new ConnectRequest(
       service_path, request->profile_path,
       request->success_callback, request->error_callback));
   pending_requests_.erase(service_path);
 
   // Post a delayed task to check to see if certificates have loaded. If they
   // 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
   // and wasn't queued), do nothing here.
   if (!queued_connect_)
     return;
   // Otherwise, notify the user.
   NET_LOG_ERROR("Certificate load timeout", queued_connect_->service_path);
   InvokeConnectErrorCallback(queued_connect_->service_path,
                              queued_connect_->error_callback,
                              kErrorCertLoadTimeout);
   queued_connect_.reset();
 }
 
-void NetworkConnectionHandler::ConnectToQueuedNetwork() {
+void NetworkConnectionHandlerImpl::ConnectToQueuedNetwork() {
   DCHECK(queued_connect_);
 
   // Make a copy of |queued_connect_| parameters, because |queued_connect_|
   // will get reset at the beginning of |ConnectToNetwork|.
   std::string service_path = queued_connect_->service_path;
   base::Closure success_callback = queued_connect_->success_callback;
   network_handler::ErrorCallback error_callback =
       queued_connect_->error_callback;
 
   NET_LOG_EVENT("Connecting to Queued Network", service_path);
   ConnectToNetwork(service_path, success_callback, error_callback,
                    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) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
     NET_LOG_ERROR("HandleConfigurationFailure called with no pending request.",
                   service_path);
     return;
   }
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
   InvokeConnectErrorCallback(service_path, error_callback,
                              kErrorConfigureFailed);
 }
 
-void NetworkConnectionHandler::HandleShillConnectSuccess(
+void NetworkConnectionHandlerImpl::HandleShillConnectSuccess(
     const std::string& service_path) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
     NET_LOG_ERROR("HandleShillConnectSuccess called with no pending request.",
                   service_path);
     return;
   }
   request->connect_state = ConnectRequest::CONNECT_STARTED;
   NET_LOG_EVENT("Connect Request Acknowledged", service_path);
   // Do not call success_callback here, wait for one of the following
   // conditions:
   // * State transitions to a non connecting state indicating success or failure
   // * Network is no longer in the visible list, indicating failure
   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) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
     NET_LOG_ERROR("HandleShillConnectFailure called with no pending request.",
                   service_path);
     return;
   }
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
   std::string error;
   if (dbus_error_name == shill::kErrorResultAlreadyConnected) {
     error = kErrorConnected;
   } else if (dbus_error_name == shill::kErrorResultInProgress) {
     error = kErrorConnecting;
   } else {
     NET_LOG_ERROR("Connect Failure, Shill error: " + dbus_error_name,
                   service_path);
     error = kErrorConnectFailed;
   }
   InvokeConnectErrorCallback(service_path, error_callback, error);
 }
 
-void NetworkConnectionHandler::CheckPendingRequest(
+void NetworkConnectionHandlerImpl::CheckPendingRequest(
     const std::string service_path) {
   ConnectRequest* request = GetPendingRequest(service_path);
   DCHECK(request);
   if (request->connect_state == ConnectRequest::CONNECT_REQUESTED)
     return;  // Request has not started, ignore update
   const NetworkState* network =
       network_state_handler_->GetNetworkState(service_path);
   if (!network)
     return;  // NetworkState may not be be updated yet.
 
@@ skipping 34 matching lines @@
       NET_LOG_ERROR("Unexpected State: " + network->connection_state(),
                     service_path);
     }
   }
 
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
   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);
   }
 }
 
 // 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);
   if (!request) {
     NET_LOG_ERROR("ErrorCallbackForPendingRequest with no pending request.",
                   service_path);
     return;
   }
   // Remove the entry before invoking the callback in case it triggers a retry.
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
   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);
   if (!success_callback.is_null())
     success_callback.Run();
 }
 
 }  // namespace chromeos