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 functools
 import os.path
 import re
 import sys
+
 try:
   import json
 except ImportError:
   import simplejson as json
 
 # Path handling for libraries and templates
 # Paths have to be normalized because Jinja uses the exact template path to
 # determine the hash used in the cache filename, and we need a pre-caching step
 # to be concurrency-safe. Use absolute path because __file__ is absolute if
 # module is imported, and relative if executed directly.
@@ skipping 34 matching lines @@
 
 
 def CamelCaseToHackerStyle(name):
   # Do two passes to insert '_' chars to deal with overlapping matches (e.g.,
   # 'LoLoLoL').
   name = re.sub(r'([^_])([A-Z][a-z]+?)', r'\1_\2', name)
   name = re.sub(r'([^_])([A-Z][a-z]+?)', r'\1_\2', name)
   return name.lower()
 
 
+def Shorten(js_name, domain_name):
+  short_name = domain_name + '.'
+  long_name = 'chromium.DevTools.' + short_name
+  return js_name.replace(long_name, short_name)
+
+
+def ShortForm(domain, js_name):
+  if not 'js_dependencies' in domain:
+    return js_name
+
+  for dependency in domain['js_dependencies']:
+    js_name = Shorten(js_name, dependency)
+  js_name = Shorten(js_name, domain['domain'])
+  return js_name
+  
+
 def SanitizeLiteral(literal):
   return {
       # Rename null enumeration values to avoid a clash with the NULL macro.
       'null': 'none',
       # Rename literals that clash with Win32 defined macros.
       'error': 'err',
       'mouseMoved': 'mouse_ptr_moved',
       'Strict': 'exact',
       'getCurrentTime': 'getCurrentAnimationTime',
       # Rename mathematical constants to avoid colliding with C macros.
@@ skipping 39 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': '!chromium.DevTools.%s.%s' % (domain['domain'], type['id']),
       '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': '!chromium.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': 'Object',
       '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 121 matching lines @@
           'properties': 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)
+  types_required = 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)
+        types_required[domain_name].add(json['$ref'])
 
   for domain in json_api['domains']:
     direct_deps[domain['domain']] = set(domain.get('dependencies', []))
+    types_required[domain['domain']] = set(domain.get('types_required', []))
     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)
 
   for domain in json_api['domains']:
     domain_deps = set()
     TraverseDependencies(domain['domain'], domain_deps)
+    if 'dependencies' in domain:
+      domain['js_dependencies'] = domain['dependencies']
+    else:
+      domain['js_dependencies'] = []
+
+    domain['js_forward_declarations'] = []
+    for type in types_required[domain['domain']]:
+      if not type.split('.')[0] in domain['js_dependencies']:
+        domain['js_forward_declarations'].append(type)
     domain['dependencies'] = sorted(domain_deps)
 
 
 def PatchExperimentalCommandsAndEvents(json_api):
   """Mark all commands and events in experimental domains as experimental
   and make sure experimental commands have at least empty parameters
   and return values.
   """
   for domain in json_api['domains']:
     if domain.get('experimental', False):
@@ skipping 27 matching lines @@
 def GeneratePerDomain(jinja_env, output_dirname, json_api, class_name,
                     file_types, domain_name_to_file_name_func):
   EnsureDirectoryExists(output_dirname)
   for file_type in file_types:
     template = jinja_env.get_template('/%s_%s.template' % (
         class_name, file_type))
     for domain in json_api['domains']:
       template_context = {
           'domain': domain,
           'resolve_type': ResolveType,
+          'short_form': functools.partial(ShortForm, domain),
       }
       domain_name = CamelCaseToHackerStyle(domain['domain'])
       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'],
       lambda domain_name: domain_name)
+  GeneratePerDomain(
+      jinja_env, os.path.join(output_dirname, 'devtools_js'), json_api,
+      'domain', ['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.
   GeneratePerDomain(
@@ skipping 16 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)