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

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 <windows.h>
 #include <userenv.h>
 
 #include <algorithm>
@@ skipping 1026 matching lines @@
       InstallValue(encoded_policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 
   PolicyBundle expected;
   expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "int"))
       .LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, DefaultPropertySchemaType) {
   // Build a schema for an "object" with a default schema for its properties.
+  // Note that the top-level object can't have "additionalProperties", so
+  // a "policy" property is used instead.
   base::DictionaryValue default_schema;
   default_schema.SetString(schema::kType, "number");
   base::DictionaryValue integer_schema;
   integer_schema.SetString(schema::kType, "integer");
-  base::DictionaryValue properties;
-  properties.Set("special-int1", integer_schema.DeepCopy());
-  properties.Set("special-int2", integer_schema.DeepCopy());
+  base::DictionaryValue policy_properties;
+  policy_properties.Set("special-int1", integer_schema.DeepCopy());
+  policy_properties.Set("special-int2", integer_schema.DeepCopy());
+  base::DictionaryValue policy_schema;
+  policy_schema.SetString(schema::kType, "object");
+  policy_schema.Set(schema::kProperties, policy_properties.DeepCopy());
+  policy_schema.Set(schema::kAdditionalProperties, default_schema.DeepCopy());
+  base::DictionaryValue schema_properties;
+  schema_properties.Set("policy", policy_schema.DeepCopy());
   base::DictionaryValue schema;
   schema.SetString(schema::kType, "object");
-  schema.Set(schema::kProperties, properties.DeepCopy());
-  schema.Set(schema::kAdditionalProperties, default_schema.DeepCopy());
+  schema.Set(schema::kProperties, schema_properties.DeepCopy());
 
   const string16 kPathSuffix =
       kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\test");
   EXPECT_TRUE(WriteSchema(schema, HKEY_CURRENT_USER, kPathSuffix, kSchema));
 
   // Write some test values.
   base::DictionaryValue policy;
   // These special values have a specific schema for them.
   policy.SetInteger("special-int1", 123);
   policy.SetString("special-int2", "-456");
   // Other values default to be loaded as doubles.
   policy.SetInteger("double1", 789.0);
   policy.SetString("double2", "123.456e7");
   policy.SetString("invalid", "omg");
-  EXPECT_TRUE(InstallValue(policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
+  base::DictionaryValue all_policies;
+  all_policies.Set("policy", policy.DeepCopy());
+  EXPECT_TRUE(
+      InstallValue(all_policies, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 
   base::DictionaryValue expected_policy;
   expected_policy.SetInteger("special-int1", 123);
   expected_policy.SetInteger("special-int2", -456);
   expected_policy.SetDouble("double1", 789.0);
   expected_policy.SetDouble("double2", 123.456e7);
   expected_policy.Set("invalid", base::Value::CreateNullValue());
+  base::DictionaryValue expected_policies;
+  expected_policies.Set("policy", expected_policy.DeepCopy());
   PolicyBundle expected;
   expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "test"))
-      .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+      .LoadFrom(&expected_policies, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, AppliedPolicyNotPresent) {
   InstallRegistrySentinel();
   gpo_list_ = NULL;
   gpo_list_status_ = ERROR_SUCCESS;
 
   PolicyBundle empty;
   EXPECT_TRUE(Matches(empty));
@@ skipping 116 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