Generate the Chrome policy schema at compile time.

chrome/tools/build/generate_policy_source.py

 #!/usr/bin/env python
 # 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.
 
 '''python %prog [options] platform chromium_os_flag template
 
 platform specifies which platform source is being generated for
   and can be one of (win, mac, linux)
 chromium_os_flag should be 1 if this is a Chromium OS build
@@ skipping 35 matching lines @@
   class EnumItem:
     def __init__(self, item):
       self.caption = PolicyDetails._RemovePlaceholders(item['caption'])
       self.value = item['value']
 
   def __init__(self, policy, os, is_chromium_os):
     self.id = policy['id']
     self.name = policy['name']
     self.is_deprecated = policy.get('deprecated', False)
     self.is_device_only = policy.get('device_only', False)
+    self.schema = policy.get('schema', {})
 
     if is_chromium_os:
       expected_platform = 'chrome_os'
     else:
       expected_platform = os.lower()
 
     self.platforms = []
     for platform, version in [ p.split(':') for p in policy['supported_on'] ]:
       if not version.endswith('-'):
         continue
@@ skipping 143 matching lines @@
 
 def _WritePolicyConstantHeader(policies, os, f):
   f.write('#ifndef CHROME_COMMON_POLICY_CONSTANTS_H_\n'
           '#define CHROME_COMMON_POLICY_CONSTANTS_H_\n'
           '\n'
           '#include <string>\n'
           '\n'
           '#include "base/basictypes.h"\n'
           '#include "base/values.h"\n'
           '\n'
-          'namespace policy {\n\n')
+          'namespace policy {\n'
+          '\n'
+          'namespace internal {\n'
+          'struct SchemaNode;\n'
+          '}\n\n')
 
   if os == 'win':
     f.write('// The windows registry path where Chrome policy '
             'configuration resides.\n'
             'extern const wchar_t kRegistryChromePolicyKey[];\n')
 
   f.write('// Lists metadata such as name, expected type and id for all\n'
           '// policies. Used to initialize ConfigurationPolicyProviders and\n'
           '// CloudExternalDataManagers.\n'
           'struct PolicyDefinitionList {\n'
           '  struct Entry {\n'
           '    const char* name;\n'
           '    base::Value::Type value_type;\n'
           '    bool device_policy;\n'
           '    int id;\n'
           '    size_t max_external_data_size;\n'
           '  };\n'
           '\n'
           '  const Entry* begin;\n'
           '  const Entry* end;\n'
           '};\n'
           '\n'
           '// Returns true if the given policy is deprecated.\n'
           'bool IsDeprecatedPolicy(const std::string& policy);\n'
           '\n'
           '// Returns the default policy definition list for Chrome.\n'
-          'const PolicyDefinitionList* GetChromePolicyDefinitionList();\n\n')
+          'const PolicyDefinitionList* GetChromePolicyDefinitionList();\n'
+          '\n'
+          '// Returns the root node of the Chrome policy schema.\n'
+          'const internal::SchemaNode* GetChromeSchemaNode();\n'
+          '\n')
   f.write('// Key names for the policy settings.\n'
           'namespace key {\n\n')
   for policy in policies:
     # TODO(joaodasilva): Include only supported policies in
     # configuration_policy_handler.cc and configuration_policy_handler_list.cc
     # so that these names can be conditional on 'policy.is_supported'.
     # http://crbug.com/223616
     f.write('extern const char k' + policy.name + '[];\n')
   f.write('\n}  // namespace key\n\n'
           '}  // namespace policy\n\n'
           '#endif  // CHROME_COMMON_POLICY_CONSTANTS_H_\n')
 
 
 #------------------ policy constants source ------------------------#
 
 def _GetValueType(policy_type):
   return policy_type if policy_type != 'TYPE_EXTERNAL' else 'TYPE_DICTIONARY'
 
 
+# Map simple schema types to the address of a static SchemaNode that
+# represents that type.
+SIMPLE_SCHEMA_NAME_MAP = {
+  'boolean': '&kSchema_boolean',
+  'integer': '&kSchema_integer',
+  'null'   : '&kSchema_null',
+  'number' : '&kSchema_number',
+  'string' : '&kSchema_string',
+}
+
+
+# Generates SchemaNodes, PropertyNodes and PropertiesNodes for |schema| and
+# its sub-schemas, and writes them to |f|.
+# |prefix| is prepended to the generated variable names.
+# |shared_keys_map| is optional. If present, then property names are looked up
+# there to reuse shared strings. Otherwise a new static C string is generated.
+# Returns an expression that evaluates to a SchemaNode*.
+def _GenerateSchema(f, schema, prefix, shared_keys_map={}):
+  # Simple types use the shared structures.
+  if schema['type'] in SIMPLE_SCHEMA_NAME_MAP:
+    return SIMPLE_SCHEMA_NAME_MAP[schema['type']]
+
+  if schema['type'] == 'array':
+    # Special case for lists of strings, which is a common policy type.
+    if schema['items']['type'] == 'string':
+      return '&kSchema_stringlist'
+    value_type = 'TYPE_LIST'
+    extra = _GenerateSchema(f, schema['items'], prefix + '_items')
+  elif schema['type'] == 'object':
+    value_type = 'TYPE_DICTIONARY'
+
+    if 'additionalProperties' in schema:
+      additionalProperties = _GenerateSchema(
+          f, schema['additionalProperties'], prefix + '_additionalProperties')
+    else:
+      additionalProperties = 'NULL'
+
+    properties = []
+    sorted_properties = sorted(schema.get('properties', {}).items())
+    for property_name, property_schema in sorted_properties:
+      schema_ptr = _GenerateSchema(
+          f, property_schema, prefix + '_property_' + property_name)
+      properties.append((property_name, schema_ptr))
+
+    f.write('const PropertyNode %s_propertyNodes[] = {\n' % prefix)
+    for key, ptr in properties:
+      f.write('  { %s, %s },\n' % (shared_keys_map.get(key, '"%s"' % key), ptr))
+    f.write('};\n\n')
+
+    f.write('const PropertiesNode %s_properties = {\n'
+            '  %s_propertyNodes,\n'
+            '  %s_propertyNodes + ARRAYSIZE_UNSAFE(%s_propertyNodes),\n'
+            '  %s,\n'
+            '};\n\n' % (prefix, prefix, prefix, prefix, additionalProperties))
+
+    extra = '&%s_properties' % prefix
+
+  f.write('const SchemaNode %s = {\n'
+          '  base::Value::%s,\n'
+          '  %s,\n'
+          '};\n\n' % (prefix, value_type, extra))
+
+  return '&%s' % prefix
+
+
 def _WritePolicyConstantSource(policies, os, f):
   f.write('#include "base/basictypes.h"\n'
           '#include "base/logging.h"\n'
+          '#include "components/policy/core/common/schema_internal.h"\n'
           '#include "policy/policy_constants.h"\n'
           '\n'
           'namespace policy {\n\n')
 
   f.write('namespace {\n\n')
 
   f.write('const PolicyDefinitionList::Entry kEntries[] = {\n')
   for policy in policies:
     if policy.is_supported:
       f.write('  { key::k%s, base::Value::%s, %s, %s, %s },\n' %
@@ skipping 13 matching lines @@
   if has_deprecated_policies:
     f.write('// List of deprecated policies.\n'
             'const char* kDeprecatedPolicyList[] = {\n')
     for policy in policies:
       if policy.is_supported and policy.is_deprecated:
         f.write('  key::k%s,\n' % policy.name)
     f.write('};\n\n')
 
   f.write('}  // namespace\n\n')
 
+  f.write('namespace internal {\n'
+          'namespace {\n\n')
+
+  # Write shared SchemaNodes for the simple types, and the string list.
+  for node in [ ('boolean',    'BOOLEAN', 'NULL'),
+                ('integer',    'INTEGER', 'NULL'),
+                ('null',       'NULL',    'NULL'),
+                ('number',     'DOUBLE',  'NULL'),
+                ('string',     'STRING',  'NULL'),
+                ('stringlist', 'LIST',    '&kSchema_string') ]:
+    f.write('const SchemaNode kSchema_%s = {\n'
+            '  base::Value::TYPE_%s,\n'
+            '  %s,\n'
+            '};\n\n' % node)
+
+  # Generate the Chrome schema.
+  chrome_schema = {
+    'type': 'object',
+    'properties': {},
+  }
+  shared_keys_map = {}
+  for policy in policies:
+    if policy.is_supported:
+      chrome_schema['properties'][policy.name] = policy.schema
+      shared_keys_map[policy.name] = 'key::k%s' % policy.name
+
+  # And write it.
+  _GenerateSchema(f, chrome_schema, 'kSchema', shared_keys_map)
+
+  f.write('}  // namespace\n'
+          '}  // namespace internal\n\n')
+
   if os == 'win':
     f.write('#if defined(GOOGLE_CHROME_BUILD)\n'
             'const wchar_t kRegistryChromePolicyKey[] = '
             'L"' + CHROME_POLICY_KEY + '";\n'
             '#else\n'
             'const wchar_t kRegistryChromePolicyKey[] = '
             'L"' + CHROMIUM_POLICY_KEY + '";\n'
             '#endif\n\n')
 
   f.write('bool IsDeprecatedPolicy(const std::string& policy) {\n')
   if has_deprecated_policies:
     # arraysize() doesn't work with empty arrays.
     f.write('  for (size_t i = 0; i < arraysize(kDeprecatedPolicyList);'
                 ' ++i) {\n'
             '    if (policy == kDeprecatedPolicyList[i])\n'
             '      return true;\n'
             '  }\n')
   f.write('  return false;\n'
           '}\n\n')
 
   f.write('const PolicyDefinitionList* GetChromePolicyDefinitionList() {\n'
           '  return &kChromePolicyList;\n'
           '}\n\n')
 
+  f.write('const internal::SchemaNode* GetChromeSchemaNode() {\n'
+          '  return &internal::kSchema;\n'
+          '}\n\n')
+
   f.write('namespace key {\n\n')
   for policy in policies:
     # TODO(joaodasilva): Include only supported policies in
     # configuration_policy_handler.cc and configuration_policy_handler_list.cc
     # so that these names can be conditional on 'policy.is_supported'.
     # http://crbug.com/223616
     f.write('const char k{name}[] = "{name}";\n'.format(name=policy.name))
   f.write('\n}  // namespace key\n\n'
           '}  // namespace policy\n')
 
@@ skipping 242 matching lines @@
 def _WriteCloudPolicyDecoder(policies, os, f):
   f.write(CPP_HEAD)
   for policy in policies:
     if policy.is_supported and not policy.is_device_only:
       _WritePolicyCode(f, policy)
   f.write(CPP_FOOT)
 
 
 if __name__ == '__main__':
   sys.exit(main())