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

chromeos/network/network_connection_handler_unittest.cc

 // Copyright (c) 2012 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/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ skipping 20 matching lines @@
   virtual ~NetworkConnectionHandlerTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     // Initialize DBusThreadManager with a stub implementation.
     DBusThreadManager::InitializeWithStub();
     message_loop_.RunUntilIdle();
     DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()
         ->ClearServices();
     message_loop_.RunUntilIdle();
-    NetworkStateHandler::Initialize();
-    NetworkConfigurationHandler::Initialize();
-    NetworkConnectionHandler::Initialize();
+    network_state_handler_.reset(NetworkStateHandler::InitializeForTest());
+    network_configuration_handler_.reset(
+        NetworkConfigurationHandler::InitializeForTest(
+            network_state_handler_.get()));
+    network_connection_handler_.reset(new NetworkConnectionHandler);
+    network_connection_handler_->Init(network_state_handler_.get(),
+                                      network_configuration_handler_.get());
   }
 
   virtual void TearDown() OVERRIDE {
-    NetworkConnectionHandler::Shutdown();
-    NetworkConfigurationHandler::Shutdown();
-    NetworkStateHandler::Shutdown();
+    network_connection_handler_.reset();
+    network_configuration_handler_.reset();
+    network_state_handler_.reset();
     DBusThreadManager::Shutdown();
   }
 
  protected:
   bool Configure(const std::string& json_string) {
     scoped_ptr<base::DictionaryValue> json_dict =
         onc::ReadDictionaryFromJson(json_string);
     if (!json_dict) {
       LOG(ERROR) << "Error parsing json: " << json_string;
       return false;
     }
     DBusThreadManager::Get()->GetShillManagerClient()->ConfigureService(
         *json_dict,
         ObjectPathCallback(), ShillManagerClient::ErrorCallback());
     message_loop_.RunUntilIdle();
     return true;
   }
 
   void Connect(const std::string& service_path) {
     const bool ignore_error_state = false;
-    NetworkConnectionHandler::Get()->ConnectToNetwork(
+    network_connection_handler_->ConnectToNetwork(
         service_path,
         base::Bind(&NetworkConnectionHandlerTest::SuccessCallback,
                    base::Unretained(this)),
         base::Bind(&NetworkConnectionHandlerTest::ErrorCallback,
                    base::Unretained(this)),
         ignore_error_state);
     message_loop_.RunUntilIdle();
   }
 
   void Disconnect(const std::string& service_path) {
-    NetworkConnectionHandler::Get()->DisconnectNetwork(
+    network_connection_handler_->DisconnectNetwork(
         service_path,
         base::Bind(&NetworkConnectionHandlerTest::SuccessCallback,
                    base::Unretained(this)),
         base::Bind(&NetworkConnectionHandlerTest::ErrorCallback,
                    base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void SuccessCallback() {
     result_ = kSuccessResult;
@@ skipping 14 matching lines @@
                                        const std::string& key) {
     std::string result;
     const base::DictionaryValue* properties =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()->
         GetServiceProperties(service_path);
     if (properties)
       properties->GetStringWithoutPathExpansion(key, &result);
     return result;
   }
 
+  scoped_ptr<NetworkStateHandler> network_state_handler_;
+  scoped_ptr<NetworkConfigurationHandler> network_configuration_handler_;
+  scoped_ptr<NetworkConnectionHandler> network_connection_handler_;
   MessageLoopForUI message_loop_;
   std::string result_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkConnectionHandlerTest);
 };
 
 namespace {
 
 const char* kConfigConnectable =
@@ skipping 77 matching lines @@
        NetworkConnectionHandlerDisconnectFailure) {
   Connect("no-network");
   EXPECT_EQ(NetworkConnectionHandler::kErrorNotFound, GetResultAndReset());
 
   EXPECT_TRUE(Configure(kConfigConnectable));
   Disconnect("wifi0");
   EXPECT_EQ(NetworkConnectionHandler::kErrorNotConnected, GetResultAndReset());
 }
 
 }  // namespace chromeos