ChromeOS: Remove MockDBusThreadManager.

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/message_loop.h"
 #include "base/strings/string_piece.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/mock_dbus_thread_manager.h"
+#include "chromeos/dbus/fake_dbus_thread_manager.h"
 #include "chromeos/dbus/mock_shill_manager_client.h"
 #include "chromeos/dbus/mock_shill_profile_client.h"
 #include "chromeos/dbus/mock_shill_service_client.h"
 #include "chromeos/dbus/shill_stub_helper.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_state_handler_observer.h"
 #include "chromeos/network/shill_property_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using ::testing::_;
+using ::testing::AnyNumber;
 using ::testing::Invoke;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrEq;
 
 // Matcher to match base::Value.
 MATCHER_P(IsEqualTo, value, "") { return arg.Equals(value); }
 
 namespace chromeos {
@@ skipping 55 matching lines @@
 class NetworkConfigurationHandlerTest : public testing::Test {
  public:
   NetworkConfigurationHandlerTest()
       : mock_manager_client_(NULL),
         mock_profile_client_(NULL),
         mock_service_client_(NULL),
         dictionary_value_result_(NULL) {}
   virtual ~NetworkConfigurationHandlerTest() {}
 
   virtual void SetUp() OVERRIDE {
-    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_profile_client_ =
-        mock_dbus_thread_manager->mock_shill_profile_client();
-    mock_service_client_ =
-        mock_dbus_thread_manager->mock_shill_service_client();
+    FakeDBusThreadManager* dbus_thread_manager = new FakeDBusThreadManager;
+    mock_manager_client_ = new MockShillManagerClient();
+    mock_profile_client_ = new MockShillProfileClient();
+    mock_service_client_ = new MockShillServiceClient();
+    dbus_thread_manager->SetShillManagerClient(
+        scoped_ptr<ShillManagerClient>(mock_manager_client_).Pass());
+    dbus_thread_manager->SetShillProfileClient(
+        scoped_ptr<ShillProfileClient>(mock_profile_client_).Pass());
+    dbus_thread_manager->SetShillServiceClient(
+        scoped_ptr<ShillServiceClient>(mock_service_client_).Pass());
+
+    EXPECT_CALL(*mock_service_client_, GetProperties(_, _))
+        .Times(AnyNumber());
+    EXPECT_CALL(*mock_manager_client_, GetProperties(_))
+        .Times(AnyNumber());
+    EXPECT_CALL(*mock_manager_client_, AddPropertyChangedObserver(_))
+        .Times(AnyNumber());
+    EXPECT_CALL(*mock_manager_client_, RemovePropertyChangedObserver(_))
+        .Times(AnyNumber());
+
+    DBusThreadManager::InitializeForTesting(dbus_thread_manager);
 
     network_state_handler_.reset(NetworkStateHandler::InitializeForTest());
     network_configuration_handler_.reset(new NetworkConfigurationHandler());
     network_configuration_handler_->Init(network_state_handler_.get());
     message_loop_.RunUntilIdle();
   }
 
   virtual void TearDown() OVERRIDE {
     network_configuration_handler_.reset();
     network_state_handler_.reset();
@@ skipping 85 matching lines @@
   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_service_client_,
               SetProperty(dbus::ObjectPath(service_path), key,
                           IsEqualTo(networkNameValue.get()), _, _)).Times(1);
-  DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
-      dbus::ObjectPath(service_path), key, *networkNameValue,
-      base::Bind(&base::DoNothing),
-      base::Bind(&DBusErrorCallback));
+  mock_service_client_->SetProperty(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));
   network_configuration_handler_->GetProperties(
       service_path,
       base::Bind(&DictionaryValueCallback,
@@ skipping 374 matching lines @@
       create_service_path_, shill::kGuidProperty, &guid));
   EXPECT_EQ(service_path, guid);
 
   std::string actual_profile;
   EXPECT_TRUE(GetServiceStringProperty(
       create_service_path_, shill::kProfileProperty, &actual_profile));
   EXPECT_EQ(shill_stub_helper::kSharedProfilePath, actual_profile);
 }
 
 }  // namespace chromeos