Remove unused typemap includes from generated C++ mojo bindings.

mojo/public/tools/bindings/pylib/mojom/generate/generator.py

 # Copyright 2013 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.
 
 """Code shared by the various language-specific code generators."""
 
 from functools import partial
 import os.path
 import re
 
@@ skipping 11 matching lines @@
 
 def UnderToCamel(under):
   """Converts underscore_separated strings to CamelCase strings."""
   return ''.join(word.capitalize() for word in under.split('_'))
 
 def WriteFile(contents, full_path):
   # Make sure the containing directory exists.
   full_dir = os.path.dirname(full_path)
   fileutil.EnsureDirectoryExists(full_dir)
 
+  try:
+    with open(full_path, "r") as f:
+      if f.read() == contents:

[yzshen1, 2017/02/01 20:25:57]

Why do we need this check? It seems to be a fairly expensive check. Do we try to
re-write up-to-date files frequently?

[Sam McNally, 2017/02/02 22:01:46]

Only when changing the bindings generator.

+        return
+  except IOError:
+    pass
+
   # Dump the data to disk.
   with open(full_path, "w+") as f:
     f.write(contents)
 
+
+def NamespaceToArray(namespace):
+  return namespace.split(".") if namespace else []
+
+
+class NameFormatter(object):
+  """A formatter for the names of kinds or values."""
+
+  def __init__(self, token, variant):
+    self._token = token
+    self._variant = variant
+
+  def Format(self, separator, prefixed=False,

[yzshen1, 2017/02/01 20:25:57]

Could you please explain why we need to introduce NameFormatter in generator.py?
IIUC, it is only used in mojom_cpp_generator.py, and its subclass has slightly
different Format() implementation, which seems confusing.

[Sam McNally, 2017/02/02 22:01:46]

This was a leftover from a previous approach. Removed.

+             include_variant=False, add_same_module_namespaces=False, **kwargs):
+    parts = []
+    if self._ShouldIncludeNamespace(add_same_module_namespaces):
+      if prefixed:
+        parts.append("")
+      parts.extend(self._GetNamespace())
+      if include_variant and self._variant:
+        parts.append(self._variant)
+    parts.extend(self._GetName(**kwargs))
+    return separator.join(parts)
+
+  def FormatForMojom(self):
+    return self.Format(".", add_same_module_namespaces=True)
+
+  def _MapKindName(self, token, **_):
+    return token.name
+
+  def _GetName(self, flatten_nested_kind=False, **kwargs):
+    name = []
+    if flatten_nested_kind and self._token.parent_kind:
+      if mojom.IsEnumKind(self._token):
+        name.append("%s_%s" % (self._token.parent_kind.name,
+                              self._MapKindName(self._token, **kwargs)))
+        return name
+      elif isinstance(self._token, mojom.EnumValue):
+        return [self.__class__(self._token.enum, self._variant).Format(
+            '', flatten_nested_kind=flatten_nested_kind, **kwargs),
+                self._token.name]
+
+    if self._token.parent_kind:
+      name.append(self._MapKindName(self._token.parent_kind, **kwargs))
+
+    # Both variable and enum constants are constructed like:
+    # Namespace::Struct::CONSTANT_NAME
+    # For enums, CONSTANT_NAME is EnumName::ENUM_VALUE.
+    if isinstance(self._token, mojom.EnumValue):
+      name.extend([self._token.enum.name, self._token.name])
+    else:
+      name.append(self._MapKindName(self._token, **kwargs))
+    return name
+
+  def _ShouldIncludeNamespace(self, add_same_module_namespaces):
+    return add_same_module_namespaces or self._token.imported_from
+
+  def _GetNamespace(self):
+    if self._token.imported_from:
+      return NamespaceToArray(self._token.imported_from["namespace"])
+    elif hasattr(self._token, "module"):
+      return NamespaceToArray(self._token.module.namespace)
+    return []
+
+
+def GetFullMojomNameForKind(kind, variant=None):
+  return NameFormatter(kind, variant).FormatForMojom()
+
+
 class Generator(object):
   # Pass |output_dir| to emit files to disk. Omit |output_dir| to echo all
   # files to stdout.
   def __init__(self, module, output_dir=None, typemap=None, variant=None,
                bytecode_path=None, for_blink=False, use_once_callback=False,
                export_attribute=None, export_header=None,
                generate_non_variant_code=False):
     self.module = module
     self.output_dir = output_dir
     self.typemap = typemap or {}
@@ skipping 97 matching lines @@
     return self._AddStructComputedData(False, struct)
 
   def _GetResponseStructFromMethod(self, method):
     """Converts a method's response_parameters into the fields of a struct."""
     params_class = "%s_%s_ResponseParams" % (method.interface.name, method.name)
     struct = mojom.Struct(params_class, module=method.interface.module)
     for param in method.response_parameters:
       struct.AddField(param.name, param.kind, param.ordinal,
                       attributes=param.attributes)
     return self._AddStructComputedData(False, struct)