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 "policy/policy_constants.h"
 
 using base::win::RegKey;
 using base::win::RegistryKeyIterator;
 using base::win::RegistryValueIterator;
+using namespace json_schema_constants;

[Aaron Boodman, 2012/08/10 19:30:23]

If you end up sticking with the approach you have:

We don't typically include entire namespace this way because it makes it hard to
find where symbols come from.

Instead, how about:

namespace json_schema = json_schema_constants. Or just bite the bullet and type
it out each time :)

[Joao da Silva, 2012/09/05 14:03:29]

Just went for this one. It's a bit extra typing but still better than typing the
full JSONSchemaValidator:: or json_schema_constants::. wdyt?

 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 161 matching lines @@
   RegKey key;
   if (!LoadHighestPriorityKey(string16(), name, &key, level, scope))
     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,

[Aaron Boodman, 2012/08/10 19:30:23]

We already have JSONSchemaValidator::GetJSONSchemaType. Why is it insufficient?
Can it be improved?

[Joao da Silva, 2012/09/05 14:03:29]

JSONSchemaValidator::GetJSONSchemaType does Value->Schema and this does the
inverse, Schema->Value.

[Aaron Boodman, 2012/09/11 22:32:39]

Just add it to JSONSchemaValidator then. I feel like it's better to encapsulate
this knowledge there rather than put it in this leaf.

[Joao da Silva, 2012/09/12 16:09:39]

Done.

                           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     },
@@ skipping 442 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