Send policy blobs to session_manager

chrome/browser/policy/cloud_policy_controller_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/policy/cloud_policy_controller.h"
 
 #include "base/memory/scoped_temp_dir.h"
 #include "base/message_loop.h"
-#include "chrome/browser/policy/cloud_policy_cache.h"
 #include "chrome/browser/policy/device_token_fetcher.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"

[Mattias Nissler (ping if slow), 2011/03/29 08:58:39]

alphabetize.

[Jakob Kummerow, 2011/03/29 09:33:37]

Done.

 #include "chrome/browser/policy/mock_configuration_policy_store.h"
 #include "chrome/browser/policy/mock_device_management_backend.h"
+#include "chrome/browser/policy/user_policy_cache.h"
 #include "content/browser/browser_thread.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const char kTestToken[] = "cloud_policy_controller_test_auth_token";
 
 namespace policy {
 
 namespace em = enterprise_management;
@@ skipping 23 matching lines @@
 };
 
 ACTION_P2(MockCloudPolicyIdentityStrategyGetCredentials, username, auth_token) {
   *arg0 = username;
   *arg1 = auth_token;
   return true;
 }
 
 class MockDeviceTokenFetcher : public DeviceTokenFetcher {
  public:
-  explicit MockDeviceTokenFetcher(CloudPolicyCache* cache)
+  explicit MockDeviceTokenFetcher(CloudPolicyCacheBase* cache)
       : DeviceTokenFetcher(NULL, cache) {}
   virtual ~MockDeviceTokenFetcher() {}
 
   MOCK_METHOD0(GetDeviceToken, const std::string&());
   MOCK_METHOD4(FetchToken,
       void(const std::string&, const std::string&,
            em::DeviceRegisterRequest_Type, const std::string&));
   MOCK_METHOD0(SetUnmanagedState, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDeviceTokenFetcher);
 };
 
 class CloudPolicyControllerTest : public testing::Test {
  public:
   CloudPolicyControllerTest()
       : ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_) {}
 
   virtual ~CloudPolicyControllerTest() {}
 
   virtual void SetUp() {
     ASSERT_TRUE(temp_user_data_dir_.CreateUniqueTempDir());
-    cache_.reset(new CloudPolicyCache(
+    cache_.reset(new UserPolicyCache(
         temp_user_data_dir_.path().AppendASCII("CloudPolicyControllerTest")));
     token_fetcher_.reset(new MockDeviceTokenFetcher(cache_.get()));
   }
 
   virtual void TearDown() {
     controller_.reset();  // Unregisters observers.
   }
 
   // Takes ownership of |backend|.
   void CreateNewController(DeviceManagementBackend* backend) {
@@ skipping 41 matching lines @@
         Return(policy_type));
     EXPECT_CALL(identity_strategy_, GetPolicyRegisterType()).WillRepeatedly(
         Return(policy_register_type));
     if (!user_name.empty()) {
       EXPECT_CALL(identity_strategy_, GetCredentials(_, _)).WillRepeatedly(
           MockCloudPolicyIdentityStrategyGetCredentials(user_name, auth_token));
     }
   }
 
  protected:
-  scoped_ptr<CloudPolicyCache> cache_;
+  scoped_ptr<CloudPolicyCacheBase> cache_;
   scoped_ptr<CloudPolicyController> controller_;
   scoped_ptr<MockDeviceTokenFetcher> token_fetcher_;
   MockCloudPolicyIdentityStrategy identity_strategy_;
   ScopedTempDir temp_user_data_dir_;
   MessageLoop loop_;
 
  private:
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
 
@@ skipping 107 matching lines @@
   MockDeviceManagementBackend* backend = new MockDeviceManagementBackend();
   EXPECT_CALL(*backend, ProcessPolicyRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorServiceManagementNotSupported));
   EXPECT_CALL(*token_fetcher_.get(), SetUnmanagedState()).Times(1);
   CreateNewController(backend, 0, 0, 0, 1000 * 1000);
   loop_.RunAllPending();
 }
 
 }  // namespace policy