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

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 14 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/win/registry.h"
 #include "chrome/browser/policy/async_policy_provider.h"
 #include "chrome/browser/policy/configuration_policy_provider_test.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/policy_bundle.h"
+#include "chrome/browser/policy/policy_domain_descriptor.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/preg_parser_win.h"
 #include "components/json_schema/json_schema_constants.h"
 #include "policy/policy_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace schema = json_schema_constants;
 
 using base::win::RegKey;
 
 namespace policy {
 
 namespace {
 
 // Constants for registry key names.
 const wchar_t kPathSep[] = L"\\";
 const wchar_t kThirdParty[] = L"3rdparty";
 const wchar_t kMandatory[] = L"policy";
 const wchar_t kRecommended[] = L"recommended";
 const wchar_t kSchema[] = L"schema";
 
+void InstallTestChromePolicySchema(AsyncPolicyLoader* loader) {
+  std::string err = "";
+  scoped_ptr<PolicySchema> schema = PolicySchema::Parse(
+      "{"
+      "  \"$schema\": \"http://json-schema.org/draft-03/schema#\","
+      "  \"type\": \"object\","
+      "  \"properties\": {"
+      "    \"BooleanPolicy\": { \"type\": \"boolean\" },"
+      "    \"IntegerPolicy\": { \"type\": \"integer\" },"
+      "    \"StringListPolicy\": {"
+      "      \"type\": \"array\","
+      "      \"items\": { \"type\": \"string\" } "
+      "    },"
+      "    \"StringPolicy\": { \"type\": \"string\" },"
+      "    \"DictionaryPolicy\": {"
+      "      \"type\": \"object\", "
+      "      \"properties\": {"
+      "        \"int\": {"
+      "          \"type\": \"integer\""
+      "        }, "
+      "        \"list\": {"
+      "          \"items\": {"
+      "            \"type\": \"string\""
+      "          }, "
+      "          \"type\": \"array\""
+      "        }, "
+      "        \"bool\": {"
+      "          \"type\": \"boolean\""
+      "        }, "
+      "        \"str\": {"
+      "          \"type\": \"string\""
+      "        }, "
+      "        \"dict\": {"
+      "          \"type\": \"object\", "
+      "          \"properties\": {"
+      "            \"sub\": {"
+      "              \"type\": \"string\""
+      "            }, "
+      "            \"sublist\": {"
+      "              \"items\": {"
+      "                \"type\": \"object\", "
+      "                \"properties\": {"
+      "                  \"aaa\": {"
+      "                    \"type\": \"integer\""
+      "                  }, "
+      "                  \"bbb\": {"
+      "                    \"type\": \"integer\""
+      "                  }, "
+      "                  \"ccc\": {"
+      "                    \"type\": \"string\""
+      "                  }, "
+      "                  \"ddd\": {"
+      "                    \"type\": \"string\""
+      "                  }"
+      "                }"
+      "              }, "
+      "              \"type\": \"array\""
+      "            }"
+      "          }"
+      "        }"
+      "      }"
+      "    }"
+      "  }"
+      "}",
+    &err);
+  CHECK("" == err) << err;
+  scoped_refptr<PolicyDomainDescriptor> descriptor =
+      new PolicyDomainDescriptor(POLICY_DOMAIN_CHROME);
+  descriptor->RegisterComponent("", schema.Pass());
+  loader->InitialRegisterPolicyDomain(descriptor);
+}
+
 // Installs |value| in the given registry |path| and |hive|, under the key
 // |name|. Returns false on errors.
 // Some of the possible Value types are stored after a conversion (e.g. doubles
 // are stored as strings), and can only be retrieved if a corresponding schema
 // is written.
 bool InstallValue(const base::Value& value,
                   HKEY hive,
                   const string16& path,
                   const string16& name) {
   // KEY_ALL_ACCESS causes the ctor to create the key if it does not exist yet.
@@ skipping 110 matching lines @@
         }
         schema->SetString(schema::kType, "object");
         schema->Set(schema::kProperties, properties);
       }
       break;
     }
 
     case base::Value::TYPE_BINARY:
       break;
   }
+  schema->SetString(schema::kSchema, "http://json-schema.org/draft-03/schema#");
   return schema;
 }
 
 // Writes a JSON |schema| at the registry entry |name| at |path|
 // in the given |hive|. Returns false on failure.
 bool WriteSchema(const base::DictionaryValue& schema,
                  HKEY hive,
                  const string16& path,
                  const string16& name) {
   std::string encoded;
@@ skipping 10 matching lines @@
 // Builds a JSON schema for |value| and writes it at the registry entry |name|
 // at |path| in the given |hive|. Returns false on failure.
 bool InstallSchema(const base::Value& value,
                    HKEY hive,
                    const string16& path,
                    const string16& name) {
   scoped_ptr<base::DictionaryValue> schema_dict(BuildSchema(value));
   return WriteSchema(*schema_dict, hive, path, name);
 }
 
+void DoNothing(scoped_ptr<PolicyBundle> bundle) {
+}
+
 // This class provides sandboxing and mocking for the parts of the Windows
 // Registry implementing Group Policy. It prepares two temporary sandbox keys,
 // one for HKLM and one for HKCU. A test's calls to the registry are redirected
 // by Windows to these sandboxes, allowing the tests to manipulate and access
 // policy as if it were active, but without actually changing the parts of the
 // Registry that are managed by Group Policy.
 class ScopedGroupPolicyRegistrySandbox {
  public:
   ScopedGroupPolicyRegistrySandbox();
   ~ScopedGroupPolicyRegistrySandbox();
@@ skipping 191 matching lines @@
 
 RegistryTestHarness::~RegistryTestHarness() {}
 
 void RegistryTestHarness::SetUp() {}
 
 ConfigurationPolicyProvider* RegistryTestHarness::CreateProvider(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     const PolicyDefinitionList* policy_list) {
   scoped_ptr<AsyncPolicyLoader> loader(new PolicyLoaderWin(
       task_runner, policy_list, kRegistryChromePolicyKey, this));
+  InstallTestChromePolicySchema(loader.get());
   return new AsyncPolicyProvider(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());
@@ skipping 112 matching lines @@
 
   memset(&gpo_, 0, sizeof(GROUP_POLICY_OBJECT));
   gpo_.lpFileSysPath = const_cast<wchar_t*>(temp_dir_.path().value().c_str());
 }
 
 ConfigurationPolicyProvider* PRegTestHarness::CreateProvider(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     const PolicyDefinitionList* policy_list) {
   scoped_ptr<AsyncPolicyLoader> loader(new PolicyLoaderWin(
       task_runner, policy_list, kRegistryChromePolicyKey, this));
+  InstallTestChromePolicySchema(loader.get());
   return new AsyncPolicyProvider(loader.Pass());
 }
 
 void PRegTestHarness::InstallEmptyPolicy() {}
 
 void PRegTestHarness::InstallStringPolicy(const std::string& policy_name,
                                           const std::string& policy_value) {
   AppendStringToPRegFile(kRegistryChromePolicyKey, policy_name, policy_value);
 }
 
@@ skipping 250 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);
+    InstallTestChromePolicySchema(&loader);
+    loader.Init(base::Bind(&DoNothing));
     scoped_ptr<PolicyBundle> loaded(loader.Load());
     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 184 matching lines @@
   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 =
-      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 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));
-}
-
 TEST_F(PolicyLoaderWinTest, AppliedPolicyNotPresent) {
   InstallRegistrySentinel();
   gpo_list_ = NULL;
   gpo_list_status_ = ERROR_SUCCESS;
 
   PolicyBundle empty;
   EXPECT_TRUE(Matches(empty));
 }
 
 TEST_F(PolicyLoaderWinTest, AppliedPolicyEmpty) {
@@ skipping 113 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