Move user cloud policy to BrowserProcess.

chrome/browser/policy/user_policy_cache_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/user_policy_cache.h"
 
 #include <limits>
 #include <string>
 
 #include "base/file_util.h"
@@ skipping 14 matching lines @@
 // Decodes a CloudPolicySettings object into two maps with mandatory and
 // recommended settings, respectively. The implementation is generated code
 // in policy/cloud_policy_generated.cc.
 void DecodePolicy(const em::CloudPolicySettings& policy,
                   PolicyMap* mandatory, PolicyMap* recommended);
 
 // The implementations of these methods are in cloud_policy_generated.cc.
 Value* DecodeIntegerValue(google::protobuf::int64 value);
 ListValue* DecodeStringList(const em::StringList& string_list);
 
-class MockConfigurationPolicyProviderObserver
-    : public ConfigurationPolicyProvider::Observer {
+class MockCloudPolicyCacheBaseObserver
+    : public CloudPolicyCacheBase::Observer {
  public:
-  MockConfigurationPolicyProviderObserver() {}
-  virtual ~MockConfigurationPolicyProviderObserver() {}
-  MOCK_METHOD0(OnUpdatePolicy, void());
-  void OnProviderGoingAway() {}
+  MockCloudPolicyCacheBaseObserver() {}
+  virtual ~MockCloudPolicyCacheBaseObserver() {}
+  MOCK_METHOD1(OnCacheUpdate, void(CloudPolicyCacheBase*));
+  void OnCacheGoingAway(CloudPolicyCacheBase*) {}
 };
 
 // Tests the device management policy cache.
 class UserPolicyCacheTest : public testing::Test {
  protected:
   UserPolicyCacheTest()
       : loop_(MessageLoop::TYPE_UI),
         ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_) {}
 
@@ skipping 44 matching lines @@
     EXPECT_TRUE(cached_policy.SerializeToString(&data));
     int size = static_cast<int>(data.size());
     EXPECT_EQ(size, file_util::WriteFile(test_file(), data.c_str(), size));
   }
 
   // Takes ownership of |policy_response|.
   void SetPolicy(UserPolicyCache* cache,
                  em::PolicyFetchResponse* policy_response,
                  bool expect_changed_policy) {
     scoped_ptr<em::PolicyFetchResponse> policy(policy_response);
-    ConfigurationPolicyObserverRegistrar registrar;
-    registrar.Init(cache->GetManagedPolicyProvider(), &observer);
+    cache->AddObserver(&observer);
+
     if (expect_changed_policy)
-      EXPECT_CALL(observer, OnUpdatePolicy()).Times(1);
+      EXPECT_CALL(observer, OnCacheUpdate(testing::_)).Times(1);

[Mattias Nissler (ping if slow), 2011/06/09 14:36:26]

using testing::_ at the top of the file.

[sfeuz, 2011/06/13 06:53:53]

Done.

     else
-      EXPECT_CALL(observer, OnUpdatePolicy()).Times(0);
+      EXPECT_CALL(observer, OnCacheUpdate(testing::_)).Times(0);
     cache->SetPolicy(*policy);
     testing::Mock::VerifyAndClearExpectations(&observer);
+
+    cache->RemoveObserver(&observer);
   }
 
   FilePath test_file() {
     return temp_dir_.path().AppendASCII("UserPolicyCacheTest");
   }
 
   const PolicyMap& mandatory_policy(const UserPolicyCache& cache) {
     return cache.mandatory_policy_;
   }
 
   const PolicyMap& recommended_policy(const UserPolicyCache& cache) {
     return cache.recommended_policy_;
   }
 
   MessageLoop loop_;
-  MockConfigurationPolicyProviderObserver observer;
+  MockCloudPolicyCacheBaseObserver observer;
 
  private:
   ScopedTempDir temp_dir_;
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
 };
 
 TEST_F(UserPolicyCacheTest, DecodePolicy) {
   em::CloudPolicySettings settings;
   settings.mutable_homepagelocation()->set_homepagelocation("chromium.org");
@@ skipping 233 matching lines @@
   // If new-style policy comes in, it should override old-style policy.
   policy = CreateHomepagePolicy("http://www.example.com",
                                 base::Time::NowFromSystemTime(),
                                 em::PolicyOptions::RECOMMENDED);
   SetPolicy(&cache, policy, true);
   EXPECT_TRUE(expected.Equals(recommended_policy(cache)));
   EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
 }
 
 }  // namespace policy