This adds ManagedNetworkConfigurationHandler first pass

chromeos/network/network_configuration_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 "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/string_piece.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ skipping 70 matching lines @@
     MockDBusThreadManager* mock_dbus_thread_manager = new MockDBusThreadManager;
     EXPECT_CALL(*mock_dbus_thread_manager, GetSystemBus())
     .WillRepeatedly(Return(reinterpret_cast<dbus::Bus*>(NULL)));
     DBusThreadManager::InitializeForTesting(mock_dbus_thread_manager);
     mock_manager_client_ =
         mock_dbus_thread_manager->mock_shill_manager_client();
     mock_service_client_ =
         mock_dbus_thread_manager->mock_shill_service_client();
 
     // Initialize DBusThreadManager with a stub implementation.
-    configuration_handler_.reset(new NetworkConfigurationHandler);
+    NetworkConfigurationHandler::Initialize();
     message_loop_.RunUntilIdle();
   }
 
   virtual void TearDown() OVERRIDE {
-    configuration_handler_.reset();
+    NetworkConfigurationHandler::Shutdown();
     DBusThreadManager::Shutdown();
   }
 
   // Handles responses for GetProperties method calls.
   void OnGetProperties(
       const dbus::ObjectPath& path,
       const ShillClientHelper::DictionaryValueCallback& callback) {
     callback.Run(DBUS_METHOD_CALL_SUCCESS, *dictionary_value_result_);
   }
 
@@ skipping 45 matching lines @@
     callback.Run(dbus::ObjectPath("/service/2"));
   }
 
   void OnRemove(const dbus::ObjectPath& service_path,
                     const base::Closure& callback,
                     const ShillClientHelper::ErrorCallback& error_callback) {
     callback.Run();
   }
 
  protected:
-  scoped_ptr<NetworkConfigurationHandler> configuration_handler_;
   MockShillManagerClient* mock_manager_client_;
   MockShillServiceClient* mock_service_client_;
   MessageLoop message_loop_;
   base::DictionaryValue* dictionary_value_result_;
 };
 
 TEST_F(NetworkConfigurationHandlerTest, GetProperties) {
   std::string service_path = "/service/1";
   std::string expected_json = "{\n   \"SSID\": \"MyNetwork\"\n}\n";
   std::string networkName = "MyNetwork";
@@ skipping 11 matching lines @@
       dbus::ObjectPath(service_path), key, *networkNameValue,
       base::Bind(&base::DoNothing),
       base::Bind(&DBusErrorCallback));
   message_loop_.RunUntilIdle();
 
   ShillServiceClient::DictionaryValueCallback get_properties_callback;
   EXPECT_CALL(*mock_service_client_,
               GetProperties(_, _)).WillOnce(
                   Invoke(this,
                          &NetworkConfigurationHandlerTest::OnGetProperties));
-  configuration_handler_->GetProperties(
+  NetworkConfigurationHandler::Get()->GetProperties(
       service_path,
       base::Bind(&DictionaryValueCallback,
                  service_path,
                  expected_json),
                  base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, SetProperties) {
   std::string service_path = "/service/1";
   std::string networkName = "MyNetwork";
   std::string key = "SSID";
   scoped_ptr<base::StringValue> networkNameValue(
       base::Value::CreateStringValue(networkName));
 
   base::DictionaryValue value;
   value.Set(key, base::Value::CreateStringValue(networkName));
   dictionary_value_result_ = &value;
   EXPECT_CALL(*mock_manager_client_,
               ConfigureService(_, _, _)).WillOnce(
                   Invoke(this,
                          &NetworkConfigurationHandlerTest::OnSetProperties));
-  configuration_handler_->SetProperties(
+  NetworkConfigurationHandler::Get()->SetProperties(
       service_path,
       value,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, ClearProperties) {
   std::string service_path = "/service/1";
   std::string networkName = "MyNetwork";
   std::string key = "SSID";
   scoped_ptr<base::StringValue> networkNameValue(
       base::Value::CreateStringValue(networkName));
 
   // First set up a value to clear.
   base::DictionaryValue value;
   value.Set(key, base::Value::CreateStringValue(networkName));
   dictionary_value_result_ = &value;
   EXPECT_CALL(*mock_manager_client_,
               ConfigureService(_, _, _)).WillOnce(
                   Invoke(this,
                          &NetworkConfigurationHandlerTest::OnSetProperties));
-  configuration_handler_->SetProperties(
+  NetworkConfigurationHandler::Get()->SetProperties(
       service_path,
       value,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 
   // Now clear it.
   std::vector<std::string> values_to_clear;
   values_to_clear.push_back(key);
   EXPECT_CALL(*mock_service_client_,
               ClearProperties(_, _, _, _)).WillOnce(
                   Invoke(this,
                          &NetworkConfigurationHandlerTest::OnClearProperties));
-  configuration_handler_->ClearProperties(
+  NetworkConfigurationHandler::Get()->ClearProperties(
       service_path,
       values_to_clear,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, ClearPropertiesError) {
   std::string service_path = "/service/1";
   std::string networkName = "MyNetwork";
   std::string key = "SSID";
   scoped_ptr<base::StringValue> networkNameValue(
       base::Value::CreateStringValue(networkName));
 
   // First set up a value to clear.
   base::DictionaryValue value;
   value.Set(key, base::Value::CreateStringValue(networkName));
   dictionary_value_result_ = &value;
   EXPECT_CALL(*mock_manager_client_,
               ConfigureService(_, _, _)).WillOnce(
                   Invoke(this,
                          &NetworkConfigurationHandlerTest::OnSetProperties));
-  configuration_handler_->SetProperties(
+  NetworkConfigurationHandler::Get()->SetProperties(
       service_path,
       value,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 
   // Now clear it.
   std::vector<std::string> values_to_clear;
   values_to_clear.push_back(key);
   EXPECT_CALL(
       *mock_service_client_,
       ClearProperties(_, _, _, _)).WillOnce(
           Invoke(this,
                  &NetworkConfigurationHandlerTest::OnClearPropertiesError));
-  configuration_handler_->ClearProperties(
+  NetworkConfigurationHandler::Get()->ClearProperties(
       service_path,
       values_to_clear,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, true, service_path));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, Connect) {
   std::string service_path = "/service/1";
 
   EXPECT_CALL(*mock_service_client_,
               Connect(_, _, _)).WillOnce(
                   Invoke(this,
                          &NetworkConfigurationHandlerTest::OnConnect));
-  configuration_handler_->Connect(
+  NetworkConfigurationHandler::Get()->Connect(
       service_path,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, Disconnect) {
   std::string service_path = "/service/1";
 
   EXPECT_CALL(*mock_service_client_,
               Disconnect(_, _, _)).WillOnce(
                   Invoke(this,
                          &NetworkConfigurationHandlerTest::OnDisconnect));
-  configuration_handler_->Disconnect(
+  NetworkConfigurationHandler::Get()->Disconnect(
       service_path,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, CreateConfiguration) {
   std::string expected_json = "{\n   \"SSID\": \"MyNetwork\"\n}\n";
   std::string networkName = "MyNetwork";
   std::string key = "SSID";
   scoped_ptr<base::StringValue> networkNameValue(
       base::Value::CreateStringValue(networkName));
   base::DictionaryValue value;
   value.Set(key, base::Value::CreateStringValue(networkName));
 
   EXPECT_CALL(
       *mock_manager_client_,
       GetService(_, _, _)).WillOnce(
           Invoke(this,
                  &NetworkConfigurationHandlerTest::OnGetService));
-  configuration_handler_->CreateConfiguration(
+  NetworkConfigurationHandler::Get()->CreateConfiguration(
       value,
       base::Bind(&StringResultCallback, std::string("/service/2")),
       base::Bind(&ErrorCallback, false, std::string("")));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, RemoveConfiguration) {
   std::string service_path = "/service/1";
 
   EXPECT_CALL(
       *mock_service_client_,
       Remove(_, _, _)).WillOnce(
           Invoke(this,
                  &NetworkConfigurationHandlerTest::OnRemove));
-  configuration_handler_->RemoveConfiguration(
+  NetworkConfigurationHandler::Get()->RemoveConfiguration(
       service_path,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 }
 
 }  // namespace chromeos