Policy providers all get a SchemaRegistry to work with.

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 234 matching lines @@
 class RegistryTestHarness : public PolicyProviderTestHarness,
                             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;
 
   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;
@@ skipping 31 matching lines @@
 class PRegTestHarness : public PolicyProviderTestHarness,
                         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;
 
   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;
@@ skipping 97 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));
-  return new AsyncPolicyProvider(loader.Pass());
+  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());
   ASSERT_HRESULT_SUCCEEDED(key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
@@ skipping 107 matching lines @@
   preg_file_path_ = temp_dir_.path().Append(PolicyLoaderWin::kPRegFileName);
   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));
-  return new AsyncPolicyProvider(loader.Pass());
+  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);
 }
 
 void PRegTestHarness::InstallIntegerPolicy(const std::string& policy_name,
@@ skipping 212 matching lines @@
   // The policy key this tests places data under. This must match the data
   // files in chrome/test/data/policy/gpo.
   static const char16 kTestPolicyKey[];
 
   PolicyLoaderWinTest()
       : gpo_list_(NULL),
         gpo_list_status_(ERROR_ACCESS_DENIED) {}
   virtual ~PolicyLoaderWinTest() {}
 
   virtual void SetUp() OVERRIDE {
+    PolicyTestBase::SetUp();
+
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir_));
     test_data_dir_ = test_data_dir_.AppendASCII("chrome")
                                    .AppendASCII("test")
                                    .AppendASCII("data")
                                    .AppendASCII("policy")
                                    .AppendASCII("gpo");
   }
 
   // AppliedGPOListProvider:
   virtual DWORD GetAppliedGPOList(DWORD flags,
@@ skipping 17 matching lines @@
     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);
-    scoped_ptr<PolicyBundle> loaded(loader.Load());
+    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("registry").c_str());
   }
@@ skipping 357 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