Removed ConfigurationPolicyProvider::Provide().

chrome/browser/policy/asynchronous_policy_loader_unittest.cc

Index: chrome/browser/policy/asynchronous_policy_loader_unittest.cc
diff --git a/chrome/browser/policy/asynchronous_policy_loader_unittest.cc b/chrome/browser/policy/asynchronous_policy_loader_unittest.cc
index befb626ad187a77cdca50f6a44c1e23ce0d96893..cda39a83561820a35d4e6b3738650f176501ac50 100644
--- a/chrome/browser/policy/asynchronous_policy_loader_unittest.cc
+++ b/chrome/browser/policy/asynchronous_policy_loader_unittest.cc
@@ -43,33 +43,36 @@ class AsynchronousPolicyLoaderTest : public AsynchronousPolicyTestBase {
   DISALLOW_COPY_AND_ASSIGN(AsynchronousPolicyLoaderTest);
 };
 
-ACTION(CreateTestPolicyMap) {
-  return new PolicyMap();
+ACTION(CreateTestPolicyBundle) {
+  return new PolicyBundle();
 }
 
-ACTION_P(CreateSequencedTestPolicyMap, number) {
-  PolicyMap* test_policy_map = new PolicyMap();
-  test_policy_map->Set("id", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                       Value::CreateIntegerValue(++(*number)));
-  return test_policy_map;
+ACTION_P(CreateSequencedTestPolicyBundle, number) {
+  PolicyBundle* bundle = new PolicyBundle();
+  bundle->Get(POLICY_DOMAIN_CHROME, "")
+      .Set("id", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+           base::Value::CreateIntegerValue(++(*number)));
+  return bundle;
 }
 
 TEST_F(AsynchronousPolicyLoaderTest, InitialLoad) {
-  PolicyMap template_policy;
-  template_policy.Set("test", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                      Value::CreateIntegerValue(123));
-  PolicyMap* result = new PolicyMap();
-  result->CopyFrom(template_policy);
+  PolicyBundle template_bundle;
+  template_bundle.Get(POLICY_DOMAIN_CHROME, "")
+      .Set("test", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+           base::Value::CreateIntegerValue(123));
+  template_bundle.Get(POLICY_DOMAIN_EXTENSIONS, "extension-id")
+      .Set("test", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+           base::Value::CreateIntegerValue(123));
+  PolicyBundle* result = new PolicyBundle();
+  result->CopyFrom(template_bundle);
   ProviderDelegateMock* delegate = new ProviderDelegateMock();
-  EXPECT_CALL(*delegate, Load()).WillOnce(Return(result));
+  EXPECT_CALL(*delegate, MockLoad()).WillOnce(Return(result));

[Mattias Nissler (ping if slow), 2012/05/14 16:55:59]

It feels brittle to pass a pointer that's to-be-owned by the caller of the
function eventually. If you have the MockLoad() helper, can't you just make the
copy in MockLoad()? That will also avoid the need for two copies of the mock
here. Then again, that might be hairy when using actions.

[Joao da Silva, 2012/05/15 13:07:05]

I wanted to keep MockLoad() similar to the function it is mocking, just without
the scoped_ptr. The code is cleaner when MockLoad() creates a copy though, so
I've made this change as suggested.

   scoped_refptr<AsynchronousPolicyLoader> loader =
       new AsynchronousPolicyLoader(delegate, 10);
   EXPECT_FALSE(bundle_.get());
   loader->Init(update_callback_);
   ASSERT_TRUE(bundle_.get());
-  const PolicyMap& chrome_policy =
-      bundle_->Get(POLICY_DOMAIN_CHROME, std::string());
-  EXPECT_TRUE(chrome_policy.Equals(template_policy));
+  EXPECT_TRUE(bundle_->Equals(template_bundle));
 }
 
 // Verify that the fallback policy requests are made.
@@ -77,10 +80,10 @@ TEST_F(AsynchronousPolicyLoaderTest, InitialLoadWithFallback) {
   int policy_number = 0;
   InSequence s;
   ProviderDelegateMock* delegate = new ProviderDelegateMock();
-  EXPECT_CALL(*delegate, Load()).WillOnce(
-      CreateSequencedTestPolicyMap(&policy_number));
-  EXPECT_CALL(*delegate, Load()).WillOnce(
-      CreateSequencedTestPolicyMap(&policy_number));
+  EXPECT_CALL(*delegate, MockLoad()).WillOnce(
+      CreateSequencedTestPolicyBundle(&policy_number));
+  EXPECT_CALL(*delegate, MockLoad()).WillOnce(
+      CreateSequencedTestPolicyBundle(&policy_number));
   scoped_refptr<AsynchronousPolicyLoader> loader =
       new AsynchronousPolicyLoader(delegate, 10);
   loader->Init(update_callback_);
@@ -91,7 +94,7 @@ TEST_F(AsynchronousPolicyLoaderTest, InitialLoadWithFallback) {
   const PolicyMap& chrome_policy =
       bundle_->Get(POLICY_DOMAIN_CHROME, std::string());
   base::FundamentalValue expected(policy_number);
-  EXPECT_TRUE(Value::Equals(&expected, chrome_policy.GetValue("id")));
+  EXPECT_TRUE(base::Value::Equals(&expected, chrome_policy.GetValue("id")));
   EXPECT_EQ(1U, chrome_policy.size());
 }
 
@@ -99,8 +102,8 @@ TEST_F(AsynchronousPolicyLoaderTest, InitialLoadWithFallback) {
 // happening.
 TEST_F(AsynchronousPolicyLoaderTest, Stop) {
   ProviderDelegateMock* delegate = new ProviderDelegateMock();
-  ON_CALL(*delegate, Load()).WillByDefault(CreateTestPolicyMap());
-  EXPECT_CALL(*delegate, Load()).Times(1);
+  ON_CALL(*delegate, MockLoad()).WillByDefault(CreateTestPolicyBundle());
+  EXPECT_CALL(*delegate, MockLoad()).Times(1);
   scoped_refptr<AsynchronousPolicyLoader> loader =
       new AsynchronousPolicyLoader(delegate, 10);
   loader->Init(update_callback_);
@@ -119,8 +122,8 @@ TEST_F(AsynchronousPolicyLoaderTest, ProviderNotificationOnPolicyChange) {
   int policy_number_2 = 0;
 
   ProviderDelegateMock* delegate = new ProviderDelegateMock();
-  EXPECT_CALL(*delegate, Load()).WillOnce(
-      CreateSequencedTestPolicyMap(&policy_number_1));
+  EXPECT_CALL(*delegate, MockLoad()).WillOnce(
+      CreateSequencedTestPolicyBundle(&policy_number_1));
 
   scoped_refptr<AsynchronousPolicyLoader> loader =
       new AsynchronousPolicyLoader(delegate, 10);
@@ -130,16 +133,16 @@ TEST_F(AsynchronousPolicyLoaderTest, ProviderNotificationOnPolicyChange) {
   registrar.Init(&provider, &observer);
   Mock::VerifyAndClearExpectations(delegate);
 
-  EXPECT_CALL(*delegate, Load()).WillOnce(
-      CreateSequencedTestPolicyMap(&policy_number_2));
+  EXPECT_CALL(*delegate, MockLoad()).WillOnce(
+      CreateSequencedTestPolicyBundle(&policy_number_2));
   EXPECT_CALL(observer, OnUpdatePolicy(_)).Times(1);
   provider.RefreshPolicies();
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(delegate);
   Mock::VerifyAndClearExpectations(&observer);
 
-  EXPECT_CALL(*delegate, Load()).WillOnce(
-      CreateSequencedTestPolicyMap(&policy_number_1));
+  EXPECT_CALL(*delegate, MockLoad()).WillOnce(
+      CreateSequencedTestPolicyBundle(&policy_number_1));
   EXPECT_CALL(observer, OnUpdatePolicy(_)).Times(1);
   provider.RefreshPolicies();
   loop_.RunAllPending();