Removed ConfigurationPolicyProvider::Provide().

chrome/browser/policy/configuration_policy_provider_test.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/policy/configuration_policy_provider_test.h"
 
 #include "base/bind.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/policy/asynchronous_policy_loader.h"
 #include "chrome/browser/policy/asynchronous_policy_provider.h"
 #include "chrome/browser/policy/configuration_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"
 
 using ::testing::Mock;
 using ::testing::_;
 
 namespace policy {
 
 namespace test_policy_definitions {
@@ skipping 11 matching lines @@
   { kKeyStringList, base::Value::TYPE_LIST },
   { kKeyDictionary, base::Value::TYPE_DICTIONARY },
 };
 
 const PolicyDefinitionList kList = {
   kEntries, kEntries + arraysize(kEntries)
 };
 
 }  // namespace test_policy_definitions
 
-PolicyProviderTestHarness::PolicyProviderTestHarness() {}
+PolicyProviderTestHarness::PolicyProviderTestHarness(PolicyLevel level,
+                                                     PolicyScope scope)
+    : level_(level), scope_(scope) {}
 
 PolicyProviderTestHarness::~PolicyProviderTestHarness() {}
 
+PolicyLevel PolicyProviderTestHarness::policy_level() const {
+  return level_;
+}
+
+PolicyScope PolicyProviderTestHarness::policy_scope() const {
+  return scope_;
+}
+
 ConfigurationPolicyProviderTest::ConfigurationPolicyProviderTest() {}
 
 ConfigurationPolicyProviderTest::~ConfigurationPolicyProviderTest() {}
 
 void ConfigurationPolicyProviderTest::SetUp() {
   AsynchronousPolicyTestBase::SetUp();
 
   test_harness_.reset((*GetParam())());
   test_harness_->SetUp();
 
   provider_.reset(
       test_harness_->CreateProvider(&test_policy_definitions::kList));
   // Some providers do a reload on init. Make sure any notifications generated
   // are fired now.
   loop_.RunAllPending();
 
-  PolicyMap policy_map;
-  EXPECT_TRUE(provider_->Provide(&policy_map));
-  EXPECT_TRUE(policy_map.empty());
+  const PolicyBundle kEmptyBundle;
+  EXPECT_TRUE(provider_->policies().Equals(kEmptyBundle));
 }
 
 void ConfigurationPolicyProviderTest::TearDown() {
   // Give providers the chance to clean up after themselves on the file thread.
   provider_.reset();
 
   AsynchronousPolicyTestBase::TearDown();
 }
 
 void ConfigurationPolicyProviderTest::CheckValue(
     const char* policy_name,
     const base::Value& expected_value,
     base::Closure install_value) {
   // Install the value, reload policy and check the provider for the value.
   install_value.Run();
   provider_->RefreshPolicies();
   loop_.RunAllPending();
-  PolicyMap policy_map;
-  EXPECT_TRUE(provider_->Provide(&policy_map));
-  EXPECT_EQ(1U, policy_map.size());
-  EXPECT_TRUE(base::Value::Equals(&expected_value,
-                                  policy_map.GetValue(policy_name)));
+  PolicyBundle expected_bundle;
+  expected_bundle.Get(POLICY_DOMAIN_CHROME, "")
+      .Set(policy_name,
+           test_harness_->policy_level(),
+           test_harness_->policy_scope(),
+           expected_value.DeepCopy());
+  EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
+  // TODO(joaodasilva): set the policy in the POLICY_DOMAIN_EXTENSIONS too,
+  // and extend the |expected_bundle|, once all providers are ready.
 }
 
 TEST_P(ConfigurationPolicyProviderTest, Empty) {
   provider_->RefreshPolicies();
   loop_.RunAllPending();
-  PolicyMap policy_map;
-  EXPECT_TRUE(provider_->Provide(&policy_map));
-  EXPECT_TRUE(policy_map.empty());
+  const PolicyBundle kEmptyBundle;
+  EXPECT_TRUE(provider_->policies().Equals(kEmptyBundle));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, StringValue) {
   const char kTestString[] = "string_value";
   base::StringValue expected_value(kTestString);
   CheckValue(test_policy_definitions::kKeyString,
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallStringPolicy,
                         base::Unretained(test_harness_.get()),
                         test_policy_definitions::kKeyString,
@@ skipping 59 matching lines @@
 
   CheckValue(test_policy_definitions::kKeyDictionary,
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallDictionaryPolicy,
                         base::Unretained(test_harness_.get()),
                         test_policy_definitions::kKeyDictionary,
                         &expected_value));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, RefreshPolicies) {
-  PolicyMap policy_map;
-  EXPECT_TRUE(provider_->Provide(&policy_map));
-  EXPECT_EQ(0U, policy_map.size());
+  PolicyBundle bundle;
+  EXPECT_TRUE(provider_->policies().Equals(bundle));
 
   // OnUpdatePolicy is called even when there are no changes.
   MockConfigurationPolicyObserver observer;
   ConfigurationPolicyObserverRegistrar registrar;
   registrar.Init(provider_.get(), &observer);
   EXPECT_CALL(observer, OnUpdatePolicy(provider_.get())).Times(1);
   provider_->RefreshPolicies();
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(&observer);
 
-  EXPECT_TRUE(provider_->Provide(&policy_map));
-  EXPECT_EQ(0U, policy_map.size());
+  EXPECT_TRUE(provider_->policies().Equals(bundle));
 
   // OnUpdatePolicy is called when there are changes.
   test_harness_->InstallStringPolicy(test_policy_definitions::kKeyString,
                                      "value");
   EXPECT_CALL(observer, OnUpdatePolicy(provider_.get())).Times(1);
   provider_->RefreshPolicies();
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(&observer);
 
-  policy_map.Clear();
-  EXPECT_TRUE(provider_->Provide(&policy_map));
-  EXPECT_EQ(1U, policy_map.size());
+  bundle.Get(POLICY_DOMAIN_CHROME, "")
+      .Set(test_policy_definitions::kKeyString,
+           test_harness_->policy_level(),
+           test_harness_->policy_scope(),
+           base::Value::CreateStringValue("value"));
+  EXPECT_TRUE(provider_->policies().Equals(bundle));
 }
 
 TEST(ConfigurationPolicyProviderTest, FixDeprecatedPolicies) {
   PolicyMap policy_map;
   policy_map.Set(key::kProxyServerMode,
                  POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER,
                  base::Value::CreateIntegerValue(3));
 
   // Both these policies should be ignored, since there's a higher priority
   // policy available.
   policy_map.Set(key::kProxyMode,
                  POLICY_LEVEL_RECOMMENDED,
                  POLICY_SCOPE_USER,
                  base::Value::CreateStringValue("pac_script"));
   policy_map.Set(key::kProxyPacUrl,
                  POLICY_LEVEL_RECOMMENDED,
                  POLICY_SCOPE_USER,
                  base::Value::CreateStringValue("http://example.com/wpad.dat"));
 
-  ConfigurationPolicyProvider::FixDeprecatedPolicies(&policy_map);
-  base::DictionaryValue expected;
-  expected.SetInteger(key::kProxyServerMode, 3);
-  EXPECT_EQ(1U, policy_map.size());
-  EXPECT_TRUE(base::Value::Equals(&expected,
-                                  policy_map.GetValue(key::kProxySettings)));
+  MockConfigurationPolicyProvider provider;
+  provider.UpdateChromePolicy(policy_map);
+
+  PolicyBundle expected_bundle;
+  base::DictionaryValue* expected_value = new base::DictionaryValue();
+  expected_value->SetInteger(key::kProxyServerMode, 3);
+  expected_bundle.Get(POLICY_DOMAIN_CHROME, "")
+      .Set(key::kProxySettings, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+           expected_value);
+  EXPECT_TRUE(provider.policies().Equals(expected_bundle));
 }
 
 }  // namespace policy