[Extensions API] Remove inline enums

tools/json_schema_compiler/model.py

 # 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.
 
 import os.path
 
 from json_parse import OrderedDict
 from memoize import memoize
 
 
 class ParseException(Exception):
   """Thrown when data in the model is invalid.
   """
   def __init__(self, parent, message):
     hierarchy = _GetModelHierarchy(parent)
     hierarchy.append(message)
     Exception.__init__(
         self, 'Model parse exception at:\n' + '\n'.join(hierarchy))
 
 
 class Model(object):
   """Model of all namespaces that comprise an API.
 
   Properties:
   - |namespaces| a map of a namespace name to its model.Namespace
   """
-  def __init__(self):
+  def __init__(self, allow_inline_enums=True):
+    self._allow_inline_enums = allow_inline_enums
     self.namespaces = {}
 
   def AddNamespace(self,
                    json,
                    source_file,
                    include_compiler_options=False,
                    environment=None):
     """Add a namespace's json to the model and returns the namespace.
     """
     namespace = Namespace(json,
                           source_file,
                           include_compiler_options=include_compiler_options,
-                          environment=environment)
+                          environment=environment,
+                          allow_inline_enums=self._allow_inline_enums)
     self.namespaces[namespace.name] = namespace
     return namespace
 
 
 def CreateFeature(name, model):
   if isinstance(model, dict):
     return SimpleFeature(name, model)
   return ComplexFeature(name, [SimpleFeature(name, child) for child in model])
 
 
@@ skipping 46 matching lines @@
   - |functions| a map of function names to their model.Function
   - |events| a map of event names to their model.Function
   - |properties| a map of property names to their model.Property
   - |compiler_options| the compiler_options dict, only not empty if
                        |include_compiler_options| is True
   """
   def __init__(self,
                json,
                source_file,
                include_compiler_options=False,
-               environment=None):
+               environment=None,
+               allow_inline_enums=True):
     self.name = json['namespace']
     if 'description' not in json:
       # TODO(kalman): Go back to throwing an error here.
       print('%s must have a "description" field. This will appear '
                        'on the API summary page.' % self.name)
       json['description'] = ''
     self.description = json['description']
     self.deprecated = json.get('deprecated', None)
     self.unix_name = UnixName(self.name)
     self.source_file = source_file
     self.source_file_dir, self.source_file_filename = os.path.split(source_file)
     self.short_filename = os.path.basename(source_file).split('.')[0]
     self.parent = None
+    self.allow_inline_enums = allow_inline_enums
     self.platforms = _GetPlatforms(json)
     toplevel_origin = Origin(from_client=True, from_json=True)
     self.types = _GetTypes(self, json, self, toplevel_origin)
     self.functions = _GetFunctions(self, json, self)
     self.events = _GetEvents(self, json, self)
     self.properties = _GetProperties(self, json, self, toplevel_origin)
     if include_compiler_options:
       self.compiler_options = json.get('compiler_options', {})
     else:
       self.compiler_options = {}
@@ skipping 60 matching lines @@
 
     json_type = json.get('type', None)
     if json_type == 'array':
       self.property_type = PropertyType.ARRAY
       self.item_type = Type(
           self, '%sType' % name, json['items'], namespace, origin)
     elif '$ref' in json:
       self.property_type = PropertyType.REF
       self.ref_type = json['$ref']
     elif 'enum' in json and json_type == 'string':
+      if not namespace.allow_inline_enums and not isinstance(parent, Namespace):

[not at google - send to devlin, 2015/04/03 17:04:38]

Is there a reason to make this a parameter rather than just the default
behavior?

[Devlin, 2015/04/03 19:38:51]

The docserver inlines types, and then feeds them back into the compiler, so we
need to still allow for that functionality.

+        raise ParseException(
+            self,
+            'Inline enum "%s" found in namespace "%s". These are not allowed. '
+                'See crbug.com/472279' % (name, namespace.name))
       self.property_type = PropertyType.ENUM
       self.enum_values = [EnumValue(value) for value in json['enum']]
       self.cpp_enum_prefix_override = json.get('cpp_enum_prefix_override', None)
     elif json_type == 'any':
       self.property_type = PropertyType.ANY
     elif json_type == 'binary':
       self.property_type = PropertyType.BINARY
     elif json_type == 'boolean':
       self.property_type = PropertyType.BOOLEAN
     elif json_type == 'integer':
@@ skipping 387 matching lines @@
   # Sanity check: platforms should not be an empty list.
   if not json['platforms']:
     raise ValueError('"platforms" cannot be an empty list')
   platforms = []
   for platform_name in json['platforms']:
     for platform_enum in _Enum.GetAll(Platforms):
       if platform_name == platform_enum.name:
         platforms.append(platform_enum)
         break
   return platforms