Make base::Value::TYPE a scoped enum.

components/policy/tools/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 20 matching lines @@
 
   # Maps policy types to a tuple with 4 other types:
   # - the equivalent base::Value::Type or 'TYPE_EXTERNAL' if the policy
   #   references external data
   # - the equivalent Protobuf field type
   # - the name of one of the protobufs for shared policy types
   # - the equivalent type in Android's App Restriction Schema
   # TODO(joaodasilva): refactor the 'dict' type into a more generic 'json' type
   # that can also be used to represent lists of other JSON objects.
   TYPE_MAP = {
-    'dict':             ('TYPE_DICTIONARY',   'string',       'String',
+    'dict':             ('Type::DICTIONARY',  'string',       'String',
                         'string'),
     'external':         ('TYPE_EXTERNAL',     'string',       'String',
                         'invalid'),
-    'int':              ('TYPE_INTEGER',      'int64',        'Integer',
+    'int':              ('Type::INTEGER',     'int64',        'Integer',
                         'integer'),
-    'int-enum':         ('TYPE_INTEGER',      'int64',        'Integer',
+    'int-enum':         ('Type::INTEGER',     'int64',        'Integer',
                         'choice'),
-    'list':             ('TYPE_LIST',         'StringList',   'StringList',
+    'list':             ('Type::LIST',        'StringList',   'StringList',
                         'string'),
-    'main':             ('TYPE_BOOLEAN',      'bool',         'Boolean',
+    'main':             ('Type::BOOLEAN',     'bool',         'Boolean',
                         'bool'),
-    'string':           ('TYPE_STRING',       'string',       'String',
+    'string':           ('Type::STRING',      'string',       'String',
                         'string'),
-    'string-enum':      ('TYPE_STRING',       'string',       'String',
+    'string-enum':      ('Type::STRING',      'string',       'String',
                         'choice'),
-    'string-enum-list': ('TYPE_LIST',         'StringList',   'StringList',
+    'string-enum-list': ('Type::LIST',        'StringList',   'StringList',
                         'multi-select'),
   }
 
   class EnumItem:
     def __init__(self, item):
       self.caption = PolicyDetails._RemovePlaceholders(item['caption'])
       self.value = item['value']
 
   def __init__(self, policy, chrome_major_version, os, is_chromium_os,
                valid_tags):
@@ skipping 273 matching lines @@
     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 ------------------------#
 
 # A mapping of the simple schema types to base::Value::Types.
 SIMPLE_SCHEMA_NAME_MAP = {
-  'boolean': 'TYPE_BOOLEAN',
-  'integer': 'TYPE_INTEGER',
-  'null'   : 'TYPE_NULL',
-  'number' : 'TYPE_DOUBLE',
-  'string' : 'TYPE_STRING',
+  'boolean': 'Type::BOOLEAN',
+  'integer': 'Type::INTEGER',
+  'null'   : 'Type::NONE',
+  'number' : 'Type::DOUBLE',
+  'string' : 'Type::STRING',
 }
 
 class SchemaNodesGenerator:
   """Builds the internal structs to represent a JSON schema."""
 
   def __init__(self, shared_strings):
     """Creates a new generator.
 
     |shared_strings| is a map of strings to a C expression that evaluates to
     that string at runtime. This mapping can be used to reuse existing string
@@ skipping 39 matching lines @@
     if self.simple_types[name] == None:
       self.simple_types[name] = self.AppendSchema(
           SIMPLE_SCHEMA_NAME_MAP[name],
           -1,
           'simple type: ' + name)
     return self.simple_types[name]
 
   def GetStringList(self):
     if self.stringlist_type == None:
       self.stringlist_type = self.AppendSchema(
-          'TYPE_LIST',
+          'Type::LIST',
           self.GetSimpleType('string'),
           'simple type: stringlist')
     return self.stringlist_type
 
   def SchemaHaveRestriction(self, schema):
     return any(keyword in schema for keyword in
         ['minimum', 'maximum', 'enum', 'pattern'])
 
   def IsConsecutiveInterval(self, seq):
     sortedSeq = sorted(seq)
     return all(sortedSeq[i] + 1 == sortedSeq[i + 1]
                for i in xrange(len(sortedSeq) - 1))
 
   def GetEnumIntegerType(self, schema, name):
     assert all(type(x) == int for x in schema['enum'])
     possible_values = schema['enum']
     if self.IsConsecutiveInterval(possible_values):
       index = self.AppendRestriction(max(possible_values), min(possible_values))
-      return self.AppendSchema('TYPE_INTEGER', index,
+      return self.AppendSchema('Type::INTEGER', index,
           'integer with enumeration restriction (use range instead): %s' % name)
     offset_begin = len(self.int_enums)
     self.int_enums += possible_values
     offset_end = len(self.int_enums)
-    return self.AppendSchema('TYPE_INTEGER',
+    return self.AppendSchema('Type::INTEGER',
         self.AppendRestriction(offset_begin, offset_end),
         'integer with enumeration restriction: %s' % name)
 
   def GetEnumStringType(self, schema, name):
     assert all(type(x) == str for x in schema['enum'])
     offset_begin = len(self.string_enums)
     self.string_enums += schema['enum']
     offset_end = len(self.string_enums)
-    return self.AppendSchema('TYPE_STRING',
+    return self.AppendSchema('Type::STRING',
         self.AppendRestriction(offset_begin, offset_end),
         'string with enumeration restriction: %s' % name)
 
   def GetEnumType(self, schema, name):
     if len(schema['enum']) == 0:
       raise RuntimeError('Empty enumeration in %s' % name)
     elif schema['type'] == 'integer':
       return self.GetEnumIntegerType(schema, name)
     elif schema['type'] == 'string':
       return self.GetEnumStringType(schema, name)
     else:
       raise RuntimeError('Unknown enumeration type in %s' % name)
 
   def GetPatternType(self, schema, name):
     if schema['type'] != 'string':
       raise RuntimeError('Unknown pattern type in %s' % name)
     pattern = schema['pattern']
     # Try to compile the pattern to validate it, note that the syntax used
     # here might be slightly different from re2.
     # TODO(binjin): Add a python wrapper of re2 and use it here.
     re.compile(pattern)
     index = len(self.string_enums);
     self.string_enums.append(pattern);
-    return self.AppendSchema('TYPE_STRING',
+    return self.AppendSchema('Type::STRING',
         self.AppendRestriction(index, index),
         'string with pattern restriction: %s' % name);
 
   def GetRangedType(self, schema, name):
     if schema['type'] != 'integer':
       raise RuntimeError('Unknown ranged type in %s' % name)
     min_value_set, max_value_set = False, False
     if 'minimum' in schema:
       min_value = int(schema['minimum'])
       min_value_set = True
     if 'maximum' in schema:
       max_value = int(schema['minimum'])
       max_value_set = True
     if min_value_set and max_value_set and min_value > max_value:
       raise RuntimeError('Invalid ranged type in %s' % name)
     index = self.AppendRestriction(
         str(max_value) if max_value_set else 'INT_MAX',
         str(min_value) if min_value_set else 'INT_MIN')
-    return self.AppendSchema('TYPE_INTEGER',
+    return self.AppendSchema('Type::INTEGER',
         index,
         'integer with ranged restriction: %s' % name)
 
   def Generate(self, schema, name):
     """Generates the structs for the given schema.
 
     |schema|: a valid JSON schema in a dictionary.
     |name|: the name of the current node, for the generated comments."""
     if schema.has_key('$ref'):
       if schema.has_key('id'):
@@ skipping 10 matching lines @@
       elif 'pattern' in schema:
         return self.GetPatternType(schema, name)
       else:
         return self.GetRangedType(schema, name)
 
     if schema['type'] == 'array':
       # Special case for lists of strings, which is a common policy type.
       # The 'type' may be missing if the schema has a '$ref' attribute.
       if schema['items'].get('type', '') == 'string':
         return self.GetStringList()
-      return self.AppendSchema('TYPE_LIST',
+      return self.AppendSchema('Type::LIST',
           self.GenerateAndCollectID(schema['items'], 'items of ' + name))
     elif schema['type'] == 'object':
       # Reserve an index first, so that dictionaries come before their
       # properties. This makes sure that the root node is the first in the
       # SchemaNodes array.
-      index = self.AppendSchema('TYPE_DICTIONARY', -1)
+      index = self.AppendSchema('Type::DICTIONARY', -1)
 
       if 'additionalProperties' in schema:
         additionalProperties = self.GenerateAndCollectID(
             schema['additionalProperties'],
             'additionalProperties of ' + name)
       else:
         additionalProperties = -1
 
       # Properties must be sorted by name, for the binary search lookup.
       # Note that |properties| must be evaluated immediately, so that all the
@@ skipping 17 matching lines @@
 
       if index == 0:
         self.root_properties_begin = begin
         self.root_properties_end = end
 
       extra = len(self.properties_nodes)
       self.properties_nodes.append((begin, end, pattern_end,
           additionalProperties, name))
 
       # Set the right data at |index| now.
-      self.schema_nodes[index] = ('TYPE_DICTIONARY', extra, name)
+      self.schema_nodes[index] = ('Type::DICTIONARY', extra, name)
       return index
     else:
       assert False
 
   def GenerateAndCollectID(self, schema, name):
     """A wrapper of Generate(), will take the return value, check and add 'id'
     attribute to self.id_map. The wrapper needs to be used for every call to
     Generate().
     """
     index = self.Generate(schema, name)
@@ skipping 153 matching lines @@
 
   f.write('const internal::SchemaData* GetChromeSchemaData() {\n'
           '  return &kChromeSchemaData;\n'
           '}\n\n')
 
   f.write('#if defined (OS_CHROMEOS)\n'
           'void SetEnterpriseUsersDefaults(PolicyMap* policy_map) {\n')
 
   for policy in policies:
     if policy.has_enterprise_default:
-      if policy.policy_type == 'TYPE_BOOLEAN':
+      if policy.policy_type == 'Type::BOOLEAN':
         creation_expression = 'new base::FundamentalValue(%s)' %\
                               ('true' if policy.enterprise_default else 'false')
-      elif policy.policy_type == 'TYPE_INTEGER':
+      elif policy.policy_type == 'Type::INTEGER':
         creation_expression = 'new base::FundamentalValue(%s)' %\
                               policy.enterprise_default
-      elif policy.policy_type == 'TYPE_STRING':
+      elif policy.policy_type == 'Type::STRING':
         creation_expression = 'new base::StringValue("%s")' %\
                               policy.enterprise_default
       else:
         raise RuntimeError('Type %s of policy %s is not supported at '
                            'enterprise defaults' % (policy.policy_type,
                                                     policy.name))
       f.write('  if (!policy_map->Get(key::k%s)) {\n'
               '    policy_map->Set(key::k%s,\n'
               '                    POLICY_LEVEL_MANDATORY,\n'
               '                    POLICY_SCOPE_USER,\n'
@@ skipping 191 matching lines @@
 # Field IDs [1..RESERVED_IDS] will not be used in the wrapping protobuf.
 RESERVED_IDS = 2
 
 
 def _WritePolicyProto(f, policy, fields):
   _OutputComment(f, policy.caption + '\n\n' + policy.desc)
   if policy.items is not None:
     _OutputComment(f, '\nValid values:')
     for item in policy.items:
       _OutputComment(f, '  %s: %s' % (str(item.value), item.caption))
-  if policy.policy_type == 'TYPE_DICTIONARY':
+  if policy.policy_type == 'Type::DICTIONARY':
     _OutputComment(f, '\nValue schema:\n%s' %
                    json.dumps(policy.schema, sort_keys=True, indent=4,
                               separators=(',', ': ')))
   _OutputComment(f, '\nSupported on: %s' % ', '.join(policy.platforms))
   if policy.can_be_recommended and not policy.can_be_mandatory:
     _OutputComment(f, '\nNote: this policy must have a RECOMMENDED ' +\
                       'PolicyMode set in PolicyOptions.')
   f.write('message %sProto {\n' % policy.name)
   f.write('  optional PolicyOptions policy_options = 1;\n')
   f.write('  optional %s %s = 2;\n' % (policy.protobuf_type, policy.name))
@@ skipping 97 matching lines @@
 '''
 
 
 CPP_FOOT = '''}
 
 }  // namespace policy
 '''
 
 
 def _CreateValue(type, arg):
-  if type == 'TYPE_BOOLEAN':
+  if type == 'Type::BOOLEAN':
     return 'new base::FundamentalValue(%s)' % arg
-  elif type == 'TYPE_INTEGER':
+  elif type == 'Type::INTEGER':
     return 'DecodeIntegerValue(%s)' % arg
-  elif type == 'TYPE_STRING':
+  elif type == 'Type::STRING':
     return 'new base::StringValue(%s)' % arg
-  elif type == 'TYPE_LIST':
+  elif type == 'Type::LIST':
     return 'DecodeStringList(%s)' % arg
-  elif type == 'TYPE_DICTIONARY' or type == 'TYPE_EXTERNAL':
+  elif type == 'Type::DICTIONARY' or type == 'TYPE_EXTERNAL':
     return 'DecodeJson(%s)' % arg
   else:
     raise NotImplementedError('Unknown type %s' % type)
 
 
 def _CreateExternalDataFetcher(type, name):
   if type == 'TYPE_EXTERNAL':
     return 'new ExternalDataFetcher(external_data_manager, key::k%s)' % name
   return 'nullptr'
 
@@ skipping 77 matching lines @@
   f.write('<restrictions xmlns:android="'
           'http://schemas.android.com/apk/res/android">\n\n')
   for policy in policies:
     if (policy.is_supported and policy.restriction_type != 'invalid' and
          not policy.is_deprecated and not policy.is_future):
       WriteAppRestriction(policy)
   f.write('</restrictions>')
 
 if __name__ == '__main__':
   sys.exit(main())