[CrOS Tether] Transform NetworkConnectionHandler to an interface.

chromeos/network/network_connection_handler_impl.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 "chromeos/network/network_connection_handler_impl.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 10 matching lines @@
 
 bool IsAuthenticationError(const std::string& error) {
   return (error == shill::kErrorBadWEPKey ||
           error == shill::kErrorPppAuthFailed ||
           error == shill::kErrorEapLocalTlsFailed ||
           error == shill::kErrorEapRemoteTlsFailed ||
           error == shill::kErrorEapAuthenticationFailed);
 }
 
 bool VPNRequiresCredentials(const std::string& service_path,
-                           const std::string& provider_type,
-                           const base::DictionaryValue& provider_properties) {
+                            const std::string& provider_type,
+                            const base::DictionaryValue& provider_properties) {
   if (provider_type == shill::kProviderOpenVpn) {
     std::string username;
     provider_properties.GetStringWithoutPathExpansion(
         shill::kOpenVPNUserProperty, &username);
     if (username.empty()) {
       NET_LOG_EVENT("OpenVPN: No username", service_path);
       return true;
     }
     bool passphrase_required = false;
     provider_properties.GetBooleanWithoutPathExpansion(
@@ skipping 23 matching lines @@
 }
 
 std::string GetDefaultUserProfilePath(const NetworkState* network) {
   if (!NetworkHandler::IsInitialized() ||
       (LoginState::IsInitialized() &&
        !LoginState::Get()->UserHasNetworkProfile()) ||
       (network && network->type() == shill::kTypeWifi &&
        network->security_class() == shill::kSecurityNone)) {
     return NetworkProfileHandler::GetSharedProfilePath();
   }
-  const NetworkProfile* profile  =
+  const NetworkProfile* profile =
       NetworkHandler::Get()->network_profile_handler()->GetDefaultUserProfile();
   return profile ? profile->path
                  : NetworkProfileHandler::GetSharedProfilePath();
 }
 
 }  // namespace
 
-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[] =
-    "configuration-required";
-const char NetworkConnectionHandler::kErrorAuthenticationRequired[] =
-    "authentication-required";
-const char NetworkConnectionHandler::kErrorConnectFailed[] = "connect-failed";
-const char NetworkConnectionHandler::kErrorDisconnectFailed[] =
-    "disconnect-failed";
-const char NetworkConnectionHandler::kErrorConfigureFailed[] =
-    "configure-failed";
-const char NetworkConnectionHandler::kErrorConnectCanceled[] =
-    "connect-canceled";
-const char NetworkConnectionHandler::kErrorCertLoadTimeout[] =
-    "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";
+NetworkConnectionHandlerImpl::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) {}
 
-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
-  };
-  std::string service_path;
-  std::string profile_path;
-  ConnectState connect_state;
-  base::Closure success_callback;
-  network_handler::ErrorCallback error_callback;
-};
+NetworkConnectionHandlerImpl::ConnectRequest::~ConnectRequest() {}
 
-NetworkConnectionHandler::NetworkConnectionHandler()
+NetworkConnectionHandlerImpl::ConnectRequest::ConnectRequest(
+    const ConnectRequest& other)
+    : service_path(other.service_path),
+      profile_path(other.profile_path),
+      connect_state(other.connect_state),
+      success_callback(other.success_callback),
+      error_callback(other.error_callback) {}
+
+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_)
     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 51 matching lines @@
   }
 
   // If the network does not have a profile path, specify the correct default
   // profile here and set it once connected. Otherwise leave it empty to
   // indicate that it does not need to be set.
   std::string profile_path;
   if (!network || network->profile_path().empty())
     profile_path = GetDefaultUserProfilePath(network);
 
   // All synchronous checks passed, add |service_path| to connecting list.
-  pending_requests_.insert(std::make_pair(
-      service_path,
-      ConnectRequest(service_path, profile_path,
-                     success_callback, error_callback)));
+  pending_requests_.emplace(
+      service_path, ConnectRequest(service_path, profile_path, success_callback,
+                                   error_callback));
 
   // Connect immediately to 'connectable' networks.
   // TODO(stevenjb): Shill needs to properly set Connectable for VPN.
   if (network && network->connectable() && network->type() != shill::kTypeVPN) {
     if (IsNetworkProhibitedByPolicy(network->type(), network->guid(),
                                     network->profile_path())) {
       ErrorCallbackForPendingRequest(service_path, kErrorUnmanagedNetwork);
       return;
     }
 
     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);
   if (passphrase_required) {
     ErrorCallbackForPendingRequest(service_path, kErrorPassphraseRequired);
     return;
   }
 
   std::string type, security_class;
   service_properties.GetStringWithoutPathExpansion(shill::kTypeProperty, &type);
   service_properties.GetStringWithoutPathExpansion(
       shill::kSecurityClassProperty, &security_class);
   bool connectable = false;
-  service_properties.GetBooleanWithoutPathExpansion(
-      shill::kConnectableProperty, &connectable);
+  service_properties.GetBooleanWithoutPathExpansion(shill::kConnectableProperty,
+                                                    &connectable);
 
   // In case NetworkState was not available in ConnectToNetwork (e.g. it had
   // been recently configured), we need to check Connectable again.
   if (connectable && type != shill::kTypeVPN) {
     // TODO(stevenjb): Shill needs to properly set Connectable for VPN.
     CallShillConnect(service_path);
     return;
   }
 
   // Get VPN provider type and host (required for configuration) and ensure
   // that required VPN non-cert properties are set.
   const base::DictionaryValue* provider_properties = NULL;
   std::string vpn_provider_type, vpn_provider_host, vpn_client_cert_id;
   if (type == shill::kTypeVPN) {
     // VPN Provider values are read from the "Provider" dictionary, not the
     // "Provider.Type", etc keys (which are used only to set the values).
     if (service_properties.GetDictionaryWithoutPathExpansion(
             shill::kProviderProperty, &provider_properties)) {
-      provider_properties->GetStringWithoutPathExpansion(
-          shill::kTypeProperty, &vpn_provider_type);
-      provider_properties->GetStringWithoutPathExpansion(
-          shill::kHostProperty, &vpn_provider_host);
+      provider_properties->GetStringWithoutPathExpansion(shill::kTypeProperty,
+                                                         &vpn_provider_type);
+      provider_properties->GetStringWithoutPathExpansion(shill::kHostProperty,
+                                                         &vpn_provider_host);
       provider_properties->GetStringWithoutPathExpansion(
           shill::kL2tpIpsecClientCertIdProperty, &vpn_client_cert_id);
     }
     if (vpn_provider_type.empty() || vpn_provider_host.empty()) {
       ErrorCallbackForPendingRequest(service_path, kErrorConfigurationRequired);
       return;
     }
   }
 
   std::string guid;
@@ skipping 61 matching lines @@
     }
 
     // Check certificate properties from policy.
     if (cert_config_from_policy.client_cert_type ==
         onc::client_cert::kPattern) {
       if (!ClientCertResolver::ResolveCertificatePatternSync(
               client_cert_type, cert_config_from_policy, &config_properties)) {
         ErrorCallbackForPendingRequest(service_path, kErrorCertificateRequired);
         return;
       }
-    } else if (check_error_state &&
-               !client_cert::IsCertificateConfigured(client_cert_type,
-                                                     service_properties)) {
+    } else if (check_error_state && !client_cert::IsCertificateConfigured(
+                                        client_cert_type, service_properties)) {
       // Network may not be configured.
       ErrorCallbackForPendingRequest(service_path, kErrorConfigurationRequired);
       return;
     }
   }
 
   if (type == shill::kTypeVPN) {
     // VPN may require a username, and/or passphrase to be set. (Check after
     // ensuring that any required certificates are configured).
     DCHECK(provider_properties);
-    if (VPNRequiresCredentials(
-            service_path, vpn_provider_type, *provider_properties)) {
+    if (VPNRequiresCredentials(service_path, vpn_provider_type,
+                               *provider_properties)) {
       NET_LOG_USER("VPN Requires Credentials", service_path);
       ErrorCallbackForPendingRequest(service_path, kErrorConfigurationRequired);
       return;
     }
 
     // If it's L2TP/IPsec PSK, there is no properties to configure, so proceed
     // to connect.
     if (client_cert_type == client_cert::CONFIG_TYPE_NONE) {
       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));
+  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.
 
   if (network->IsConnectingState()) {
     request->connect_state = ConnectRequest::CONNECT_CONNECTING;
     return;
   }
   if (network->IsConnectedState()) {
     if (!request->profile_path.empty()) {
       // If a profile path was specified, set it on a successful connection.
       configuration_handler_->SetNetworkProfile(
-          service_path,
-          request->profile_path,
+          service_path, request->profile_path,
           NetworkConfigurationObserver::SOURCE_USER_ACTION,
           base::Bind(&base::DoNothing),
           chromeos::network_handler::ErrorCallback());
     }
     InvokeConnectSuccessCallback(request->service_path,
                                  request->success_callback);
     pending_requests_.erase(service_path);
     return;
   }
   if (network->connection_state() == shill::kStateIdle &&
@@ skipping 14 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) {
+           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