Removed ConfigurationPolicyProvider::Provide().

chrome/browser/policy/file_based_policy_provider_unittest.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 "base/values.h"
 #include "chrome/browser/policy/asynchronous_policy_loader.h"
 #include "chrome/browser/policy/asynchronous_policy_test_base.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/file_based_policy_provider.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
+#include "chrome/browser/policy/policy_bundle.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::InSequence;
 using testing::Return;
 using testing::_;
 
 namespace policy {
 
 class FileBasedPolicyProviderDelegateMock
     : public FileBasedPolicyProvider::ProviderDelegate {
  public:
   FileBasedPolicyProviderDelegateMock()
       : FileBasedPolicyProvider::ProviderDelegate(FilePath()) {}
-  MOCK_METHOD0(Load, PolicyMap*());
+
+  // Load() returns a scoped_ptr<PolicyBundle> but it can't be mocked because
+  // scoped_ptr is moveable but not copyable. This override forwards the
+  // call to MockLoad() which returns a PolicyBundle*, and returns it wrapped
+  // in a passed scoped_ptr.
+  virtual scoped_ptr<PolicyBundle> Load() OVERRIDE {
+    scoped_ptr<PolicyBundle> bundle(MockLoad());
+    return bundle.Pass();
+  }
+
+  MOCK_METHOD0(MockLoad, PolicyBundle*());

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

Should document that this actually needs to return ownership as well. Or as
noted before make it such that we don't need to transfer ownership, which makes
things easier in case you want something to call this function multiple times.

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

Modified as suggested before.

   MOCK_METHOD0(GetLastModification, base::Time());
 };
 
 TEST_F(AsynchronousPolicyTestBase, ProviderInit) {
   base::Time last_modified;
   FileBasedPolicyProviderDelegateMock* provider_delegate =
       new FileBasedPolicyProviderDelegateMock();
   EXPECT_CALL(*provider_delegate, GetLastModification()).WillRepeatedly(
       Return(last_modified));
   InSequence s;
-  EXPECT_CALL(*provider_delegate, Load()).WillOnce(Return(new PolicyMap));
-  PolicyMap* policies = new PolicyMap();
-  policies->Set(key::kSyncDisabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                Value::CreateBooleanValue(true));
+  EXPECT_CALL(*provider_delegate, MockLoad())
+      .WillOnce(Return(new PolicyBundle));
+  PolicyBundle* bundle = new PolicyBundle();
+  bundle->Get(POLICY_DOMAIN_CHROME, "")
+      .Set(key::kSyncDisabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+           base::Value::CreateBooleanValue(true));
   // A second call to Load gets triggered during the provider's construction
   // when the file watcher is initialized, since this file may have changed
   // between the initial load and creating watcher.
-  EXPECT_CALL(*provider_delegate, Load()).WillOnce(Return(policies));
+  EXPECT_CALL(*provider_delegate, MockLoad()).WillOnce(Return(bundle));
   FileBasedPolicyProvider provider(GetChromePolicyDefinitionList(),
                                    provider_delegate);
   loop_.RunAllPending();
-  PolicyMap policy_map;
-  provider.Provide(&policy_map);
-  base::FundamentalValue expected(true);
-  EXPECT_TRUE(Value::Equals(&expected,
-                            policy_map.GetValue(key::kSyncDisabled)));
-  EXPECT_EQ(1U, policy_map.size());
+  PolicyBundle expected_bundle;
+  expected_bundle.Get(POLICY_DOMAIN_CHROME, "")
+      .Set(key::kSyncDisabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+           base::Value::CreateBooleanValue(true));
+  EXPECT_TRUE(provider.policies().Equals(expected_bundle));

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

And if you were to avoid passing ownership, you could just test against |bundle|
here.

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

Yep, done.

 }
 
 TEST_F(AsynchronousPolicyTestBase, ProviderRefresh) {
   base::Time last_modified;
   FileBasedPolicyProviderDelegateMock* provider_delegate =
       new FileBasedPolicyProviderDelegateMock();
   EXPECT_CALL(*provider_delegate, GetLastModification()).WillRepeatedly(
       Return(last_modified));
   InSequence s;
-  EXPECT_CALL(*provider_delegate, Load()).WillOnce(Return(new PolicyMap));
+  EXPECT_CALL(*provider_delegate, MockLoad())
+      .WillOnce(Return(new PolicyBundle));
   FileBasedPolicyProvider file_based_provider(GetChromePolicyDefinitionList(),
                                               provider_delegate);
   // A second call to Load gets triggered during the provider's construction
   // when the file watcher is initialized, since this file may have changed
   // between the initial load and creating watcher.
-  EXPECT_CALL(*provider_delegate, Load()).WillOnce(Return(new PolicyMap));
+  EXPECT_CALL(*provider_delegate, MockLoad())
+      .WillOnce(Return(new PolicyBundle));
   loop_.RunAllPending();
   // A third and final call to Load is made by the explicit Reload. This
   // should be the one that provides the current policy.
-  PolicyMap* policies = new PolicyMap();
-  policies->Set(key::kSyncDisabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                Value::CreateBooleanValue(true));
-  EXPECT_CALL(*provider_delegate, Load()).WillOnce(Return(policies));
+  PolicyBundle* bundle = new PolicyBundle();
+  bundle->Get(POLICY_DOMAIN_CHROME, "")
+      .Set(key::kSyncDisabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+           base::Value::CreateBooleanValue(true));
+  EXPECT_CALL(*provider_delegate, MockLoad()).WillOnce(Return(bundle));
   MockConfigurationPolicyObserver observer;
   ConfigurationPolicyObserverRegistrar registrar;
   registrar.Init(&file_based_provider, &observer);
   EXPECT_CALL(observer, OnUpdatePolicy(&file_based_provider)).Times(1);
   file_based_provider.RefreshPolicies();
   loop_.RunAllPending();
-  PolicyMap policy_map;
-  file_based_provider.Provide(&policy_map);
-  base::FundamentalValue expected(true);
-  EXPECT_TRUE(Value::Equals(&expected,
-                            policy_map.GetValue(key::kSyncDisabled)));
-  EXPECT_EQ(1U, policy_map.size());
+  PolicyBundle expected_bundle;
+  expected_bundle.Get(POLICY_DOMAIN_CHROME, "")
+        .Set(key::kSyncDisabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+             base::Value::CreateBooleanValue(true));
+  EXPECT_TRUE(file_based_provider.policies().Equals(expected_bundle));
 }
 
 }  // namespace policy