chromeos: Fix UpdateScreenTest and NetworkScreenTest for Debug build.

chrome/browser/chromeos/login/signed_settings_unittest.cc

 // Copyright (c) 2011 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/login/signed_settings.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/mock_library_loader.h"
 #include "chrome/browser/chromeos/cros_settings_names.h"
-#include "chrome/browser/chromeos/dbus/dbus_thread_manager.h"
+#include "chrome/browser/chromeos/dbus/mock_dbus_thread_manager.h"
 #include "chrome/browser/chromeos/dbus/mock_session_manager_client.h"
 #include "chrome/browser/chromeos/login/mock_owner_key_utils.h"
 #include "chrome/browser/chromeos/login/mock_ownership_service.h"
 #include "chrome/browser/chromeos/login/owner_manager_unittest.h"
 #include "chrome/browser/policy/proto/chrome_device_policy.pb.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "content/test/test_browser_thread.h"
 #include "crypto/rsa_private_key.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 77 matching lines @@
  public:
   SignedSettingsTest()
       : fake_email_("fakey@example.com"),
         fake_domain_("*@example.com"),
         fake_prop_(kAccountsPrefAllowGuest),
         fake_value_("false"),
         message_loop_(MessageLoop::TYPE_UI),
         ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE),
         mock_(new MockKeyUtils),
-        injector_(mock_) /* injector_ takes ownership of mock_ */ {
+        injector_(mock_) /* injector_ takes ownership of mock_ */,
+        mock_dbus_thread_manager_(new MockDBusThreadManager) {
   }
 
   virtual ~SignedSettingsTest() {}
 
   virtual void SetUp() {
     file_thread_.Start();
-    DBusThreadManager::Initialize();
+    DBusThreadManager::InitializeForTesting(mock_dbus_thread_manager_);
   }
 
   virtual void TearDown() {
     OwnerKeyUtils::set_factory(NULL);
     DBusThreadManager::Shutdown();
   }
 
   void mock_service(SignedSettings* s, MockOwnershipService* m) {
     s->set_service(m);
   }
@@ skipping 146 matching lines @@
 
   MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   std::vector<uint8> fake_public_key_;
   scoped_ptr<crypto::RSAPrivateKey> fake_private_key_;
 
   MockKeyUtils* mock_;
   MockInjector injector_;
+  MockDBusThreadManager* mock_dbus_thread_manager_;
 
   ScopedStubCrosEnabler stub_cros_enabler_;
 };
 
+ACTION_P(Retrieve, policy_blob) { arg0.Run(policy_blob); }
+ACTION_P(Store, success) { arg1.Run(success); }
+ACTION_P(FinishKeyOp, s) { arg2->OnKeyOpComplete(OwnerManager::SUCCESS, s); }
+
 TEST_F(SignedSettingsTest, CheckWhitelist) {
   NormalDelegate<bool> d(true);
   d.expect_success();
   scoped_refptr<SignedSettings> s(
       SignedSettings::CreateCheckWhitelistOp(fake_email_, &d));
 
   mock_service(s.get(), &m_);
   EXPECT_CALL(m_, has_cached_policy())
       .WillOnce(Return(true));
 
@@ skipping 50 matching lines @@
 
 TEST_F(SignedSettingsTest, Whitelist) {
   NormalDelegate<bool> d(true);
   d.expect_success();
   scoped_refptr<SignedSettings> s(
       SignedSettings::CreateWhitelistOp(fake_email_, true, &d));
   em::PolicyData in_pol = BuildPolicyData(std::vector<std::string>());
   em::PolicyData out_pol;
   ExpectWhitelistOp(s.get(), &in_pol, &out_pol);
 
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
+  EXPECT_CALL(*client, StorePolicy(_, _))
+      .WillOnce(Store(true))
+      .RetiresOnSaturation();
+
   s->Execute();
   s->OnKeyOpComplete(OwnerManager::SUCCESS, std::vector<uint8>());
   message_loop_.RunAllPending();
 
   ASSERT_TRUE(CheckWhitelist(fake_email_, out_pol));
 }
 
 TEST_F(SignedSettingsTest, AddToExistingWhitelist) {
   NormalDelegate<bool> d(true);
   d.expect_success();
   scoped_refptr<SignedSettings> s(
       SignedSettings::CreateWhitelistOp(fake_email_, true, &d));
   em::PolicyData in_pol =
       BuildPolicyData(std::vector<std::string>(1, fake_domain_));
   em::PolicyData out_pol;
   ExpectWhitelistOp(s.get(), &in_pol, &out_pol);
 
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
+  EXPECT_CALL(*client, StorePolicy(_, _))
+      .WillOnce(Store(true))
+      .RetiresOnSaturation();
+
   s->Execute();
   s->OnKeyOpComplete(OwnerManager::SUCCESS, std::vector<uint8>());
   message_loop_.RunAllPending();
 
   ASSERT_TRUE(CheckWhitelist(fake_email_, out_pol));
 }
 
 TEST_F(SignedSettingsTest, Unwhitelist) {
   NormalDelegate<bool> d(true);
   d.expect_success();
   scoped_refptr<SignedSettings> s(
       SignedSettings::CreateWhitelistOp(fake_email_, false, &d));
   em::PolicyData in_pol =
       BuildPolicyData(std::vector<std::string>(1, fake_email_));
   em::PolicyData out_pol;
   ExpectWhitelistOp(s.get(), &in_pol, &out_pol);
 
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
+  EXPECT_CALL(*client, StorePolicy(_, _))
+      .WillOnce(Store(true))
+      .RetiresOnSaturation();
+
   s->Execute();
   s->OnKeyOpComplete(OwnerManager::SUCCESS, std::vector<uint8>());
   message_loop_.RunAllPending();
 
   ASSERT_FALSE(CheckWhitelist(fake_email_, out_pol));
 }
 
 TEST_F(SignedSettingsTest, RemoveFromExistingWhitelist) {
   NormalDelegate<bool> d(true);
   d.expect_success();
   scoped_refptr<SignedSettings> s(
       SignedSettings::CreateWhitelistOp(fake_email_, false, &d));
   std::vector<std::string> whitelist(1, fake_domain_);
   whitelist.push_back(fake_email_);
   whitelist.push_back(fake_email_ + "m");
   em::PolicyData in_pol = BuildPolicyData(whitelist);
   em::PolicyData out_pol;
   ExpectWhitelistOp(s.get(), &in_pol, &out_pol);
 
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
+  EXPECT_CALL(*client, StorePolicy(_, _))
+      .WillOnce(Store(true))
+      .RetiresOnSaturation();
+
   s->Execute();
   s->OnKeyOpComplete(OwnerManager::SUCCESS, std::vector<uint8>());
   message_loop_.RunAllPending();
 
   ASSERT_FALSE(CheckWhitelist(fake_email_, out_pol));
 }
 
 TEST_F(SignedSettingsTest, StoreProperty) {
   NormalDelegate<bool> d(true);
   d.expect_success();
   scoped_refptr<SignedSettings> s(
       SignedSettings::CreateStorePropertyOp(fake_prop_, fake_value_, &d));
 
   mock_service(s.get(), &m_);
   EXPECT_CALL(m_, StartSigningAttempt(_, _))
       .Times(1);
   EXPECT_CALL(m_, GetStatus(_))
       .WillOnce(Return(OwnershipService::OWNERSHIP_TAKEN));
   EXPECT_CALL(m_, has_cached_policy())
       .WillOnce(Return(true));
   em::PolicyData in_pol =
       BuildPolicyData(std::vector<std::string>(1, fake_email_));
   EXPECT_CALL(m_, cached_policy())
       .WillOnce(ReturnRef(in_pol));
   em::PolicyData out_pol;
   EXPECT_CALL(m_, set_cached_policy(A<const em::PolicyData&>()))
       .WillOnce(SaveArg<0>(&out_pol));
 
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
+  EXPECT_CALL(*client, StorePolicy(_, _))
+      .WillOnce(Store(true))
+      .RetiresOnSaturation();
+
   s->Execute();
   s->OnKeyOpComplete(OwnerManager::SUCCESS, std::vector<uint8>());
   message_loop_.RunAllPending();
 
   ASSERT_TRUE(out_pol.has_policy_value());
   em::ChromeDeviceSettingsProto pol;
   pol.ParseFromString(out_pol.policy_value());
   ASSERT_TRUE(pol.has_guest_mode_enabled());
   ASSERT_TRUE(pol.guest_mode_enabled().has_guest_mode_enabled());
   ASSERT_FALSE(pol.guest_mode_enabled().guest_mode_enabled());
@@ skipping 55 matching lines @@
       .WillOnce(Return(true));
 
   em::PolicyData fake_pol = BuildPolicyData(std::vector<std::string>());
   EXPECT_CALL(m_, cached_policy())
       .WillOnce(ReturnRef(fake_pol));
 
   s->Execute();
   message_loop_.RunAllPending();
 }
 
-ACTION_P(Retrieve, policy_blob) { arg0.Run(policy_blob); }
-ACTION_P(Store, success) { arg1.Run(success); }
-ACTION_P(FinishKeyOp, s) { arg2->OnKeyOpComplete(OwnerManager::SUCCESS, s); }
-
 TEST_F(SignedSettingsTest, RetrievePolicyToRetrieveProperty) {
   NormalDelegate<std::string> d(fake_value_);
   d.expect_success();
   scoped_refptr<SignedSettings> s(
       SignedSettings::CreateRetrievePropertyOp(fake_prop_, &d));
 
   em::PolicyData fake_pol = BuildPolicyData(std::vector<std::string>());
   std::string data = fake_pol.SerializeAsString();
   std::string signed_serialized;
   em::PolicyFetchResponse signed_policy = BuildProto(data,
                                                      fake_value_,
                                                      &signed_serialized);
-  MockSessionManagerClient* client = new MockSessionManagerClient;
-  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
   EXPECT_CALL(*client, RetrievePolicy(_))
       .WillOnce(Retrieve(signed_serialized))
       .RetiresOnSaturation();
 
   mock_service(s.get(), &m_);
 
   EXPECT_CALL(m_, GetStatus(_))
       .WillOnce(Return(OwnershipService::OWNERSHIP_TAKEN))
       .WillOnce(Return(OwnershipService::OWNERSHIP_TAKEN));
   EXPECT_CALL(m_, has_cached_policy())
@@ skipping 40 matching lines @@
   message_loop_.RunAllPending();
 
   // Fake out a successful signing.
   std::string signed_serialized;
   em::PolicyFetchResponse signed_policy = BuildProto(data_serialized,
                                                      fake_value_,
                                                      &signed_serialized);
   std::vector<uint8> fake_sig(fake_value_.c_str(),
                               fake_value_.c_str() + fake_value_.length());
 
-  MockSessionManagerClient* client = new MockSessionManagerClient;;
-  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
   EXPECT_CALL(*client, StorePolicy(signed_serialized, _))
       .WillOnce(Store(true))
       .RetiresOnSaturation();
   s->OnKeyOpComplete(OwnerManager::SUCCESS, fake_sig);
   message_loop_.RunAllPending();
 }
 
 TEST_F(SignedSettingsTest, StoreSignedPolicy) {
   NormalDelegate<bool> d(true);
   d.expect_success();
 
   em::PolicyData in_pol = BuildPolicyData(std::vector<std::string>());
   std::string serialized = in_pol.SerializeAsString();
   std::string signed_serialized;
   em::PolicyFetchResponse signed_policy = BuildProto(serialized,
                                                      fake_value_,
                                                      &signed_serialized);
   scoped_refptr<SignedSettings> s(
       SignedSettings::CreateStorePolicyOp(&signed_policy, &d));
-  MockSessionManagerClient* client = new MockSessionManagerClient;;
-  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
   EXPECT_CALL(*client, StorePolicy(signed_serialized, _))
       .WillOnce(Store(true))
       .RetiresOnSaturation();
 
   mock_service(s.get(), &m_);
   em::PolicyData out_pol;
   EXPECT_CALL(m_, set_cached_policy(A<const em::PolicyData&>()))
       .WillOnce(SaveArg<0>(&out_pol));
 
   s->Execute();
@@ skipping 27 matching lines @@
   em::PolicyData in_pol = BuildPolicyData(std::vector<std::string>());
   std::string serialized = in_pol.SerializeAsString();
   std::string signed_serialized;
   em::PolicyFetchResponse signed_policy = BuildProto(serialized,
                                                      fake_value_,
                                                      &signed_serialized);
   ProtoDelegate d(signed_policy);
   d.expect_success();
   scoped_refptr<SignedSettings> s(SignedSettings::CreateRetrievePolicyOp(&d));
 
-  MockSessionManagerClient* client = new MockSessionManagerClient;;
-  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
   EXPECT_CALL(*client, RetrievePolicy(_))
       .WillOnce(Retrieve(signed_serialized))
       .RetiresOnSaturation();
 
   mock_service(s.get(), &m_);
   std::vector<uint8> fake_sig(fake_value_.c_str(),
                               fake_value_.c_str() + fake_value_.length());
   EXPECT_CALL(m_, StartVerifyAttempt(serialized, fake_sig, _))
       .Times(1);
   em::PolicyData out_pol;
   EXPECT_CALL(m_, set_cached_policy(A<const em::PolicyData&>()))
       .WillOnce(SaveArg<0>(&out_pol));
 
   s->Execute();
   message_loop_.RunAllPending();
 
   s->OnKeyOpComplete(OwnerManager::SUCCESS, std::vector<uint8>());
   message_loop_.RunAllPending();
 }
 
 TEST_F(SignedSettingsTest, RetrieveNullPolicy) {
   em::PolicyFetchResponse policy;
   ProtoDelegate d(policy);
   d.expect_failure(SignedSettings::NOT_FOUND);
   scoped_refptr<SignedSettings> s(SignedSettings::CreateRetrievePolicyOp(&d));
 
-  MockSessionManagerClient* client = new MockSessionManagerClient;;
-  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
   EXPECT_CALL(*client, RetrievePolicy(_))
       .WillOnce(Retrieve(""))
       .RetiresOnSaturation();
 
   s->Execute();
   message_loop_.RunAllPending();
 }
 
 TEST_F(SignedSettingsTest, RetrieveEmptyPolicy) {
   std::string serialized;
   em::PolicyFetchResponse policy = BuildProto("", "", &serialized);
   ProtoDelegate d(policy);
   d.expect_failure(SignedSettings::NOT_FOUND);
   scoped_refptr<SignedSettings> s(SignedSettings::CreateRetrievePolicyOp(&d));
 
-  MockSessionManagerClient* client = new MockSessionManagerClient;;
-  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
   EXPECT_CALL(*client, RetrievePolicy(_))
       .WillOnce(Retrieve(""))
       .RetiresOnSaturation();
 
   s->Execute();
   message_loop_.RunAllPending();
 }
 
 TEST_F(SignedSettingsTest, RetrieveUnsignedPolicy) {
   std::string serialized;
   em::PolicyFetchResponse policy = BuildProto(fake_prop_,
                                               std::string(),
                                               &serialized);
   ProtoDelegate d(policy);
   d.expect_failure(SignedSettings::BAD_SIGNATURE);
   scoped_refptr<SignedSettings> s(SignedSettings::CreateRetrievePolicyOp(&d));
 
-  MockSessionManagerClient* client = new MockSessionManagerClient;;
-  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
   EXPECT_CALL(*client, RetrievePolicy(_))
       .WillOnce(Retrieve(serialized))
       .RetiresOnSaturation();
 
   s->Execute();
   message_loop_.RunAllPending();
 }
 
 TEST_F(SignedSettingsTest, RetrieveMalsignedPolicy) {
   std::string signed_serialized;
   em::PolicyFetchResponse signed_policy = BuildProto(fake_prop_,
                                                      fake_value_,
                                                      &signed_serialized);
   ProtoDelegate d(signed_policy);
   d.expect_failure(SignedSettings::BAD_SIGNATURE);
   scoped_refptr<SignedSettings> s(SignedSettings::CreateRetrievePolicyOp(&d));
 
-  MockSessionManagerClient* client = new MockSessionManagerClient;;
-  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  MockSessionManagerClient* client =
+      mock_dbus_thread_manager_->mock_session_manager_client();
   EXPECT_CALL(*client, RetrievePolicy(_))
       .WillOnce(Retrieve(signed_serialized))
       .RetiresOnSaturation();
 
   mock_service(s.get(), &m_);
   std::vector<uint8> fake_sig(fake_value_.c_str(),
                               fake_value_.c_str() + fake_value_.length());
   EXPECT_CALL(m_, StartVerifyAttempt(fake_prop_, fake_sig, _))
       .Times(1);
 
   s->Execute();
   message_loop_.RunAllPending();
 
   s->OnKeyOpComplete(OwnerManager::OPERATION_FAILED, std::vector<uint8>());
   message_loop_.RunAllPending();
 }
 
 }  // namespace chromeos