Share JSON schema constants.

chrome/browser/policy/policy_loader_win.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 <string>
 
 #include <string.h>
 
 #include <userenv.h>
 
 // userenv.dll is required for RegisterGPNotification().
 #pragma comment(lib, "userenv.lib")
 
 #include "base/basictypes.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/win/registry.h"
 #include "chrome/browser/policy/policy_bundle.h"
 #include "chrome/browser/policy/policy_map.h"
+#include "chrome/common/json_schema_constants.h"
+#include "chrome/common/json_schema_validator.h"
 #include "policy/policy_constants.h"
 
+namespace schema = json_schema_constants;
+
 using base::win::RegKey;
 using base::win::RegistryKeyIterator;
 using base::win::RegistryValueIterator;
 using namespace policy::registry_constants;
 
 namespace policy {
 
 namespace registry_constants {
   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";
-  const char kType[] = "type";
-  const char kProperties[] = "properties";
-  const char kAdditionalProperties[] = "additionalProperties";
-  const char kItems[] = "items";
 }  // namespace registry_constants
 
 namespace {
 
 // Map of registry hives to their corresponding policy scope, in decreasing
 // order of priority.
 const struct {
   HKEY hive;
   PolicyScope scope;
 } kHives[] = {
@@ skipping 164 matching lines @@
     return NULL;
   string16 value;
   if (!ReadRegistryString(&key, name, &value))
     return NULL;
   return base::JSONReader::Read(UTF16ToUTF8(value));
 }
 
 // Returns the Value type described in |schema|, or |default_type| if not found.
 base::Value::Type GetType(const base::DictionaryValue* schema,
                           base::Value::Type default_type) {
-  // JSON-schema types to base::Value::Type mapping.
-  static const struct {
-    // JSON schema type.
-    const char* schema_type;
-    // Correspondent value type.
-    base::Value::Type value_type;
-  } kSchemaToValueTypeMap[] = {
-    { "array",        base::Value::TYPE_LIST        },
-    { "boolean",      base::Value::TYPE_BOOLEAN     },
-    { "integer",      base::Value::TYPE_INTEGER     },
-    { "null",         base::Value::TYPE_NULL        },
-    { "number",       base::Value::TYPE_DOUBLE      },
-    { "object",       base::Value::TYPE_DICTIONARY  },
-    { "string",       base::Value::TYPE_STRING      },
-  };
-
-  if (!schema)
-    return default_type;
-  std::string type;
-  if (!schema->GetString(kType, &type))
-    return default_type;
-  for (size_t i = 0; i < arraysize(kSchemaToValueTypeMap); ++i) {
-    if (type == kSchemaToValueTypeMap[i].schema_type)
-      return kSchemaToValueTypeMap[i].value_type;
+  std::string schema_type;
+  base::Value::Type value_type;
+  if (schema &&
+      schema->GetString(schema::kType, &schema_type) &&
+      JSONSchemaValidator::GetValueType(schema_type, &value_type)) {
+    return value_type;
   }
   return default_type;
 }
 
 // Returns the default type for registry entries of |reg_type|, when there is
 // no schema defined type for a policy.
 base::Value::Type GetDefaultFor(DWORD reg_type) {
   return reg_type == REG_DWORD ? base::Value::TYPE_INTEGER :
                                  base::Value::TYPE_STRING;
 }
 
 // Returns the entry with key |name| in |dictionary| (can be NULL), or NULL.
 const base::DictionaryValue* GetEntry(const base::DictionaryValue* dictionary,
                                 const std::string& name) {
   if (!dictionary)
     return NULL;
   const base::DictionaryValue* entry = NULL;
   dictionary->GetDictionary(name, &entry);
   return entry;
 }
 
 // Returns the schema for property |name| given the |schema| of an object.
 // Returns the "additionalProperties" schema if no specific schema for
 // |name| is present. Returns NULL if no schema is found.
 const base::DictionaryValue* GetSchemaFor(const base::DictionaryValue* schema,
                                     const std::string& name) {
-  const base::DictionaryValue* properties = GetEntry(schema, kProperties);
+  const base::DictionaryValue* properties =
+      GetEntry(schema, schema::kProperties);
   const base::DictionaryValue* sub_schema = GetEntry(properties, name);
   if (sub_schema)
     return sub_schema;
   // "additionalProperties" can be a boolean, but that case is ignored.
-  return GetEntry(schema, kAdditionalProperties);
+  return GetEntry(schema, schema::kAdditionalProperties);
 }
 
 // Converts string |value| to another |type|, if possible.
 base::Value* ConvertComponentStringValue(const string16& value,
                                          base::Value::Type type) {
   switch (type) {
     case base::Value::TYPE_NULL:
       return base::Value::CreateNullValue();
 
     case base::Value::TYPE_BOOLEAN: {
@@ skipping 102 matching lines @@
                                         const base::DictionaryValue* schema) {
   // The sub-elements are indexed from 1 to N. They can be represented as
   // registry values or registry keys though; use |schema| first to try to
   // determine the right type, and if that fails default to STRING.
 
   RegKey key(hive, path.c_str(), KEY_READ);
   if (!key.Valid())
     return NULL;
 
   // Get the schema for list items.
-  schema = GetEntry(schema, kItems);
+  schema = GetEntry(schema, schema::kItems);
   base::Value::Type type = GetType(schema, base::Value::TYPE_STRING);
   base::ListValue* list = new base::ListValue();
   for (int i = 1; ; ++i) {
     string16 name = base::IntToString16(i);
     base::Value* value = NULL;
     if (type == base::Value::TYPE_DICTIONARY) {
       value =
           ReadComponentDictionaryValue(hive, path + kPathSep + name, schema);
     } else if (type == base::Value::TYPE_LIST) {
       value = ReadComponentListValue(hive, path + kPathSep + name, schema);
@@ skipping 264 matching lines @@
 
 void PolicyLoaderWin::OnObjectSignaled(HANDLE object) {
   DCHECK(object == user_policy_changed_event_.handle() ||
          object == machine_policy_changed_event_.handle())
       << "unexpected object signaled policy reload, obj = "
       << std::showbase << std::hex << object;
   Reload(false);
 }
 
 }  // namespace policy