Store/Retrieve CrOS user policy in session_manager.

chrome/browser/chromeos/login/login_utils_browsertest.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 "chrome/browser/chromeos/login/login_utils.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
@@ skipping 31 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 
 namespace {
 
 namespace em = enterprise_management;
 
 using ::testing::DoAll;
 using ::testing::Return;
+using ::testing::SaveArg;
 using ::testing::SetArgPointee;
 using ::testing::_;
 using content::BrowserThread;
 
 const char kTrue[] = "true";
 const char kDomain[] = "domain.com";
 const char kUsername[] = "user@domain.com";
 const char kMode[] = "enterprise";
 const char kDeviceId[] = "100200300";
 const char kUsernameOtherDomain[] = "user@other.com";
@@ skipping 10 matching lines @@
     "wrap_access_token=1234&wrap_access_token_expires_in=123456789";
 
 const char kDMServer[] = "http://server/device_management";
 const char kDMRegisterRequest[] =
     "http://server/device_management?request=register";
 const char kDMPolicyRequest[] =
     "http://server/device_management?request=policy";
 
 const char kDMToken[] = "1234";
 
-ACTION_P(MockSessionManagerClientPolicyCallback, policy) {
-  arg0.Run(policy);
+ACTION_P(MockSessionManagerClientRetrievePolicyCallback, policy) {
+  arg0.Run(*policy);
+}
+
+ACTION_P(MockSessionManagerClientStorePolicyCallback, success) {
+  arg1.Run(success);
 }
 
 template<typename TESTBASE>
 class LoginUtilsTestBase : public TESTBASE,
                            public LoginUtils::Delegate,
                            public LoginStatusConsumer {
  public:
   // Initialization here is important. The UI thread gets the test's
   // message loop, as does the file thread (which never actually gets
   // started - so this is a way to fake multiple threads on a single
@@ skipping 10 matching lines @@
         ui_thread_(content::BrowserThread::UI, &loop_),
         file_thread_(content::BrowserThread::FILE, &loop_),
         io_thread_(content::BrowserThread::IO),
         mock_async_method_caller_(NULL),
         connector_(NULL),
         cryptohome_(NULL),
         prepared_profile_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
-    // BrowserPolicyConnector makes the UserPolicyCache read relative to this
-    // path. Make sure it's in a clean state.
-    PathService::Override(chrome::DIR_USER_DATA, scoped_temp_dir_.path());
 
     CommandLine* command_line = CommandLine::ForCurrentProcess();
     command_line->AppendSwitch(switches::kEnableDevicePolicy);
     command_line->AppendSwitchASCII(switches::kDeviceManagementUrl, kDMServer);
     command_line->AppendSwitchASCII(switches::kLoginProfile, "user");
 
     local_state_.Get()->RegisterStringPref(prefs::kApplicationLocale, "");
 
     // DBusThreadManager should be initialized before io_thread_state_, as
     // DBusThreadManager is used from chromeos::ProxyConfigServiceImpl,
     // which is part of io_thread_state_.
     DBusThreadManager::InitializeForTesting(&mock_dbus_thread_manager_);
 
     // Likewise, SessionManagerClient should also be initialized before
     // io_thread_state_.
     MockSessionManagerClient* session_managed_client =
         mock_dbus_thread_manager_.mock_session_manager_client();
     EXPECT_CALL(*session_managed_client, RetrieveDevicePolicy(_))
-        .WillRepeatedly(MockSessionManagerClientPolicyCallback(""));
+        .WillRepeatedly(
+            MockSessionManagerClientRetrievePolicyCallback(&device_policy_));
+    EXPECT_CALL(*session_managed_client, RetrieveUserPolicy(_))
+        .WillRepeatedly(
+            MockSessionManagerClientRetrievePolicyCallback(&user_policy_));
+    EXPECT_CALL(*session_managed_client, StoreUserPolicy(_, _))
+        .WillRepeatedly(
+            DoAll(SaveArg<0>(&user_policy_),
+                  MockSessionManagerClientStorePolicyCallback(true)));
 
     mock_async_method_caller_ = new cryptohome::MockAsyncMethodCaller;
     cryptohome::AsyncMethodCaller::InitializeForTesting(
         mock_async_method_caller_);
 
     io_thread_state_.reset(new IOThread(local_state_.Get(), NULL, NULL));
     browser_process_->SetIOThread(io_thread_state_.get());
 
     CrosLibrary::TestApi* test_api = CrosLibrary::Get()->GetTestApi();
     ASSERT_TRUE(test_api);
@@ skipping 211 matching lines @@
 
   cryptohome::MockAsyncMethodCaller* mock_async_method_caller_;
 
   policy::BrowserPolicyConnector* connector_;
   MockCryptohomeLibrary* cryptohome_;
   Profile* prepared_profile_;
 
  private:
   ScopedTempDir scoped_temp_dir_;
 
+  std::string device_policy_;
+  std::string user_policy_;
+
   DISALLOW_COPY_AND_ASSIGN(LoginUtilsTestBase);
 };
 
 class LoginUtilsTest : public LoginUtilsTestBase<testing::Test> {
 };
 
 class LoginUtilsBlockingLoginTest
     : public LoginUtilsTestBase<testing::TestWithParam<int> > {
 };
 
@@ skipping 127 matching lines @@
 }
 
 INSTANTIATE_TEST_CASE_P(
     LoginUtilsBlockingLoginTestInstance,
     LoginUtilsBlockingLoginTest,
     testing::Values(0, 1, 2, 3, 4, 5));
 
 }  // namespace
 
 }