headless: Implement DevTools events

headless/lib/browser/client_api_generator.py

 # Copyright 2016 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 argparse
 import os.path
 import sys
 import re
 try:
   import json
@@ skipping 96 matching lines @@
   return {
     'return_type': 'std::unique_ptr<headless::%s::%s>' % (
         namespace, type['id']),
     'pass_type': 'std::unique_ptr<headless::%s::%s>' % (namespace, type['id']),
     'to_raw_type': '*%s',
     'to_raw_return_type': '%s.get()',
     'to_pass_type': 'std::move(%s)',
     'type': 'std::unique_ptr<headless::%s::%s>' % (namespace, type['id']),
     'raw_type': 'headless::%s::%s' % (namespace, type['id']),
     'raw_pass_type': 'headless::%s::%s*' % (namespace, type['id']),
-    'raw_return_type': 'headless::%s::%s*' % (namespace, type['id']),
+    'raw_return_type': 'const headless::%s::%s*' % (namespace, type['id']),
   }
 
 
 def CreateEnumTypeDefinition(domain_name, type):
   namespace = CamelCaseToHackerStyle(domain_name)
   return {
     'return_type': 'headless::%s::%s' % (namespace, type['id']),
     'pass_type': 'headless::%s::%s' % (namespace, type['id']),
     'to_raw_type': '%s',
     'to_raw_return_type': '%s',
     'to_pass_type': '%s',
     'type': 'headless::%s::%s' % (namespace, type['id']),
     'raw_type': 'headless::%s::%s' % (namespace, type['id']),
     'raw_pass_type': 'headless::%s::%s' % (namespace, type['id']),
     'raw_return_type': 'headless::%s::%s' % (namespace, type['id']),
   }
 
 
 def CreateObjectTypeDefinition():
   return {
     'return_type': 'std::unique_ptr<base::DictionaryValue>',
     'pass_type': 'std::unique_ptr<base::DictionaryValue>',
     'to_raw_type': '*%s',
     'to_raw_return_type': '%s.get()',
     'to_pass_type': 'std::move(%s)',
     'type': 'std::unique_ptr<base::DictionaryValue>',
     'raw_type': 'base::DictionaryValue',
     'raw_pass_type': 'base::DictionaryValue*',
-    'raw_return_type': 'base::DictionaryValue*',
+    'raw_return_type': 'const base::DictionaryValue*',
   }
 
 
 def WrapObjectTypeDefinition(type):
   id = type.get('id', 'base::Value')
   return {
     'return_type': 'std::unique_ptr<%s>' % id,
     'pass_type': 'std::unique_ptr<%s>' % id,
     'to_raw_type': '*%s',
     'to_raw_return_type': '%s.get()',
     'to_pass_type': 'std::move(%s)',
     'type': 'std::unique_ptr<%s>' % id,
     'raw_type': id,
     'raw_pass_type': '%s*' % id,
-    'raw_return_type': '%s*' % id,
+    'raw_return_type': 'const %s*' % id,
   }
 
 
 def CreateAnyTypeDefinition():
   return {
     'return_type': 'std::unique_ptr<base::Value>',
     'pass_type': 'std::unique_ptr<base::Value>',
     'to_raw_type': '*%s',
     'to_raw_return_type': '%s.get()',
     'to_pass_type': 'std::move(%s)',
     'type': 'std::unique_ptr<base::Value>',
     'raw_type': 'base::Value',
     'raw_pass_type': 'base::Value*',
-    'raw_return_type': 'base::Value*',
+    'raw_return_type': 'const base::Value*',
   }
 
 
 def CreateStringTypeDefinition(domain):
   return {
     'return_type': 'std::string',
     'pass_type': 'const std::string&',
     'to_pass_type': '%s',
     'to_raw_type': '%s',
     'to_raw_return_type': '%s',
@@ skipping 36 matching lines @@
 def WrapArrayDefinition(type):
   return {
     'return_type': 'std::vector<%s>' % type['type'],
     'pass_type': 'std::vector<%s>' % type['type'],
     'to_raw_type': '%s',
     'to_raw_return_type': '&%s',
     'to_pass_type': 'std::move(%s)',
     'type': 'std::vector<%s>' % type['type'],
     'raw_type': 'std::vector<%s>' % type['type'],
     'raw_pass_type': 'std::vector<%s>*' % type['type'],
-    'raw_return_type': 'std::vector<%s>*' % type['type'],
+    'raw_return_type': 'const std::vector<%s>*' % type['type'],
   }
 
 
 def CreateTypeDefinitions(json_api):
   for domain in json_api['domains']:
     if not ('types' in domain):
       continue
     for type in domain['types']:
       if type['type'] == 'object':
         if 'properties' in type:
@@ skipping 80 matching lines @@
         result_type = {
           'id': ToTitleCase(command['name']) + 'Result',
           'type': 'object',
           'description': 'Result for the %s command.' % ToTitleCase(
               command['name']),
           'properties': command['returns']
         }
         domain['types'].append(result_type)
 
 
+def SynthesizeEventTypes(json_api):
+  """Generate types for events and their properties."""
+  for domain in json_api['domains']:
+    if not 'types' in domain:
+      domain['types'] = []
+    for event in domain.get('events', []):
+      if not 'parameters' in event:
+        continue
+      for parameter in event['parameters']:
+        if 'enum' in parameter and not '$ref' in parameter:
+          SynthesizeEnumType(domain, event['name'], parameter)
+      event_type = {
+        'id': ToTitleCase(event['name']) + 'Params',
+        'type': 'object',
+        'description': 'Parameters for the %s event.' % ToTitleCase(
+            event['name']),
+        'properties': event['parameters']
+      }
+      domain['types'].append(event_type)
+
+
 def Generate(jinja_env, output_dirname, json_api, class_name, file_types):
   template_context = {
     'api': json_api,
     'join_arrays': JoinArrays,
     'resolve_type': ResolveType,
     'type_definition': TypeDefinition,
   }
   for file_type in file_types:
     template = jinja_env.get_template('/%s_%s.template' % (
         class_name, file_type))
@@ skipping 15 matching lines @@
       domain_name = CamelCaseToHackerStyle(domain['domain'])
       output_file = '%s/%s.%s' % (output_dirname, domain_name, file_type)
       with open(output_file, 'w') as f:
         f.write(template.render(template_context))
 
 
 if __name__ == '__main__':
   json_api, output_dirname = ParseArguments(sys.argv[1:])
   jinja_env = InitializeJinjaEnv(output_dirname)
   SynthesizeCommandTypes(json_api)
+  SynthesizeEventTypes(json_api)
   PatchFullQualifiedRefs(json_api)
   CreateTypeDefinitions(json_api)
   Generate(jinja_env, output_dirname, json_api, 'types', ['cc', 'h'])
   Generate(jinja_env, output_dirname, json_api, 'type_conversions', ['h'])
   GenerateDomains(jinja_env, output_dirname, json_api, 'domain', ['cc', 'h'])