Add some closureised JS bindings for DevTools for use by headless embedder

headless/lib/browser/devtools_api/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 collections
 import os.path
 import re
 import sys
 try:
@@ skipping 102 matching lines @@
       if not '.' in json['$ref']:
         json['$ref'] = domain_name + '.' + json['$ref']
 
   for domain in json_api['domains']:
     PatchFullQualifiedRefsInDomain(domain, domain['domain'])
 
 
 def CreateUserTypeDefinition(domain, type):
   namespace = CamelCaseToHackerStyle(domain['domain'])
   return {
+      'js_type': '!goog.DevTools.%s.%s' % (domain['domain'], type['id']),

[Sami, 2017/05/24 09:16:21]

Is the goog namespace the one we should be using? What's the convention here?

[alex clarke (OOO till 29th), 2017/05/24 11:38:14]

Well we are google so goog seems appropriate?

[Sami, 2017/05/25 17:53:35]

Let's use the chrome namespace since this is more a Chrome API than a Google API
and there's some precedent too (chrome.gpuBenchmarking).

[alex clarke (OOO till 29th), 2017/05/26 11:37:02]

As discussed offline we had to use chromium instead because there was some built
in extern for chrome.

       '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': 'const headless::%s::%s*' % (namespace, type['id']),
   }
 
 
 def CreateEnumTypeDefinition(domain_name, type):
   namespace = CamelCaseToHackerStyle(domain_name)
   return {
+      'js_type': '!goog.DevTools.%s.%s' % (domain_name, type['id']),
       '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 {
+      'js_type': '%s',
       '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': 'const base::DictionaryValue*',
   }
 
 
 def WrapObjectTypeDefinition(type):
   id = type.get('id', 'base::Value')
   return {
+      'js_type': '!Object',
       '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': 'const %s*' % id,
   }
 
 
 def CreateAnyTypeDefinition():
   return {
+      'js_type': '*',
       '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': 'const base::Value*',
   }
 
 
 def CreateStringTypeDefinition():
   return {
+      'js_type': 'string',
       'return_type': 'std::string',
       'pass_type': 'const std::string&',
       'to_pass_type': '%s',
       'to_raw_type': '%s',
       'to_raw_return_type': '%s',
       'type': 'std::string',
       'raw_type': 'std::string',
       'raw_pass_type': 'const std::string&',
       'raw_return_type': 'std::string',
   }
 
 
 def CreatePrimitiveTypeDefinition(type):
   typedefs = {
       'number': 'double',
       'integer': 'int',
       'boolean': 'bool',
   }
+  js_typedefs = {
+      'number': 'number',
+      'integer': 'number',
+      'boolean': 'boolean',
+  }
   return {
+      'js_type': js_typedefs[type],
       'return_type': typedefs[type],
       'pass_type': typedefs[type],
       'to_pass_type': '%s',
       'to_raw_type': '%s',
       'to_raw_return_type': '%s',
       'type': typedefs[type],
       'raw_type': typedefs[type],
       'raw_pass_type': typedefs[type],
       'raw_return_type': typedefs[type],
   }
 
 
 type_definitions = {}
 type_definitions['number'] = CreatePrimitiveTypeDefinition('number')
 type_definitions['integer'] = CreatePrimitiveTypeDefinition('integer')
 type_definitions['boolean'] = CreatePrimitiveTypeDefinition('boolean')
 type_definitions['string'] = CreateStringTypeDefinition()
 type_definitions['object'] = CreateObjectTypeDefinition()
 type_definitions['any'] = CreateAnyTypeDefinition()
 
 
 def WrapArrayDefinition(type):
   return {
+      'js_type': '!Array.<%s>' % type['js_type'],
       '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': 'const std::vector<%s>*' % type['type'],
   }
@@ skipping 53 matching lines @@
 
 
 def SynthesizeEnumType(domain, owner, type):
   type['id'] = ToTitleCase(owner) + ToTitleCase(type['name'])
   type_definitions[domain['domain'] + '.' + type['id']] = (
       CreateEnumTypeDefinition(domain['domain'], type))
   type['$ref'] = domain['domain'] + '.' + type['id']
   domain['types'].append(type)
 
 
+def SynthesizeJsConstructorArgs(properties):

[Sami, 2017/05/24 09:16:21]

Please add some coverage in update client_api_generator_test.py too.

[alex clarke (OOO till 29th), 2017/05/24 11:38:14]

We don't need this anymore, removing.

+  args = []
+  for prop in properties:
+    if 'optional' in prop and prop['optional']:
+      continue
+    args.append(prop['name'])
+  for prop in properties:
+    if not 'optional' in prop or not prop['optional']:
+      continue
+    args.append('opt_' + prop['name'])
+  return ', '.join(args)
+
+
 def SynthesizeCommandTypes(json_api):
   """Generate types for command parameters, return values and enum
      properties.
   """
   for domain in json_api['domains']:
     if not 'types' in domain:
       domain['types'] = []
     for type in domain['types']:
       if type['type'] == 'object':
         for property in type.get('properties', []):
           if 'enum' in property and not '$ref' in property:
             SynthesizeEnumType(domain, type['id'], property)
 
     for command in domain.get('commands', []):
       if 'parameters' in command:
         for parameter in command['parameters']:
           if 'enum' in parameter and not '$ref' in parameter:
             SynthesizeEnumType(domain, command['name'], parameter)
         parameters_type = {
             'id': ToTitleCase(SanitizeLiteral(command['name'])) + 'Params',
             'type': 'object',
             'description': 'Parameters for the %s command.' % ToTitleCase(
                 SanitizeLiteral(command['name'])),
-            'properties': command['parameters']
+            'properties': command['parameters'],
+            'js_constructor_args': SynthesizeJsConstructorArgs(
+                command['parameters'])
         }
         domain['types'].append(parameters_type)
       if 'returns' in command:
         for parameter in command['returns']:
           if 'enum' in parameter and not '$ref' in parameter:
             SynthesizeEnumType(domain, command['name'], parameter)
         result_type = {
             'id': ToTitleCase(SanitizeLiteral(command['name'])) + 'Result',
             'type': 'object',
             'description': 'Result for the %s command.' % ToTitleCase(
                 SanitizeLiteral(command['name'])),
-            'properties': command['returns']
+            'properties': command['returns'],
+            'js_constructor_args': SynthesizeJsConstructorArgs(
+                command['returns'])
         }
         domain['types'].append(result_type)
 
 
 def SynthesizeEventTypes(json_api):
   """Generate types for events and their properties.
 
   Note that parameter objects are also created for events without parameters to
   make it easier to introduce parameters later.
   """
   for domain in json_api['domains']:
     if not 'types' in domain:
       domain['types'] = []
     for event in domain.get('events', []):
       for parameter in event.get('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.get('parameters', [])
+          'properties': event.get('parameters', []),
+          'js_constructor_args': SynthesizeJsConstructorArgs(
+              event.get('parameters', []))
       }
       domain['types'].append(event_type)
 
 
 def InitializeDomainDependencies(json_api):
   """For each domain create list of domains given domain depends on,
   including itself."""
 
   direct_deps = collections.defaultdict(set)
 
   def GetDomainDepsFromRefs(domain_name, json):
     if isinstance(json, list):
       for value in json:
         GetDomainDepsFromRefs(domain_name, value)
       return
 
     if not isinstance(json, dict):
       return
     for value in json.itervalues():
       GetDomainDepsFromRefs(domain_name, value)
 
     if '$ref' in json:
       if '.' in json['$ref']:
         dep = json['$ref'].split('.')[0]
         direct_deps[domain_name].add(dep)
 
   for domain in json_api['domains']:
-    direct_deps[domain['domain']] = set(domain.get('dependencies', []))
+    deps = domain.get('dependencies', [])
+    js_dependencies = deps

[Sami, 2017/05/24 09:16:21]

|js_dependencies| unused?

[alex clarke (OOO till 29th), 2017/05/24 11:38:14]

Done.

+    direct_deps[domain['domain']] = set(deps)
     GetDomainDepsFromRefs(domain['domain'], domain)
 
   def TraverseDependencies(domain, deps):
     if domain in deps:
       return
     deps.add(domain)
 
     for dep in direct_deps[domain]:
       TraverseDependencies(dep, deps)
 
@@ skipping 52 matching lines @@
       output_file = '%s/%s.%s' % (output_dirname,
                                   domain_name_to_file_name_func(domain_name),
                                   file_type)
       with open(output_file, 'w') as f:
         f.write(template.render(template_context))
 
 
 def GenerateDomains(jinja_env, output_dirname, json_api):
   GeneratePerDomain(
       jinja_env, os.path.join(output_dirname, 'devtools', 'domains'), json_api,
-      'domain', ['cc', 'h'],
+      'domain', ['cc', 'h', 'js'],
       lambda domain_name: domain_name)
 
 
 def GenerateTypes(jinja_env, output_dirname, json_api):
   # Generate forward declarations for types.
   GeneratePerDomain(
       jinja_env, os.path.join(output_dirname, 'devtools', 'internal'),
       json_api, 'domain_types_forward_declarations', ['h'],
       lambda domain_name: 'types_forward_declarations_%s' % (domain_name, ))
   # Generate types on per-domain basis.
@@ skipping 17 matching lines @@
   InitializeDomainDependencies(json_api)
   PatchExperimentalCommandsAndEvents(json_api)
   EnsureCommandsHaveParametersAndReturnTypes(json_api)
   SynthesizeCommandTypes(json_api)
   SynthesizeEventTypes(json_api)
   PatchFullQualifiedRefs(json_api)
   CreateTypeDefinitions(json_api)
   GenerateDomains(jinja_env, output_dirname, json_api)
   GenerateTypes(jinja_env, output_dirname, json_api)
   GenerateTypeConversions(jinja_env, output_dirname, json_api)