Share JSON schema constants.

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/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.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/policy_bundle.h"
 #include "chrome/browser/policy/policy_map.h"
+#include "chrome/common/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;
 using namespace policy::registry_constants;
 
 namespace policy {
 
 namespace {
 
 const wchar_t kUnitTestRegistrySubKey[] = L"SOFTWARE\\Chromium Unit Tests";
 const wchar_t kUnitTestMachineOverrideSubKey[] =
     L"SOFTWARE\\Chromium Unit Tests\\HKLM Override";
@@ skipping 80 matching lines @@
   NOTREACHED();
   return false;
 }
 
 // Builds a JSON schema that represents the types contained in |value|.
 // Ownership is transferred to the caller.
 base::DictionaryValue* BuildSchema(const base::Value& value) {
   base::DictionaryValue* schema = new base::DictionaryValue();
   switch (value.GetType()) {
     case base::Value::TYPE_NULL:
-      schema->SetString(kType, "null");
+      schema->SetString(schema::kType, "null");
       break;
     case base::Value::TYPE_BOOLEAN:
-      schema->SetString(kType, "boolean");
+      schema->SetString(schema::kType, "boolean");
       break;
     case base::Value::TYPE_INTEGER:
-      schema->SetString(kType, "integer");
+      schema->SetString(schema::kType, "integer");
       break;
     case base::Value::TYPE_DOUBLE:
-      schema->SetString(kType, "number");
+      schema->SetString(schema::kType, "number");
       break;
     case base::Value::TYPE_STRING:
-      schema->SetString(kType, "string");
+      schema->SetString(schema::kType, "string");
       break;
 
     case base::Value::TYPE_LIST: {
       // Assumes every list element has the same type.
       const base::ListValue* list = NULL;
       if (value.GetAsList(&list) && !list->empty()) {
-        schema->SetString(kType, "array");
-        schema->Set(kItems, BuildSchema(**list->begin()));
+        schema->SetString(schema::kType, "array");
+        schema->Set(schema::kItems, BuildSchema(**list->begin()));
       }
       break;
     }
 
     case base::Value::TYPE_DICTIONARY: {
       const base::DictionaryValue* dict = NULL;
       if (value.GetAsDictionary(&dict)) {
         base::DictionaryValue* properties = new base::DictionaryValue();
         for (base::DictionaryValue::Iterator it(*dict);
              it.HasNext(); it.Advance()) {
           properties->Set(it.key(), BuildSchema(it.value()));
         }
-        schema->SetString(kType, "object");
-        schema->Set(kProperties, properties);
+        schema->SetString(schema::kType, "object");
+        schema->Set(schema::kProperties, properties);
       }
       break;
     }
 
     case base::Value::TYPE_BINARY:
       break;
   }
   return schema;
 }
 
@@ skipping 402 matching lines @@
 
   PolicyBundle expected;
   expected.Get(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(kType, "number");
+  default_schema.SetString(schema::kType, "number");
   base::DictionaryValue integer_schema;
-  integer_schema.SetString(kType, "integer");
+  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(kType, "object");
-  schema.Set(kProperties, properties.DeepCopy());
-  schema.Set(kAdditionalProperties, default_schema.DeepCopy());
+  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");
   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);
   PolicyBundle expected;
   expected.Get(POLICY_DOMAIN_EXTENSIONS, "test")
       .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy