Update json_schema_compiler to handle the Automation extension API

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 pprint
 import re
@@ skipping 32 matching lines @@
     to other arguments.
     |arg2_name|: Description of arg2...
 
   Newlines are removed, and leading and trailing whitespace is stripped.
 
   Args:
     comment: The string from a Comment node.
 
   Returns: A tuple that looks like:
     (
-      "The processed comment, minus all |parameter| mentions.",
+      "The processed comment, minus all |parameter| mentions and jsexterns.",
+      "Any block wrapped in <jsexterns></jsexterns>.",
       {
         'parameter_name_1': "The comment that followed |parameter_name_1|:",
         ...
       }
     )
   '''
+  jsexterns = None
+  match = re.search('<jsexterns>(.*)</jsexterns>', comment, re.DOTALL)

[Dan Beam, 2017/01/12 03:12:50]

oh, i guess this is only on the comment, not the whole file.  probably less of
an issue then

I'm trusting Devlin's instincts on whether this mechanism is actually a good
idea.  It basically seems like static_cast<> for externs generation ;)

[Devlin, 2017/01/12 17:28:47]

I'm not in love with it, but there's also not a great alternative yet.  But
there are a few places it looks like we can avoid it here - see idl comments.

[dmazzoni, 2017/01/13 21:22:53]

Great, now down to just two special cases, both maps.

+  if match:
+    jsexterns = match.group(1).strip()
+    comment = comment[:match.start()] + comment[match.end():]
+
   def add_paragraphs(content):
     paragraphs = content.split('\n\n')
     if len(paragraphs) < 2:
       return content
     return '<p>' + '</p><p>'.join(p.strip() for p in paragraphs) + '</p>'
 
   # Find all the parameter comments of the form '|name|: comment'.
   parameter_starts = list(re.finditer(r' *\|([^|]*)\| *: *', comment))
 
   # Get the parent comment (everything before the first parameter comment.
   first_parameter_location = (parameter_starts[0].start()
                               if parameter_starts else len(comment))
   parent_comment = (add_paragraphs(comment[:first_parameter_location].strip())
                     .replace('\n', ''))
 
   params = OrderedDict()
   for (cur_param, next_param) in itertools.izip_longest(parameter_starts,
                                                         parameter_starts[1:]):
     param_name = cur_param.group(1)
 
     # A parameter's comment goes from the end of its introduction to the
     # beginning of the next parameter's introduction.
     param_comment_start = cur_param.end()
     param_comment_end = next_param.start() if next_param else len(comment)
     params[param_name] = (
         add_paragraphs(comment[param_comment_start:param_comment_end].strip())
         .replace('\n', ''))
 
-  return (parent_comment, params)
+  return (parent_comment, jsexterns, params)
 
 
 class Callspec(object):
   '''
   Given a Callspec node representing an IDL function declaration, converts into
   a tuple:
       (name, list of function parameters, return type)
   '''
   def __init__(self, callspec_node, comment):
     self.node = callspec_node
@@ skipping 89 matching lines @@
         ('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))
     type_override = None
     parameter_comments = OrderedDict()
     for node in self.node.GetChildren():
       if node.cls == 'Comment':
-        (parent_comment, parameter_comments) = ProcessComment(node.GetName())
+        (parent_comment, jsexterns, parameter_comments) = ProcessComment(
+            node.GetName())
         properties['description'] = parent_comment
+        properties['jsexterns'] = jsexterns
       elif node.cls == 'Callspec':
         name, parameters, return_type = (Callspec(node, parameter_comments)
                                          .process(callbacks))
         if functions_are_properties:
           # If functions are treated as properties (which will happen if the
           # interface is named Properties) then this isn't a function, it's a
           # property which is encoded as a function with no arguments. The
           # property type is the return type. This is an egregious hack in lieu
           # of the IDL parser supporting 'const'.
           assert parameters == [], (
@@ skipping 341 matching lines @@
       print json.dumps(schema, indent=2)
   else:
     contents = sys.stdin.read()
     idl = idl_parser.IDLParser().ParseData(contents, '<stdin>')
     schema = IDLSchema(idl).process()
     print json.dumps(schema, indent=2)
 
 
 if __name__ == '__main__':
   Main()