policy: use JSON schema to deserialize entries from Windows registry.

chrome/browser/policy/configuration_policy_provider_test.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/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"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_bundle.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::Mock;
 using ::testing::_;
 
+namespace {
+// Builds a DictionaryValue for testing.
+// On Windows this matches the Chrome policy test schema.
+void BuildTestDictionaryValue(base::DictionaryValue& value) {
+  value.SetBoolean("bool", true);
+  value.SetInteger("int", 123);
+  value.SetString("str", "omg");
+
+  base::ListValue* list = new base::ListValue();
+  list->Set(0U, base::Value::CreateStringValue("first"));
+  list->Set(1U, base::Value::CreateStringValue("second"));
+  value.Set("list", list);
+
+  base::DictionaryValue* dict = new base::DictionaryValue();
+  dict->SetString("sub", "value");
+  list = new base::ListValue();
+  base::DictionaryValue* sub = new base::DictionaryValue();
+  sub->SetInteger("aaa", 111);
+  sub->SetInteger("bbb", 222);
+  list->Append(sub);
+  sub = new base::DictionaryValue();
+  sub->SetString("ccc", "333");
+  sub->SetString("ddd", "444");
+  list->Append(sub);
+  dict->Set("sublist", list);
+  value.Set("dict", dict);
+}
+}  // namespace
+
 namespace policy {
 
 namespace test_policy_definitions {
 
 const char kKeyString[] = "StringPolicy";
 const char kKeyBoolean[] = "BooleanPolicy";
 const char kKeyInteger[] = "IntegerPolicy";
 const char kKeyStringList[] = "StringListPolicy";
 const char kKeyDictionary[] = "DictionaryPolicy";
 
@@ skipping 132 matching lines @@
   CheckValue(test_policy_definitions::kKeyStringList,
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallStringListPolicy,
                         base::Unretained(test_harness_.get()),
                         test_policy_definitions::kKeyStringList,
                         &expected_value));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, DictionaryValue) {
   base::DictionaryValue expected_value;
-  expected_value.SetBoolean("bool", true);
-  expected_value.SetInteger("int", 123);
-  expected_value.SetString("str", "omg");
-
-  base::ListValue* list = new base::ListValue();
-  list->Set(0U, base::Value::CreateStringValue("first"));
-  list->Set(1U, base::Value::CreateStringValue("second"));
-  expected_value.Set("list", list);
-
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  dict->SetString("sub", "value");
-  list = new base::ListValue();
-  base::DictionaryValue* sub = new base::DictionaryValue();
-  sub->SetInteger("aaa", 111);
-  sub->SetInteger("bbb", 222);
-  list->Append(sub);
-  sub = new base::DictionaryValue();
-  sub->SetString("ccc", "333");
-  sub->SetString("ddd", "444");
-  list->Append(sub);
-  dict->Set("sublist", list);
-  expected_value.Set("dict", dict);
-
+  BuildTestDictionaryValue(expected_value);
   CheckValue(test_policy_definitions::kKeyDictionary,
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallDictionaryPolicy,
                         base::Unretained(test_harness_.get()),
                         test_policy_definitions::kKeyDictionary,
                         &expected_value));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, RefreshPolicies) {
   PolicyBundle bundle;
@@ skipping 65 matching lines @@
   provider.Shutdown();
 }
 
 Configuration3rdPartyPolicyProviderTest::
     Configuration3rdPartyPolicyProviderTest() {}
 
 Configuration3rdPartyPolicyProviderTest::
     ~Configuration3rdPartyPolicyProviderTest() {}
 
 TEST_P(Configuration3rdPartyPolicyProviderTest, Load3rdParty) {
+  // Install a Chrome policy.
+  base::DictionaryValue chrome_policy_dict;
+  BuildTestDictionaryValue(chrome_policy_dict);
+  test_harness_->InstallDictionaryPolicy(
+      test_policy_definitions::kKeyDictionary, &chrome_policy_dict);
+
+  // Install 3rd party policies.
   base::DictionaryValue policy_dict;
   policy_dict.SetBoolean("bool", true);
   policy_dict.SetDouble("double", 123.456);
   policy_dict.SetInteger("int", 789);
   policy_dict.SetString("str", "string value");
 
   base::ListValue* list = new base::ListValue();
   for (int i = 0; i < 2; ++i) {
     base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetInteger("subdictindex", i);
     dict->Set("subdict", policy_dict.DeepCopy());
     list->Append(dict);
   }
   policy_dict.Set("list", list);
   policy_dict.Set("dict", policy_dict.DeepCopy());
 
-  // Install these policies as a Chrome policy.
-  test_harness_->InstallDictionaryPolicy(
-      test_policy_definitions::kKeyDictionary, &policy_dict);
-  // Install them as 3rd party policies too.
   base::DictionaryValue policy_3rdparty;
   policy_3rdparty.Set("extensions.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                       policy_dict.DeepCopy());
   policy_3rdparty.Set("extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
                       policy_dict.DeepCopy());
   // Install invalid 3rd party policies that shouldn't be loaded. These also
   // help detecting memory leaks in the code paths that detect invalid input.
   policy_3rdparty.Set("invalid-domain.component", policy_dict.DeepCopy());
   policy_3rdparty.Set("extensions.cccccccccccccccccccccccccccccccc",
                       base::Value::CreateStringValue("invalid-value"));
   test_harness_->Install3rdPartyPolicy(&policy_3rdparty);
 
   provider_->RefreshPolicies();
   loop_.RunUntilIdle();
 
   PolicyMap expected_policy;
   expected_policy.Set(test_policy_definitions::kKeyDictionary,
                       test_harness_->policy_level(),
                       test_harness_->policy_scope(),
-                      policy_dict.DeepCopy(),
+                      chrome_policy_dict.DeepCopy(),
                       NULL);
   PolicyBundle expected_bundle;
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .CopyFrom(expected_policy);
   expected_policy.Clear();
   expected_policy.LoadFrom(&policy_dict,
                            test_harness_->policy_level(),
                            test_harness_->policy_scope());
   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