Add NetworkHandler to own network handlers in src/chromeos/network

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 "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
@@ skipping 89 matching lines @@
   scoped_refptr<net::X509Certificate> matching_cert =
       certificate_pattern::GetCertificateMatch(
           ui_data->certificate_pattern());
   if (!matching_cert.get())
     return false;
   return true;
 }
 
 }  // namespace
 
-static NetworkConnectionHandler* g_connection_handler_instance = NULL;
-
 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::kErrorActivationRequired[] =
     "activation-required";
 const char NetworkConnectionHandler::kErrorCertificateRequired[] =
     "certificate-required";
 const char NetworkConnectionHandler::kErrorConfigurationRequired[] =
     "configuration-required";
 const char NetworkConnectionHandler::kErrorShillError[] = "shill-error";
 
-// static
-void NetworkConnectionHandler::Initialize() {
-  CHECK(!g_connection_handler_instance);
-  g_connection_handler_instance = new NetworkConnectionHandler;
-}
-
-// static
-void NetworkConnectionHandler::Shutdown() {
-  CHECK(g_connection_handler_instance);
-  delete g_connection_handler_instance;
-  g_connection_handler_instance = NULL;
-}
-
-// static
-NetworkConnectionHandler* NetworkConnectionHandler::Get() {
-  CHECK(g_connection_handler_instance)
-      << "NetworkConnectionHandler::Get() called before Initialize()";
-  return g_connection_handler_instance;
-}
-
-NetworkConnectionHandler::NetworkConnectionHandler() {
+NetworkConnectionHandler::NetworkConnectionHandler()
+    : network_state_handler_(NULL),
+      network_configuration_handler_(NULL) {
 }
 
 NetworkConnectionHandler::~NetworkConnectionHandler() {
 }
 
+void NetworkConnectionHandler::Init(
+    NetworkStateHandler* network_state_handler,
+    NetworkConfigurationHandler* network_configuration_handler) {
+  network_state_handler_ = network_state_handler;
+  network_configuration_handler_ = network_configuration_handler;
+}
+
 void NetworkConnectionHandler::ConnectToNetwork(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
   const NetworkState* network =
-      NetworkStateHandler::Get()->GetNetworkState(service_path);
+      network_state_handler_->GetNetworkState(service_path);
   if (!network) {
     InvokeErrorCallback(service_path, error_callback, kErrorNotFound);
     return;
   }
   if (network->IsConnectedState()) {
     InvokeErrorCallback(service_path, error_callback, kErrorConnected);
     return;
   }
   if (network->IsConnectingState() ||
       pending_requests_.find(service_path) != pending_requests_.end()) {
     InvokeErrorCallback(service_path, error_callback, kErrorConnecting);
     return;
   }
   if (network->passphrase_required()) {
     InvokeErrorCallback(service_path, error_callback, kErrorPassphraseRequired);
     return;
   }
   if (NetworkRequiresActivation(network)) {
     InvokeErrorCallback(service_path, error_callback, kErrorActivationRequired);
     return;
   }
 
   // All synchronous checks passed, add |service_path| to connecting list.
   pending_requests_.insert(service_path);
 
   if (!network->connectable() && NetworkMayNeedCredentials(network)) {
     // Request additional properties to check.
-    NetworkConfigurationHandler::Get()->GetProperties(
+    network_configuration_handler_->GetProperties(
         network->path(),
         base::Bind(&NetworkConnectionHandler::VerifyConfiguredAndConnect,
                    AsWeakPtr(), success_callback, error_callback),
         base::Bind(&NetworkConnectionHandler::HandleConfigurationFailure,
                    AsWeakPtr(), network->path(), error_callback));
     return;
   }
   // All checks passed, send connect request.
   CallShillConnect(service_path, success_callback, error_callback);
 }
 
 void NetworkConnectionHandler::DisconnectNetwork(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
   const NetworkState* network =
-      NetworkStateHandler::Get()->GetNetworkState(service_path);
+      network_state_handler_->GetNetworkState(service_path);
   if (!network) {
     InvokeErrorCallback(service_path, error_callback, kErrorNotFound);
     return;
   }
   if (!network->IsConnectedState()) {
     InvokeErrorCallback(service_path, error_callback, kErrorNotConnected);
     return;
   }
   CallShillDisconnect(service_path, success_callback, error_callback);
 }
 
 void NetworkConnectionHandler::CallShillConnect(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
   // TODO(stevenjb): Remove SetConnectingNetwork and use this class to maintain
   // the connecting network(s) once NetworkLibrary path is eliminated.
-  NetworkStateHandler::Get()->SetConnectingNetwork(service_path);
+  network_state_handler_->SetConnectingNetwork(service_path);
   network_event_log::AddEntry(kLogModule, "Connect Request", service_path);
   DBusThreadManager::Get()->GetShillServiceClient()->Connect(
       dbus::ObjectPath(service_path),
       base::Bind(&NetworkConnectionHandler::HandleShillSuccess,
                  AsWeakPtr(), service_path, success_callback),
       base::Bind(&NetworkConnectionHandler::HandleShillFailure,
                  AsWeakPtr(), service_path, error_callback));
 }
 
 void NetworkConnectionHandler::CallShillDisconnect(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
   network_event_log::AddEntry(kLogModule, "Disconnect Request", service_path);
   DBusThreadManager::Get()->GetShillServiceClient()->Disconnect(
       dbus::ObjectPath(service_path),
       base::Bind(&NetworkConnectionHandler::HandleShillSuccess,
                  AsWeakPtr(), service_path, success_callback),
       base::Bind(&NetworkConnectionHandler::HandleShillFailure,
                  AsWeakPtr(), service_path, error_callback));
 }
 
 void NetworkConnectionHandler::VerifyConfiguredAndConnect(
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback,
     const std::string& service_path,
     const base::DictionaryValue& properties) {
   const NetworkState* network =
-      NetworkStateHandler::Get()->GetNetworkState(service_path);
+      network_state_handler_->GetNetworkState(service_path);
   if (!network) {
     InvokeErrorCallback(service_path, error_callback, kErrorNotFound);
     return;
   }
 
   // VPN requires a host and username to be set.
   if (network->type() == flimflam::kTypeVPN &&
       !VPNIsConfigured(properties)) {
     InvokeErrorCallback(service_path, error_callback,
                         kErrorConfigurationRequired);
@@ skipping 40 matching lines @@
     const network_handler::ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   pending_requests_.erase(service_path);
   std::string error = "Connect Failure: " + error_name + ": " + error_message;
   network_handler::ShillErrorCallbackFunction(
       kLogModule, service_path, error_callback, error_name, error_message);
 }
 
 }  // namespace chromeos