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

chrome/browser/chromeos/extensions/networking_private_api.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 "chrome/browser/chromeos/extensions/networking_private_api.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/extension_function_registry.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/networking_private.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/onc/onc_constants.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 
 namespace api = extensions::api::networking_private;
 namespace onc = chromeos::onc;
 using chromeos::DBusThreadManager;
 using chromeos::ManagedNetworkConfigurationHandler;
+using chromeos::NetworkHandler;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 using chromeos::ShillManagerClient;
 
 namespace {
 
 // Helper function that converts between the two types of verification
 // properties. They should always have the same fields, but we do this here to
 // prevent ShillManagerClient from depending directly on the extension API.
 ShillManagerClient::VerificationProperties ConvertVerificationProperties(
@@ skipping 20 matching lines @@
 
 NetworkingPrivateGetPropertiesFunction::
   ~NetworkingPrivateGetPropertiesFunction() {
 }
 
 bool NetworkingPrivateGetPropertiesFunction::RunImpl() {
   scoped_ptr<api::GetProperties::Params> params =
       api::GetProperties::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  ManagedNetworkConfigurationHandler::Get()->GetProperties(
+  NetworkHandler::Get()->managed_network_configuration_handler()->GetProperties(
       params->network_guid,  // service path
       base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess,
                  this),
       base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed,
                  this));
   return true;
 }
 
 void NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess(
     const std::string& service_path,
@@ skipping 27 matching lines @@
   // User ID hash presence is only enforced when multi-profiles are turned on.
   std::string user_id_hash;
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kMultiProfiles)) {
     user_id_hash = g_browser_process->platform_part()->
         profile_helper()->GetUserIdHashFromProfile(profile());
   } else {
     user_id_hash = g_browser_process->platform_part()->
         profile_helper()->active_user_id_hash();
   }
 
-  ManagedNetworkConfigurationHandler::Get()->GetManagedProperties(
-      user_id_hash,
-      params->network_guid,  // service path
-      base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Success,
-                 this),
-      base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Failure,
-                 this));
+  NetworkHandler::Get()->managed_network_configuration_handler()->
+      GetManagedProperties(
+          user_id_hash,
+          params->network_guid,  // service path
+          base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Success,
+                     this),
+          base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Failure,
+                     this));
   return true;
 }
 
 void NetworkingPrivateGetManagedPropertiesFunction::Success(
     const std::string& service_path,
     const base::DictionaryValue& dictionary) {
   base::DictionaryValue* network_properties = dictionary.DeepCopy();
   network_properties->SetStringWithoutPathExpansion(onc::network_config::kGUID,
                                                     service_path);
   SetResult(network_properties);
@@ skipping 14 matching lines @@
   ~NetworkingPrivateGetStateFunction() {
 }
 
 bool NetworkingPrivateGetStateFunction::RunImpl() {
   scoped_ptr<api::GetState::Params> params =
       api::GetState::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
   // The |network_guid| parameter is storing the service path.
   std::string service_path = params->network_guid;
 
-  const NetworkState* state =
-      NetworkStateHandler::Get()->GetNetworkState(service_path);
+  const NetworkState* state = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path);
   if (!state) {
     error_ = "Error.InvalidParameter";
     SendResponse(false);
   }
 
   scoped_ptr<base::DictionaryValue> result_dict(new base::DictionaryValue);
   state->GetProperties(result_dict.get());
   scoped_ptr<base::DictionaryValue> onc_network_part =
       onc::TranslateShillServiceToONCPart(*result_dict,
                                           &onc::kNetworkWithStateSignature);
@@ skipping 11 matching lines @@
 }
 
 bool NetworkingPrivateSetPropertiesFunction::RunImpl() {
   scoped_ptr<api::SetProperties::Params> params =
       api::SetProperties::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   scoped_ptr<base::DictionaryValue> properties_dict(
       params->properties.ToValue());
 
-  ManagedNetworkConfigurationHandler::Get()->SetProperties(
+  NetworkHandler::Get()->managed_network_configuration_handler()->SetProperties(
       params->network_guid,  // service path
       *properties_dict,
       base::Bind(&NetworkingPrivateSetPropertiesFunction::ResultCallback,
                  this),
       base::Bind(&NetworkingPrivateSetPropertiesFunction::ErrorCallback,
                  this));
   return true;
 }
 
 void NetworkingPrivateSetPropertiesFunction::ErrorCallback(
@@ skipping 15 matching lines @@
 }
 
 bool NetworkingPrivateGetVisibleNetworksFunction::RunImpl() {
   scoped_ptr<api::GetVisibleNetworks::Params> params =
       api::GetVisibleNetworks::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string type_filter =
       api::GetVisibleNetworks::Params::ToString(params->type);
 
   NetworkStateHandler::NetworkStateList network_states;
-  NetworkStateHandler::Get()->GetNetworkList(&network_states);
+  NetworkHandler::Get()->network_state_handler()->GetNetworkList(
+      &network_states);
 
   base::ListValue* network_properties_list = new base::ListValue;
   for (NetworkStateHandler::NetworkStateList::iterator it =
            network_states.begin();
        it != network_states.end(); ++it) {
     const std::string& service_path = (*it)->path();
     base::DictionaryValue shill_dictionary;
     (*it)->GetProperties(&shill_dictionary);
 
     scoped_ptr<base::DictionaryValue> onc_network_part =
@@ skipping 17 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateRequestNetworkScanFunction
 
 NetworkingPrivateRequestNetworkScanFunction::
 ~NetworkingPrivateRequestNetworkScanFunction() {
 }
 
 bool NetworkingPrivateRequestNetworkScanFunction::RunImpl() {
-  NetworkStateHandler::Get()->RequestScan();
+  NetworkHandler::Get()->network_state_handler()->RequestScan();
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateStartConnectFunction
 
 NetworkingPrivateStartConnectFunction::
   ~NetworkingPrivateStartConnectFunction() {
 }
 
 void  NetworkingPrivateStartConnectFunction::ConnectionStartSuccess() {
   SendResponse(true);
 }
 
 void NetworkingPrivateStartConnectFunction::ConnectionStartFailed(
     const std::string& error_name,
     const scoped_ptr<base::DictionaryValue> error_data) {
   error_ = error_name;
   SendResponse(false);
 }
 
 bool NetworkingPrivateStartConnectFunction::RunImpl() {
   scoped_ptr<api::StartConnect::Params> params =
       api::StartConnect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  ManagedNetworkConfigurationHandler::Get()->Connect(
+  NetworkHandler::Get()->managed_network_configuration_handler()->Connect(
       params->network_guid,  // service path
       base::Bind(
           &NetworkingPrivateStartConnectFunction::ConnectionStartSuccess,
           this),
       base::Bind(
           &NetworkingPrivateStartConnectFunction::ConnectionStartFailed,
           this));
   return true;
 }
 
@@ skipping 13 matching lines @@
     const scoped_ptr<base::DictionaryValue> error_data) {
   error_ = error_name;
   SendResponse(false);
 }
 
 bool NetworkingPrivateStartDisconnectFunction::RunImpl() {
   scoped_ptr<api::StartDisconnect::Params> params =
       api::StartDisconnect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  ManagedNetworkConfigurationHandler::Get()->Disconnect(
+  NetworkHandler::Get()->managed_network_configuration_handler()->Disconnect(
       params->network_guid,  // service path
       base::Bind(
           &NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess,
           this),
       base::Bind(
           &NetworkingPrivateStartDisconnectFunction::DisconnectionStartFailed,
           this));
   return true;
 }
 
@@ skipping 107 matching lines @@
     const std::string& result) {
   results_ = api::VerifyAndEncryptData::Results::Create(result);
   SendResponse(true);
 }
 
 void NetworkingPrivateVerifyAndEncryptDataFunction::ErrorCallback(
     const std::string& error_name, const std::string& error) {
   error_ = error_name;
   SendResponse(false);
 }