Change PolicyLoaderWin to load PReg files if possible.

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 "base/json/json_writer.h"
 #include "base/process.h"
@@ skipping 302 matching lines @@
 ConfigurationPolicyProvider* TestHarness::CreateProvider(
     const PolicyDefinitionList* policy_list) {
   scoped_ptr<AsyncPolicyLoader> loader(new PolicyLoaderWin(policy_list));
   return new AsyncPolicyProvider(loader.Pass());
 }
 
 void TestHarness::InstallEmptyPolicy() {}
 
 void TestHarness::InstallStringPolicy(const std::string& policy_name,
                                       const std::string& policy_value) {
-  RegKey key(hive_, kRegistryMandatorySubKey, KEY_ALL_ACCESS);
+  RegKey key(hive_, kRegistryChromePolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
   ASSERT_HRESULT_SUCCEEDED(key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
                                           UTF8ToUTF16(policy_value).c_str()));
 }
 
 void TestHarness::InstallIntegerPolicy(const std::string& policy_name,
                                        int policy_value) {
-  RegKey key(hive_, kRegistryMandatorySubKey, KEY_ALL_ACCESS);
+  RegKey key(hive_, kRegistryChromePolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
   key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
                  static_cast<DWORD>(policy_value));
 }
 
 void TestHarness::InstallBooleanPolicy(const std::string& policy_name,
                                        bool policy_value) {
-  RegKey key(hive_, kRegistryMandatorySubKey, KEY_ALL_ACCESS);
+  RegKey key(hive_, kRegistryChromePolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
   key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
                  static_cast<DWORD>(policy_value));
 }
 
 void TestHarness::InstallStringListPolicy(const std::string& policy_name,
                                           const base::ListValue* policy_value) {
   RegKey key(hive_,
-             (string16(kRegistryMandatorySubKey) + ASCIIToUTF16("\\") +
+             (string16(kRegistryChromePolicyKey) + ASCIIToUTF16("\\") +
               UTF8ToUTF16(policy_name)).c_str(),
              KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
   int index = 1;
   for (base::ListValue::const_iterator element(policy_value->begin());
        element != policy_value->end();
        ++element) {
     std::string element_value;
     if (!(*element)->GetAsString(&element_value))
       continue;
     std::string name(base::IntToString(index++));
     key.WriteValue(UTF8ToUTF16(name).c_str(),
                    UTF8ToUTF16(element_value).c_str());
   }
 }
 
 void TestHarness::InstallDictionaryPolicy(
     const std::string& policy_name,
     const base::DictionaryValue* policy_value) {
   std::string json;
   base::JSONWriter::Write(policy_value, &json);
-  RegKey key(hive_, kRegistryMandatorySubKey, KEY_ALL_ACCESS);
+  RegKey key(hive_, kRegistryChromePolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
   key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
                  UTF8ToUTF16(json).c_str());
 }
 
 void TestHarness::Install3rdPartyPolicy(const base::DictionaryValue* policies) {
   // The first level entries are domains, and the second level entries map
   // components to their policy.
-  const string16 kPathPrefix = string16(kRegistryMandatorySubKey) + kPathSep +
+  const string16 kPathPrefix = string16(kRegistryChromePolicyKey) + kPathSep +
                                kThirdParty + kPathSep;
   for (base::DictionaryValue::Iterator domain(*policies);
        domain.HasNext(); domain.Advance()) {
     const base::DictionaryValue* components = NULL;
     if (!domain.value().GetAsDictionary(&components)) {
       ADD_FAILURE();
       continue;
     }
     for (base::DictionaryValue::Iterator component(*components);
          component.HasNext(); component.Advance()) {
-      const string16 path = string16(kRegistryMandatorySubKey) + kPathSep +
+      const string16 path = string16(kRegistryChromePolicyKey) + kPathSep +
                             kThirdParty + kPathSep +
                             UTF8ToUTF16(domain.key()) + kPathSep +
                             UTF8ToUTF16(component.key());
       InstallValue(component.value(), hive_, path, kMandatory);
       EXPECT_TRUE(InstallSchema(component.value(), hive_, path, kSchema));
     }
   }
 }
 
 // static
@@ skipping 29 matching lines @@
   bool Matches(const PolicyBundle& expected) {
     PolicyLoaderWin loader(&test_policy_definitions::kList);
     scoped_ptr<PolicyBundle> loaded(loader.Load());
     return loaded->Equals(expected);
   }
 
   ScopedGroupPolicyRegistrySandbox registry_sandbox_;
 };
 
 TEST_F(PolicyLoaderWinTest, HKLMOverHKCU) {
-  RegKey hklm_key(HKEY_LOCAL_MACHINE, kRegistryMandatorySubKey, KEY_ALL_ACCESS);
+  RegKey hklm_key(HKEY_LOCAL_MACHINE, kRegistryChromePolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(hklm_key.Valid());
   hklm_key.WriteValue(UTF8ToUTF16(test_policy_definitions::kKeyString).c_str(),
                       UTF8ToUTF16("hklm").c_str());
-  RegKey hkcu_key(HKEY_CURRENT_USER, kRegistryMandatorySubKey, KEY_ALL_ACCESS);
+  RegKey hkcu_key(HKEY_CURRENT_USER, kRegistryChromePolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(hkcu_key.Valid());
   hkcu_key.WriteValue(UTF8ToUTF16(test_policy_definitions::kKeyString).c_str(),
                       UTF8ToUTF16("hkcu").c_str());
 
   PolicyBundle expected;
   expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(test_policy_definitions::kKeyString,
            POLICY_LEVEL_MANDATORY,
            POLICY_SCOPE_MACHINE,
            base::Value::CreateStringValue("hklm"));
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, Load3rdPartyWithoutSchema) {
   base::DictionaryValue dict;
   dict.SetString("str", "string value");
   dict.SetInteger("int", 123);
   dict.Set("subdict", dict.DeepCopy());
   dict.Set("subsubdict", dict.DeepCopy());
   dict.Set("subsubsubdict", dict.DeepCopy());
 
   base::DictionaryValue policy_dict;
   policy_dict.Set("extensions.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.policy",
                   dict.DeepCopy());
   policy_dict.Set("extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.policy",
                   dict.DeepCopy());
   EXPECT_TRUE(InstallValue(policy_dict, HKEY_LOCAL_MACHINE,
-                           kRegistryMandatorySubKey, kThirdParty));
+                           kRegistryChromePolicyKey, kThirdParty));
 
   PolicyBundle expected;
   expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
       .LoadFrom(&dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
   expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
       .LoadFrom(&dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, Merge3rdPartyPolicies) {
   // Policy for the same extension will be provided at the 4 level/scope
   // combinations, to verify that they overlap as expected.
 
   const string16 kPathSuffix =
-      kRegistryMandatorySubKey + ASCIIToUTF16("\\3rdparty\\extensions\\merge");
+      kRegistryChromePolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\merge");
 
   const char kUserMandatory[] = "user-mandatory";
   const char kUserRecommended[] = "user-recommended";
   const char kMachineMandatory[] = "machine-mandatory";
   const char kMachineRecommended[] = "machine-recommended";
 
   base::DictionaryValue policy;
   policy.SetString("a", kMachineMandatory);
   EXPECT_TRUE(InstallValue(policy, HKEY_LOCAL_MACHINE,
                            kPathSuffix, kMandatory));
@@ skipping 51 matching lines @@
   ASSERT_FALSE(encoded_list.empty());
   base::DictionaryValue encoded_policy;
   encoded_policy.SetString("null", "");
   encoded_policy.SetString("bool", "1");
   encoded_policy.SetString("int", "-123");
   encoded_policy.SetString("double", "456.78e9");
   encoded_policy.SetString("list", encoded_list);
   encoded_policy.SetString("dict", encoded_dict);
 
   const string16 kPathSuffix =
-      kRegistryMandatorySubKey + ASCIIToUTF16("\\3rdparty\\extensions\\string");
+      kRegistryChromePolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\string");
   EXPECT_TRUE(InstallSchema(policy, HKEY_CURRENT_USER, kPathSuffix, kSchema));
   EXPECT_TRUE(
       InstallValue(encoded_policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 
   PolicyBundle expected;
   expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "string"))
       .LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, LoadIntegerEncodedValues) {
   base::DictionaryValue policy;
   policy.SetBoolean("bool", true);
   policy.SetInteger("int", 123);
   policy.SetDouble("double", 456.0);
 
   base::DictionaryValue encoded_policy;
   encoded_policy.SetInteger("bool", 1);
   encoded_policy.SetInteger("int", 123);
   encoded_policy.SetInteger("double", 456);
 
   const string16 kPathSuffix =
-      kRegistryMandatorySubKey + ASCIIToUTF16("\\3rdparty\\extensions\\int");
+      kRegistryChromePolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\int");
   EXPECT_TRUE(InstallSchema(policy, HKEY_CURRENT_USER, kPathSuffix, kSchema));
   EXPECT_TRUE(
       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.
   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 schema;
   schema.SetString(schema::kType, "object");
   schema.Set(schema::kProperties, properties.DeepCopy());
   schema.Set(schema::kAdditionalProperties, default_schema.DeepCopy());
 
   const string16 kPathSuffix =
-      kRegistryMandatorySubKey + ASCIIToUTF16("\\3rdparty\\extensions\\test");
+      kRegistryChromePolicyKey + 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 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());
   PolicyBundle expected;
   expected.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "test"))
       .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy