Use schemas bundled in extensions to convert policies loaded on Windows.

components/policy/core/common/configuration_policy_provider_test.cc

 // Copyright 2013 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/configuration_policy_provider_test.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/values.h"
@@ skipping 108 matching lines @@
 const char kKeyStringList[] = "StringListPolicy";
 const char kKeyDictionary[] = "DictionaryPolicy";
 
 }  // namespace test_keys
 
 PolicyTestBase::PolicyTestBase() {}
 
 PolicyTestBase::~PolicyTestBase() {}
 
 void PolicyTestBase::SetUp() {
-  std::string error;
-  chrome_schema_ = Schema::Parse(kTestChromeSchema, &error);
-  ASSERT_TRUE(chrome_schema_.valid()) << error;
-  schema_registry_.RegisterComponent(PolicyNamespace(POLICY_DOMAIN_CHROME, ""),
-                                     chrome_schema_);
+  const PolicyNamespace ns(POLICY_DOMAIN_CHROME, "");
+  ASSERT_TRUE(RegisterSchema(ns, kTestChromeSchema));
 }
 
 void PolicyTestBase::TearDown() {
   loop_.RunUntilIdle();
 }
 
+bool PolicyTestBase::RegisterSchema(const PolicyNamespace& ns,
+                                    const std::string& schema_string) {
+  std::string error;
+  Schema schema = Schema::Parse(schema_string, &error);
+  if (schema.valid()) {
+    schema_registry_.RegisterComponent(ns, schema);
+    return true;
+  }
+  ADD_FAILURE() << error;
+  return false;
+}
+
 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_;
 }
 
 void PolicyProviderTestHarness::Install3rdPartyPolicy(
     const base::DictionaryValue* policies) {
   FAIL();
 }
 
 ConfigurationPolicyProviderTest::ConfigurationPolicyProviderTest() {}
 
 ConfigurationPolicyProviderTest::~ConfigurationPolicyProviderTest() {}
 
 void ConfigurationPolicyProviderTest::SetUp() {
   PolicyTestBase::SetUp();
 
   test_harness_.reset((*GetParam())());
   test_harness_->SetUp();
 
+  const PolicyNamespace chrome_ns(POLICY_DOMAIN_CHROME, "");
+  Schema chrome_schema = *schema_registry_.schema_map()->GetSchema(chrome_ns);
   Schema extension_schema =
-      chrome_schema_.GetKnownProperty(test_keys::kKeyDictionary);
+      chrome_schema.GetKnownProperty(test_keys::kKeyDictionary);
   ASSERT_TRUE(extension_schema.valid());
   schema_registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
       extension_schema);
   schema_registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
       extension_schema);
   schema_registry_.RegisterComponent(
@@ skipping 213 matching lines @@
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
       .CopyFrom(expected_policy);
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
       .CopyFrom(expected_policy);
   EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
 }
 
 }  // namespace policy