Added Network Quality Estimator Real-time interface to Cronet

build/android/gyp/java_cpp_enum.py

 #!/usr/bin/env python
 #
 # Copyright 2014 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 collections
 import re
 import optparse
 import os
@@ skipping 11 matching lines @@
   'short', 'unsigned short',
   'int', 'int8_t', 'int16_t', 'int32_t', 'uint8_t', 'uint16_t']
 
 class EnumDefinition(object):
   def __init__(self, original_enum_name=None, class_name_override=None,
                enum_package=None, entries=None, fixed_type=None):
     self.original_enum_name = original_enum_name
     self.class_name_override = class_name_override
     self.enum_package = enum_package
     self.entries = collections.OrderedDict(entries or [])
+    self.comments = collections.OrderedDict(entries or [])
     self.prefix_to_strip = None
     self.fixed_type = fixed_type
 
-  def AppendEntry(self, key, value):
+  def AppendEntry(self, key, value, comment):
     if key in self.entries:
       raise Exception('Multiple definitions of key %s found.' % key)
     self.entries[key] = value
+    self.comments[key] = comment
 
   @property
   def class_name(self):
     return self.class_name_override or self.original_enum_name
 
   def Finalize(self):
     self._Validate()
     self._AssignEntryIndices()
     self._StripPrefix()
 
@@ skipping 65 matching lines @@
   def UpdateDefinition(self, definition):
     definition.class_name_override = self._directives.get(
         DirectiveSet.class_name_override_key, '')
     definition.enum_package = self._directives.get(
         DirectiveSet.enum_package_key)
     definition.prefix_to_strip = self._directives.get(
         DirectiveSet.prefix_to_strip_key)
 
 
 class HeaderParser(object):
-  single_line_comment_re = re.compile(r'\s*//')
+  single_line_comment_re = re.compile(r'\s*//(.*)')
   multi_line_comment_start_re = re.compile(r'\s*/\*')
   enum_line_re = re.compile(r'^\s*(\w+)(\s*\=\s*([^,\n]+))?,?')
   enum_end_re = re.compile(r'^\s*}\s*;\.*$')
   generator_directive_re = re.compile(
       r'^\s*//\s+GENERATED_JAVA_(\w+)\s*:\s*([\.\w]+)$')
   multi_line_generator_directive_start_re = re.compile(
       r'^\s*//\s+GENERATED_JAVA_(\w+)\s*:\s*\(([\.\w]*)$')
   multi_line_directive_continuation_re = re.compile(
       r'^\s*//\s+([\.\w]+)$')
   multi_line_directive_end_re = re.compile(
       r'^\s*//\s+([\.\w]*)\)$')
 
   optional_class_or_struct_re = r'(class|struct)?'
   enum_name_re = r'(\w+)'
   optional_fixed_type_re = r'(\:\s*(\w+\s*\w+?))?'
   enum_start_re = re.compile(r'^\s*(?:\[cpp.*\])?\s*enum\s+' +
       optional_class_or_struct_re + '\s*' + enum_name_re + '\s*' +
       optional_fixed_type_re + '\s*{\s*$')
 
   def __init__(self, lines, path=None):
     self._lines = lines
     self._path = path
     self._enum_definitions = []
     self._in_enum = False
+    self._current_comment = []
     self._current_definition = None
     self._generator_directives = DirectiveSet()
     self._multi_line_generator_directive = None
 
   def _ApplyGeneratorDirectives(self):
     self._generator_directives.UpdateDefinition(self._current_definition)
     self._generator_directives = DirectiveSet()
 
   def ParseDefinitions(self):
     for line in self._lines:
       self._ParseLine(line)
     return self._enum_definitions
 
   def _ParseLine(self, line):
     if self._multi_line_generator_directive:
       self._ParseMultiLineDirectiveLine(line)
     elif not self._in_enum:
       self._ParseRegularLine(line)
     else:
       self._ParseEnumLine(line)
 
   def _ParseEnumLine(self, line):
-    if HeaderParser.single_line_comment_re.match(line):
+    comment = HeaderParser.single_line_comment_re.match(line)
+    if comment:
+      self._current_comment.append(comment.groups()[0])
       return
     if HeaderParser.multi_line_comment_start_re.match(line):
+      self._current_comment = []
       raise Exception('Multi-line comments in enums are not supported in ' +
                       self._path)
     enum_end = HeaderParser.enum_end_re.match(line)
     enum_entry = HeaderParser.enum_line_re.match(line)
     if enum_end:
       self._ApplyGeneratorDirectives()
       self._current_definition.Finalize()
       self._enum_definitions.append(self._current_definition)
       self._in_enum = False
     elif enum_entry:
       enum_key = enum_entry.groups()[0]
       enum_value = enum_entry.groups()[2]
-      self._current_definition.AppendEntry(enum_key, enum_value)
+      self._current_definition.AppendEntry(enum_key, enum_value,
+                                           self._current_comment)
+      self._current_comment = []
 
   def _ParseMultiLineDirectiveLine(self, line):
     multi_line_directive_continuation = (
         HeaderParser.multi_line_directive_continuation_re.match(line))
     multi_line_directive_end = (
         HeaderParser.multi_line_directive_end_re.match(line))
 
     if multi_line_directive_continuation:
       value_cont = multi_line_directive_continuation.groups()[0]
       self._multi_line_generator_directive[1].append(value_cont)
@@ skipping 55 matching lines @@
   return output_paths
 
 
 def DoParseHeaderFile(path):
   with open(path) as f:
     return HeaderParser(f.readlines(), path).ParseDefinitions()
 
 
 def GenerateOutput(source_path, enum_definition):
   template = Template("""
-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2015 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.
 
 // This file is autogenerated by
 //     ${SCRIPT_NAME}
 // From
 //     ${SOURCE_PATH}
 
 package ${PACKAGE};
 
 public class ${CLASS_NAME} {
 ${ENUM_ENTRIES}
 }
 """)
 
-  enum_template = Template('  public static final int ${NAME} = ${VALUE};')
+  enum_template = Template('${COMMENT}  '
+                           'public static final int ${NAME} = ${VALUE};')
   enum_entries_string = []
   for enum_name, enum_value in enum_definition.entries.iteritems():
+    enum_comment_string = []
+    line_separator = '\n'
+    if enum_name in enum_definition.comments and \
+       enum_definition.comments[enum_name]:
+      line_separator += '\n'
+      enum_comment_string.append('  /**\n')
+      for comment_line in enum_definition.comments[enum_name]:
+        enum_comment_string.append('   *' + comment_line + '\n')
+      enum_comment_string.append('   */\n')
     values = {
+        'COMMENT': ''.join(enum_comment_string),
         'NAME': enum_name,
         'VALUE': enum_value,
     }
     enum_entries_string.append(enum_template.substitute(values))
-  enum_entries_string = '\n'.join(enum_entries_string)
+  enum_entries_string = line_separator.join(enum_entries_string)
 
   values = {
       'CLASS_NAME': enum_definition.class_name,
       'ENUM_ENTRIES': enum_entries_string,
       'PACKAGE': enum_definition.enum_package,
       'SCRIPT_NAME': GetScriptName(),
       'SOURCE_PATH': source_path,
   }
   return template.substitute(values)
 
@@ skipping 34 matching lines @@
     AssertFilesList(output_paths, options.assert_files_list)
 
   if options.verbose:
     print 'Output paths:'
     print '\n'.join(output_paths)
 
   return ' '.join(output_paths)
 
 if __name__ == '__main__':
   DoMain(sys.argv[1:])