chromeos: Change all clients of LoginLibrary to use SessionManagerClient.

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/mock_login_library.h"
 #include "chrome/browser/chromeos/cros_settings_names.h"
+#include "chrome/browser/chromeos/dbus/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/browser/browser_thread.h"
 #include "crypto/rsa_private_key.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::A;
 using ::testing::AnyNumber;
-using ::testing::InvokeArgument;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrEq;
 using ::testing::WithArg;
 using ::testing::_;
 using google::protobuf::RepeatedPtrField;
 
 namespace em = enterprise_management;
 namespace chromeos {
@@ skipping 71 matching lines @@
         ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE),
         mock_(new MockKeyUtils),
         injector_(mock_) /* injector_ takes ownership of mock_ */ {
   }
 
   virtual ~SignedSettingsTest() {}
 
   virtual void SetUp() {
     file_thread_.Start();
+    DBusThreadManager::Initialize();
   }
 
   virtual void TearDown() {
     OwnerKeyUtils::set_factory(NULL);
+    DBusThreadManager::Shutdown();
   }
 
   void mock_service(SignedSettings* s, MockOwnershipService* m) {
     s->set_service(m);
   }
 
   em::PolicyData BuildPolicyData(std::vector<std::string> whitelist) {
     em::PolicyData to_return;
     em::ChromeDeviceSettingsProto pol;
     em::GuestModeEnabledProto* allow = pol.mutable_guest_mode_enabled();
@@ skipping 91 matching lines @@
 
     mock_service(s.get(), &m_);
     EXPECT_CALL(m_, StartSigningAttempt(StrEq(fake_prop_), _))
         .Times(1);
 
     s->Execute();
     s->OnKeyOpComplete(return_code, std::vector<uint8>());
     message_loop_.RunAllPending();
   }
 
-  MockLoginLibrary* MockLoginLib() {
-    chromeos::CrosLibrary::TestApi* test_api =
-        chromeos::CrosLibrary::Get()->GetTestApi();
-
-    // Mocks, ownership transferred to CrosLibrary class on creation.
-    MockLoginLibrary* mock_library;
-    MockLibraryLoader* loader;
-
-    loader = new MockLibraryLoader();
-    ON_CALL(*loader, Load(_))
-        .WillByDefault(Return(true));
-    EXPECT_CALL(*loader, Load(_))
-        .Times(AnyNumber());
-
-    test_api->SetLibraryLoader(loader, true);
-
-    mock_library = new MockLoginLibrary();
-    test_api->SetLoginLibrary(mock_library, true);
-    return mock_library;
-  }
-
-  void UnMockLoginLib() {
-    // Prevent bogus gMock leak check from firing.
-    chromeos::CrosLibrary::TestApi* test_api =
-        chromeos::CrosLibrary::Get()->GetTestApi();
-    test_api->SetLibraryLoader(NULL, false);
-    test_api->SetLoginLibrary(NULL, false);
-  }
-
   em::PolicyFetchResponse BuildProto(const std::string& data,
                                      const std::string& sig,
                                      std::string* out_serialized) {
     em::PolicyFetchResponse fake_policy;
     if (!data.empty())
       fake_policy.set_policy_data(data);
     if (!sig.empty())
       fake_policy.set_policy_data_signature(sig);
     EXPECT_TRUE(fake_policy.SerializeToString(out_serialized));
     return fake_policy;
@@ skipping 260 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, s) { (*arg0)((void*)arg1, s.c_str(), s.length()); }
+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);
-  MockLoginLibrary* lib = MockLoginLib();
-  EXPECT_CALL(*lib, RequestRetrievePolicy(_, _))
+  MockSessionManagerClient* client = new MockSessionManagerClient;
+  DBusThreadManager::Get()->set_session_manager_client_for_testing(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())
       .WillOnce(Return(false))
       .WillOnce(Return(true));
   em::PolicyData out_pol;
   EXPECT_CALL(m_, set_cached_policy(A<const em::PolicyData&>()))
       .WillOnce(SaveArg<0>(&out_pol));
   EXPECT_CALL(m_, cached_policy())
       .WillOnce(ReturnRef(out_pol));
 
   std::vector<uint8> fake_sig(fake_value_.c_str(),
                               fake_value_.c_str() + fake_value_.length());
   EXPECT_CALL(m_, StartVerifyAttempt(data, fake_sig, _))
       .WillOnce(FinishKeyOp(fake_sig))
       .RetiresOnSaturation();
 
   s->Execute();
   message_loop_.RunAllPending();
-  UnMockLoginLib();
 }
 
 TEST_F(SignedSettingsTest, SignAndStorePolicy) {
   NormalDelegate<bool> d(true);
   d.expect_success();
 
   em::PolicyData in_pol = BuildPolicyData(std::vector<std::string>());
   std::string data_serialized = in_pol.SerializeAsString();
   std::string serialized;
   em::PolicyFetchResponse fake_policy = BuildProto(data_serialized,
@@ skipping 14 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());
 
-  MockLoginLibrary* lib = MockLoginLib();
-  EXPECT_CALL(*lib, RequestStorePolicy(StrEq(signed_serialized), _, s.get()))
-      .WillOnce(InvokeArgument<1>(static_cast<void*>(s.get()), true))
+  MockSessionManagerClient* client = new MockSessionManagerClient;;
+  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  EXPECT_CALL(*client, StorePolicy(signed_serialized, _))
+      .WillOnce(Store(true))
       .RetiresOnSaturation();
   s->OnKeyOpComplete(OwnerManager::SUCCESS, fake_sig);
   message_loop_.RunAllPending();
-  UnMockLoginLib();
 }
 
 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));
-  MockLoginLibrary* lib = MockLoginLib();
-  EXPECT_CALL(*lib, RequestStorePolicy(StrEq(signed_serialized), _, s.get()))
-      .WillOnce(InvokeArgument<1>(static_cast<void*>(s.get()), true))
+  MockSessionManagerClient* client = new MockSessionManagerClient;;
+  DBusThreadManager::Get()->set_session_manager_client_for_testing(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();
   message_loop_.RunAllPending();
-  UnMockLoginLib();
 }
 
 TEST_F(SignedSettingsTest, StorePolicyNoKey) {
   FailingStorePolicyOp(OwnerManager::KEY_UNAVAILABLE);
 }
 
 TEST_F(SignedSettingsTest, StorePolicyFailed) {
   FailingStorePolicyOp(OwnerManager::OPERATION_FAILED);
 }
 
@@ skipping 16 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));
 
-  MockLoginLibrary* lib = MockLoginLib();
-  EXPECT_CALL(*lib, RequestRetrievePolicy(_, s.get()))
-      .WillOnce(InvokeArgument<0>(static_cast<void*>(s.get()),
-                                  signed_serialized.c_str(),
-                                  signed_serialized.length()))
+  MockSessionManagerClient* client = new MockSessionManagerClient;;
+  DBusThreadManager::Get()->set_session_manager_client_for_testing(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();
-  UnMockLoginLib();
 
   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));
 
-  MockLoginLibrary* lib = MockLoginLib();
-  EXPECT_CALL(*lib, RequestRetrievePolicy(_, s.get()))
-      .WillOnce(InvokeArgument<0>(static_cast<void*>(s.get()),
-                                  static_cast<const char*>(NULL),
-                                  0))
+  MockSessionManagerClient* client = new MockSessionManagerClient;;
+  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  EXPECT_CALL(*client, RetrievePolicy(_))
+      .WillOnce(Retrieve(""))
       .RetiresOnSaturation();
 
   s->Execute();
   message_loop_.RunAllPending();
-  UnMockLoginLib();
 }
 
 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));
 
-  MockLoginLibrary* lib = MockLoginLib();
-  EXPECT_CALL(*lib, RequestRetrievePolicy(_, s.get()))
-      .WillOnce(InvokeArgument<0>(static_cast<void*>(s.get()), "", 0))
+  MockSessionManagerClient* client = new MockSessionManagerClient;;
+  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  EXPECT_CALL(*client, RetrievePolicy(_))
+      .WillOnce(Retrieve(""))
       .RetiresOnSaturation();
 
   s->Execute();
   message_loop_.RunAllPending();
-  UnMockLoginLib();
 }
 
 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));
 
-  MockLoginLibrary* lib = MockLoginLib();
-  EXPECT_CALL(*lib, RequestRetrievePolicy(_, s.get()))
-      .WillOnce(InvokeArgument<0>(static_cast<void*>(s.get()),
-                                  serialized.c_str(),
-                                  serialized.length()))
+  MockSessionManagerClient* client = new MockSessionManagerClient;;
+  DBusThreadManager::Get()->set_session_manager_client_for_testing(client);
+  EXPECT_CALL(*client, RetrievePolicy(_))
+      .WillOnce(Retrieve(serialized))
       .RetiresOnSaturation();
 
   s->Execute();
   message_loop_.RunAllPending();
-  UnMockLoginLib();
 }
 
 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));
 
-  MockLoginLibrary* lib = MockLoginLib();
-  EXPECT_CALL(*lib, RequestRetrievePolicy(_, s.get()))
-      .WillOnce(InvokeArgument<0>(static_cast<void*>(s.get()),
-                                  signed_serialized.c_str(),
-                                  signed_serialized.length()))
+  MockSessionManagerClient* client = new MockSessionManagerClient;;
+  DBusThreadManager::Get()->set_session_manager_client_for_testing(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();
-  UnMockLoginLib();
 
   s->OnKeyOpComplete(OwnerManager::OPERATION_FAILED, std::vector<uint8>());
   message_loop_.RunAllPending();
 }
 
 }  // namespace chromeos