Make json_schema_compiler remove 'nocompile' nodes from JSON at the JSON level

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 copy
 import os.path
 import re
 
 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):
     self.namespaces = {}
 
   def AddNamespace(self, json, source_file):
-    """Add a namespace's json to the model if it doesn't have "nocompile"
-    property set to true. Returns the new namespace or None if a namespace
-    wasn't added.
+    """Add a namespace's json to the model and returns the namespace.
     """
-    if json.get('nocompile', False):
-      return None
     namespace = Namespace(json, source_file)
     self.namespaces[namespace.name] = namespace
     return namespace
 
 class Namespace(object):
   """An API namespace.
 
   Properties:
   - |name| the name of the namespace
   - |unix_name| the unix_name of the namespace
@@ skipping 12 matching lines @@
     self.functions = {}
     self.parent = None
     # TODO(calamity): Implement properties on namespaces for shared structures
     # or constants across a namespace (e.g Windows::WINDOW_ID_NONE).
     for property_json in json.get('properties', []):
       pass
     for type_json in json.get('types', []):
       type_ = Type(self, type_json['id'], type_json)
       self.types[type_.name] = type_
     for function_json in json.get('functions', []):
-      if not function_json.get('nocompile', False):
-        self.functions[function_json['name']] = Function(self, function_json)
+      self.functions[function_json['name']] = Function(self, function_json)
 
 class Type(object):
   """A Type defined in the json.
 
   Properties:
   - |name| the type name
   - |description| the description of the type (if provided)
   - |properties| a map of property unix_names to their model.Property
   - |functions| a map of function names to their model.Function
   - |from_client| indicates that instances of the Type can originate from the
@@ skipping 18 matching lines @@
         raise ParseException(name + " has no properties or functions")
       self.type_ = PropertyType.OBJECT
     self.name = name
     self.description = json.get('description')
     self.from_json = True
     self.from_client = True
     self.properties = {}
     self.functions = {}
     self.parent = parent
     for function_json in json.get('functions', []):
-      if not function_json.get('nocompile', False):
-        self.functions[function_json['name']] = Function(self, function_json)
+      self.functions[function_json['name']] = Function(self, function_json)
     props = []
     for prop_name, prop_json in json.get('properties', {}).items():
       # TODO(calamity): support functions (callbacks) as properties.  The model
       # doesn't support it yet because the h/cc generators don't -- this is
       # because we'd need to hook it into a base::Callback or something.
       #
       # However, pragmatically it's not necessary to support them anyway, since
       # the instances of functions-on-properties in the extension APIs are all
       # handled in pure Javascript on the render process (and .: never reach
       # C++ let alone the browser).
@@ skipping 225 matching lines @@
   """Returns the hierarchy of the given model entity."""
   hierarchy = []
   while entity:
     try:
       hierarchy.append(entity.name)
     except AttributeError:
       hierarchy.append(repr(entity))
     entity = entity.parent
   hierarchy.reverse()
   return hierarchy