Removed the PolicyDefinitionList.

chrome/browser/policy/policy_loader_win_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 "chrome/browser/policy/policy_loader_win.h"
 
 #include <userenv.h>
 #include <windows.h>
 
 #include <algorithm>
@@ skipping 17 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/win/registry.h"
 #include "chrome/browser/policy/async_policy_provider.h"
 #include "chrome/browser/policy/configuration_policy_provider_test.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/policy_bundle.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/preg_parser_win.h"
 #include "components/json_schema/json_schema_constants.h"
-#include "policy/policy_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace schema = json_schema_constants;
 
 using base::win::RegKey;
 
 namespace policy {
 
 namespace {
 
@@ skipping 197 matching lines @@
                             public AppliedGPOListProvider {
  public:
   RegistryTestHarness(HKEY hive, PolicyScope scope);
   virtual ~RegistryTestHarness();
 
   // PolicyProviderTestHarness:
   virtual void SetUp() OVERRIDE;
 
   virtual ConfigurationPolicyProvider* CreateProvider(
       SchemaRegistry* registry,
-      scoped_refptr<base::SequencedTaskRunner> task_runner,
-      const PolicyDefinitionList* policy_list) OVERRIDE;
+      scoped_refptr<base::SequencedTaskRunner> task_runner) OVERRIDE;
 
   virtual void InstallEmptyPolicy() OVERRIDE;
   virtual void InstallStringPolicy(const std::string& policy_name,
                                    const std::string& policy_value) OVERRIDE;
   virtual void InstallIntegerPolicy(const std::string& policy_name,
                                     int policy_value) OVERRIDE;
   virtual void InstallBooleanPolicy(const std::string& policy_name,
                                     bool policy_value) OVERRIDE;
   virtual void InstallStringListPolicy(
       const std::string& policy_name,
@@ skipping 30 matching lines @@
                         public AppliedGPOListProvider {
  public:
   PRegTestHarness();
   virtual ~PRegTestHarness();
 
   // PolicyProviderTestHarness:
   virtual void SetUp() OVERRIDE;
 
   virtual ConfigurationPolicyProvider* CreateProvider(
       SchemaRegistry* registry,
-      scoped_refptr<base::SequencedTaskRunner> task_runner,
-      const PolicyDefinitionList* policy_list) OVERRIDE;
+      scoped_refptr<base::SequencedTaskRunner> task_runner) OVERRIDE;
 
   virtual void InstallEmptyPolicy() OVERRIDE;
   virtual void InstallStringPolicy(const std::string& policy_name,
                                    const std::string& policy_value) OVERRIDE;
   virtual void InstallIntegerPolicy(const std::string& policy_name,
                                     int policy_value) OVERRIDE;
   virtual void InstallBooleanPolicy(const std::string& policy_name,
                                     bool policy_value) OVERRIDE;
   virtual void InstallStringListPolicy(
       const std::string& policy_name,
@@ skipping 96 matching lines @@
 
 RegistryTestHarness::RegistryTestHarness(HKEY hive, PolicyScope scope)
     : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, scope), hive_(hive) {}
 
 RegistryTestHarness::~RegistryTestHarness() {}
 
 void RegistryTestHarness::SetUp() {}
 
 ConfigurationPolicyProvider* RegistryTestHarness::CreateProvider(
     SchemaRegistry* registry,
-    scoped_refptr<base::SequencedTaskRunner> task_runner,
-    const PolicyDefinitionList* policy_list) {
-  scoped_ptr<AsyncPolicyLoader> loader(new PolicyLoaderWin(
-      task_runner, policy_list, kRegistryChromePolicyKey, this));
+    scoped_refptr<base::SequencedTaskRunner> task_runner) {
+  scoped_ptr<AsyncPolicyLoader> loader(
+      new PolicyLoaderWin(task_runner, kRegistryChromePolicyKey, this));
   return new AsyncPolicyProvider(registry, loader.Pass());
 }
 
 void RegistryTestHarness::InstallEmptyPolicy() {}
 
 void RegistryTestHarness::InstallStringPolicy(
     const std::string& policy_name,
     const std::string& policy_value) {
   RegKey key(hive_, kRegistryChromePolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
@@ skipping 109 matching lines @@
   ASSERT_TRUE(file_util::WriteFile(preg_file_path_,
                                    preg_parser::kPRegFileHeader,
                                    arraysize(preg_parser::kPRegFileHeader)));
 
   memset(&gpo_, 0, sizeof(GROUP_POLICY_OBJECT));
   gpo_.lpFileSysPath = const_cast<wchar_t*>(temp_dir_.path().value().c_str());
 }
 
 ConfigurationPolicyProvider* PRegTestHarness::CreateProvider(
     SchemaRegistry* registry,
-    scoped_refptr<base::SequencedTaskRunner> task_runner,
-    const PolicyDefinitionList* policy_list) {
-  scoped_ptr<AsyncPolicyLoader> loader(new PolicyLoaderWin(
-      task_runner, policy_list, kRegistryChromePolicyKey, this));
+    scoped_refptr<base::SequencedTaskRunner> task_runner) {
+  scoped_ptr<AsyncPolicyLoader> loader(
+      new PolicyLoaderWin(task_runner, kRegistryChromePolicyKey, this));
   return new AsyncPolicyProvider(registry, loader.Pass());
 }
 
 void PRegTestHarness::InstallEmptyPolicy() {}
 
 void PRegTestHarness::InstallStringPolicy(const std::string& policy_name,
                                           const std::string& policy_value) {
   AppendStringToPRegFile(kRegistryChromePolicyKey, policy_name, policy_value);
 }
 
@@ skipping 249 matching lines @@
                GROUP_POLICY_OBJECT* next,
                GROUP_POLICY_OBJECT* prev) {
     memset(gpo, 0, sizeof(GROUP_POLICY_OBJECT));
     gpo->dwOptions = options;
     gpo->lpFileSysPath = const_cast<wchar_t*>(path.value().c_str());
     gpo->pNext = next;
     gpo->pPrev = prev;
   }
 
   bool Matches(const PolicyBundle& expected) {
-    PolicyLoaderWin loader(loop_.message_loop_proxy(),
-                           &test_policy_definitions::kList, kTestPolicyKey,
-                           this);
+    PolicyLoaderWin loader(loop_.message_loop_proxy(), kTestPolicyKey, this);
     scoped_ptr<PolicyBundle> loaded(
         loader.InitialLoad(schema_registry_.schema_map()));
     return loaded->Equals(expected);
   }
 
   void InstallRegistrySentinel() {
     RegKey hklm_key(HKEY_CURRENT_USER, kTestPolicyKey, KEY_ALL_ACCESS);
     ASSERT_TRUE(hklm_key.Valid());
     hklm_key.WriteValue(
-        UTF8ToUTF16(test_policy_definitions::kKeyString).c_str(),
+        UTF8ToUTF16(test_keys::kKeyString).c_str(),
         UTF8ToUTF16("registry").c_str());
   }
 
   bool MatchesRegistrySentinel() {
     base::DictionaryValue expected_policy;
-    expected_policy.SetString(test_policy_definitions::kKeyString, "registry");
+    expected_policy.SetString(test_keys::kKeyString, "registry");
     PolicyBundle expected;
     expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
     return Matches(expected);
   }
 
   bool MatchesTestBundle() {
     base::DictionaryValue expected_policy;
-    expected_policy.SetBoolean(test_policy_definitions::kKeyBoolean, true);
-    expected_policy.SetString(test_policy_definitions::kKeyString, "GPO");
-    expected_policy.SetInteger(test_policy_definitions::kKeyInteger, 42);
+    expected_policy.SetBoolean(test_keys::kKeyBoolean, true);
+    expected_policy.SetString(test_keys::kKeyString, "GPO");
+    expected_policy.SetInteger(test_keys::kKeyInteger, 42);
     scoped_ptr<base::ListValue> list(new base::ListValue());
     list->AppendString("GPO 1");
     list->AppendString("GPO 2");
-    expected_policy.Set(test_policy_definitions::kKeyStringList,
-                        list.release());
+    expected_policy.Set(test_keys::kKeyStringList, list.release());
     PolicyBundle expected;
     expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_MACHINE);
     return Matches(expected);
   }
 
   ScopedGroupPolicyRegistrySandbox registry_sandbox_;
   PGROUP_POLICY_OBJECT gpo_list_;
   DWORD gpo_list_status_;
   base::FilePath test_data_dir_;
 };
 
 const char16 PolicyLoaderWinTest::kTestPolicyKey[] =
     L"SOFTWARE\\Policies\\Chromium";
 
 TEST_F(PolicyLoaderWinTest, HKLMOverHKCU) {
   RegKey hklm_key(HKEY_LOCAL_MACHINE, kTestPolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(hklm_key.Valid());
-  hklm_key.WriteValue(UTF8ToUTF16(test_policy_definitions::kKeyString).c_str(),
+  hklm_key.WriteValue(UTF8ToUTF16(test_keys::kKeyString).c_str(),
                       UTF8ToUTF16("hklm").c_str());
   RegKey hkcu_key(HKEY_CURRENT_USER, kTestPolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(hkcu_key.Valid());
-  hkcu_key.WriteValue(UTF8ToUTF16(test_policy_definitions::kKeyString).c_str(),
+  hkcu_key.WriteValue(UTF8ToUTF16(test_keys::kKeyString).c_str(),
                       UTF8ToUTF16("hkcu").c_str());
 
   PolicyBundle expected;
   expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
-      .Set(test_policy_definitions::kKeyString,
+      .Set(test_keys::kKeyString,
            POLICY_LEVEL_MANDATORY,
            POLICY_SCOPE_MACHINE,
            base::Value::CreateStringValue("hklm"), NULL);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, Load3rdPartyWithoutSchema) {
   base::DictionaryValue dict;
   dict.SetString("str", "string value");
   dict.SetInteger("int", 123);
@@ skipping 298 matching lines @@
       .LoadFrom(&expected_a, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
   base::DictionaryValue expected_b;
   expected_b.SetInteger("policy 1", 2);
   expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
       .LoadFrom(&expected_b, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy