Pepper: More IDL generator cleanup.

tools/json_schema_compiler/idl_schema.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.
 
 import itertools
 import json
 import os.path
 import re
 import sys
@@ skipping 89 matching lines @@
     return_type = None
     if self.node.GetProperty('TYPEREF') not in ('void', None):
       return_type = Typeref(self.node.GetProperty('TYPEREF'),
                             self.node.parent,
                             {'name': self.node.GetName()}).process(callbacks)
       # The IDL parser doesn't allow specifying return types as optional.
       # Instead we infer any object return values to be optional.
       # TODO(asargent): fix the IDL parser to support optional return types.
       if return_type.get('type') == 'object' or '$ref' in return_type:
         return_type['optional'] = True
-    for node in self.node.children:
+    for node in self.node.GetChildren():
       parameter = Param(node).process(callbacks)
       if parameter['name'] in self.comment:
         parameter['description'] = self.comment[parameter['name']]
       parameters.append(parameter)
     return (self.node.GetName(), parameters, return_type)
 
 
 class Param(object):
   '''
   Given a Param node representing a function parameter, converts into a Python
@@ skipping 11 matching lines @@
 class Dictionary(object):
   '''
   Given an IDL Dictionary node, converts into a Python dictionary that the JSON
   schema compiler expects to see.
   '''
   def __init__(self, dictionary_node):
     self.node = dictionary_node
 
   def process(self, callbacks):
     properties = OrderedDict()
-    for node in self.node.children:
+    for node in self.node.GetChildren():
       if node.cls == 'Member':
         k, v = Member(node).process(callbacks)
         properties[k] = v
     result = {'id': self.node.GetName(),
               'properties': properties,
               'type': 'object'}
     if self.node.GetProperty('inline_doc'):
       result['inline_doc'] = True
     elif self.node.GetProperty('noinline_doc'):
       result['noinline_doc'] = True
@@ skipping 21 matching lines @@
         ('supportsFilters', lambda s: s == 'true'),
         ('supportsListeners', lambda s: s == 'true'),
         ('supportsRules', lambda s: s == 'true')]:
       if self.node.GetProperty(option_name):
         if 'options' not in properties:
           properties['options'] = {}
         properties['options'][option_name] = sanitizer(self.node.GetProperty(
           option_name))
     is_function = False
     parameter_comments = OrderedDict()
-    for node in self.node.children:
+    for node in self.node.GetChildren():
       if node.cls == 'Comment':
         (parent_comment, parameter_comments) = ProcessComment(node.GetName())
         properties['description'] = parent_comment
       elif node.cls == 'Callspec':
         is_function = True
         name, parameters, return_type = (Callspec(node, parameter_comments)
                                          .process(callbacks))
         properties['parameters'] = parameters
         if return_type is not None:
           properties['returns'] = return_type
@@ skipping 88 matching lines @@
   '''
   Given an IDL Enum node, converts into a Python dictionary that the JSON
   schema compiler expects to see.
   '''
   def __init__(self, enum_node):
     self.node = enum_node
     self.description = ''
 
   def process(self, callbacks):
     enum = []
-    for node in self.node.children:
+    for node in self.node.GetChildren():
       if node.cls == 'EnumItem':
         enum_value = {'name': node.GetName()}
-        for child in node.children:
+        for child in node.GetChildren():
           if child.cls == 'Comment':
             enum_value['description'] = ProcessComment(child.GetName())[0]
           else:
             raise ValueError('Did not process %s %s' % (child.cls, child))
         enum.append(enum_value)
       elif node.cls == 'Comment':
         self.description = ProcessComment(node.GetName())[0]
       else:
         sys.exit('Did not process %s %s' % (node.cls, node))
     result = {'id' : self.node.GetName(),
@@ skipping 24 matching lines @@
     self.internal = internal
     self.platforms = platforms
     self.compiler_options = compiler_options
     self.events = []
     self.functions = []
     self.types = []
     self.callbacks = OrderedDict()
     self.description = description
 
   def process(self):
-    for node in self.namespace.children:
+    for node in self.namespace.GetChildren():
       if node.cls == 'Dictionary':
         self.types.append(Dictionary(node).process(self.callbacks))
       elif node.cls == 'Callback':
         k, v = Member(node).process(self.callbacks)
         self.callbacks[k] = v
       elif node.cls == 'Interface' and node.GetName() == 'Functions':
         self.functions = self.process_interface(node)
       elif node.cls == 'Interface' and node.GetName() == 'Events':
         self.events = self.process_interface(node)
       elif node.cls == 'Enum':
         self.types.append(Enum(node).process(self.callbacks))
       else:
         sys.exit('Did not process %s %s' % (node.cls, node))
     if self.compiler_options is not None:
       compiler_options = self.compiler_options
     else:
       compiler_options = {}
     return {'namespace': self.namespace.GetName(),
             'description': self.description,
             'nodoc': self.nodoc,
             'types': self.types,
             'functions': self.functions,
             'internal': self.internal,
             'events': self.events,
             'platforms': self.platforms,
             'compiler_options': compiler_options}
 
   def process_interface(self, node):
     members = []
-    for member in node.children:
+    for member in node.GetChildren():
       if member.cls == 'Member':
         name, properties = Member(member).process(self.callbacks)
         members.append(properties)
     return members
 
 
 class IDLSchema(object):
   '''
   Given a list of IDLNodes and IDLAttributes, converts into a Python list
   of api_defs that the JSON schema compiler expects to see.
@@ skipping 64 matching lines @@
   Dump a json serialization of parse result for the IDL files whose names
   were passed in on the command line.
   '''
   for filename in sys.argv[1:]:
     schema = Load(filename)
     print json.dumps(schema, indent=2)
 
 
 if __name__ == '__main__':
   Main()