Cleanup the policy code after the recent moves into the component.

components/policy/core/common/policy_service_impl_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 "components/policy/core/common/policy_service_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/mock_policy_service.h"
+#include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AnyNumber;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::_;
 
 namespace policy {
 
 namespace {
 
 const char kExtension[] = "extension-id";
 const char kSameLevelPolicy[] = "policy-same-level-and-scope";
 const char kDiffLevelPolicy[] = "chrome-diff-level-and-scope";
 
-void SetPolicyMapValue(const std::string& key,
-                       const std::string& value,
-                       PolicyBundle* bundle) {
-  bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
-      .Set(key,
-           POLICY_LEVEL_MANDATORY,
-           POLICY_SCOPE_USER,
-           new base::StringValue(value),
-           NULL);
-}
-
 // Helper to compare the arguments to an EXPECT_CALL of OnPolicyUpdated() with
 // their expected values.
 MATCHER_P(PolicyEquals, expected, "") {
   return arg.Equals(*expected);
 }
 
 // Helper to compare the arguments to an EXPECT_CALL of OnPolicyValueUpdated()
 // with their expected values.
 MATCHER_P(ValueEquals, expected, "") {
   return base::Value::Equals(arg, expected);
@@ skipping 62 matching lines @@
     provider2_.Init();
 
     policy0_.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                  base::Value::CreateIntegerValue(13), NULL);
     provider0_.UpdateChromePolicy(policy0_);
 
     PolicyServiceImpl::Providers providers;
     providers.push_back(&provider0_);
     providers.push_back(&provider1_);
     providers.push_back(&provider2_);
-    policy_service_.reset(new PolicyServiceImpl(
-        providers, PolicyServiceImpl::PreprocessCallback()));
+    policy_service_.reset(new PolicyServiceImpl(providers));
   }
 
   virtual void TearDown() OVERRIDE {
     provider0_.Shutdown();
     provider1_.Shutdown();
     provider2_.Shutdown();
   }
 
   MOCK_METHOD2(OnPolicyValueUpdated, void(const base::Value*,
                                           const base::Value*));
@@ skipping 390 matching lines @@
   // For policies with different levels and scopes, the highest priority
   // level/scope combination takes precedence, on every namespace.
   expected.Set(kDiffLevelPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                base::Value::CreateStringValue("bundle2"), NULL);
   EXPECT_TRUE(policy_service_->GetPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())).Equals(expected));
   EXPECT_TRUE(policy_service_->GetPolicies(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension)).Equals(expected));
 }
 
-TEST_F(PolicyServiceTest, PolicyPreprocessing) {
-  // Reset the PolicyServiceImpl to one that has the preprocessor.
-  PolicyServiceImpl::Providers providers;
-  providers.push_back(&provider0_);
-  policy_service_.reset(new PolicyServiceImpl(
-      providers, base::Bind(&SetPolicyMapValue, kSameLevelPolicy, "bar")));
-
-  // Set the policy value to "foo".
-  scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
-  PolicyMap& map =
-      bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
-  map.Set(kSameLevelPolicy,
-          POLICY_LEVEL_MANDATORY,
-          POLICY_SCOPE_USER,
-          base::Value::CreateStringValue("foo"),
-          NULL);
-
-  // Push the update through the provider.
-  provider0_.UpdatePolicy(bundle.Pass());
-  RunUntilIdle();
-
-  // The value should have been changed from "foo" to "bar".
-  const PolicyMap& actual = policy_service_->GetPolicies(
-        PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
-  PolicyMap expected;
-  expected.Set(kSameLevelPolicy,
-               POLICY_LEVEL_MANDATORY,
-               POLICY_SCOPE_USER,
-               base::Value::CreateStringValue("bar"),
-               NULL);
-  EXPECT_TRUE(actual.Equals(expected));
-}
-
 TEST_F(PolicyServiceTest, IsInitializationComplete) {
   // |provider0| has all domains initialized.
   Mock::VerifyAndClearExpectations(&provider1_);
   Mock::VerifyAndClearExpectations(&provider2_);
   EXPECT_CALL(provider1_, IsInitializationComplete(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(provider2_, IsInitializationComplete(_))
       .WillRepeatedly(Return(false));
   PolicyServiceImpl::Providers providers;
   providers.push_back(&provider0_);
   providers.push_back(&provider1_);
   providers.push_back(&provider2_);
-  policy_service_.reset(new PolicyServiceImpl(
-      providers, PolicyServiceImpl::PreprocessCallback()));
+  policy_service_.reset(new PolicyServiceImpl(providers));
   EXPECT_FALSE(policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_FALSE(
       policy_service_->IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS));
 
   // |provider2_| still doesn't have POLICY_DOMAIN_CHROME initialized, so
   // the initialization status of that domain won't change.
   MockPolicyServiceObserver observer;
   policy_service_->AddObserver(POLICY_DOMAIN_CHROME, &observer);
   policy_service_->AddObserver(POLICY_DOMAIN_EXTENSIONS, &observer);
   EXPECT_CALL(observer, OnPolicyServiceInitialized(_)).Times(0);
@@ skipping 47 matching lines @@
   Mock::VerifyAndClearExpectations(&observer);
   EXPECT_TRUE(policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_TRUE(
       policy_service_->IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS));
 
   // Cleanup.
   policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, &observer);
   policy_service_->RemoveObserver(POLICY_DOMAIN_EXTENSIONS, &observer);
 }
 
+TEST_F(PolicyServiceTest, FixDeprecatedPolicies) {
+  const PolicyNamespace chrome_namespace(POLICY_DOMAIN_CHROME, std::string());
+  const PolicyNamespace extension_namespace(POLICY_DOMAIN_EXTENSIONS, "xyz");
+
+  scoped_ptr<PolicyBundle> policy_bundle(new PolicyBundle());
+  PolicyMap& policy_map = policy_bundle->Get(chrome_namespace);
+  // Individual proxy policy values in the Chrome namespace should be collected
+  // into a dictionary.
+  policy_map.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY,
+                 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(3), NULL);
+
+  // 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"), NULL);
+  policy_map.Set(key::kProxyPacUrl, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
+                 base::Value::CreateStringValue("http://example.com/wpad.dat"),
+                 NULL);
+
+  // Add a value to a non-Chrome namespace.
+  policy_bundle->Get(extension_namespace)
+      .Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+           base::Value::CreateIntegerValue(3), NULL);
+
+  // The resulting Chrome namespace map should have the collected policy.
+  PolicyMap expected_chrome;
+  scoped_ptr<base::DictionaryValue> expected_value(new base::DictionaryValue);
+  expected_value->SetInteger(key::kProxyServerMode, 3);
+  expected_chrome.Set(key::kProxySettings, POLICY_LEVEL_MANDATORY,
+                      POLICY_SCOPE_USER, expected_value.release(), NULL);
+
+  // The resulting Extensions namespace map shouldn't have been modified.
+  PolicyMap expected_extension;
+  expected_extension.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY,
+                         POLICY_SCOPE_USER, base::Value::CreateIntegerValue(3),
+                         NULL);
+
+  provider0_.UpdatePolicy(policy_bundle.Pass());
+  RunUntilIdle();
+
+  EXPECT_TRUE(VerifyPolicies(chrome_namespace, expected_chrome));
+  EXPECT_TRUE(VerifyPolicies(extension_namespace, expected_extension));
+}
+
 }  // namespace policy