Mojo bindings: Fix typemap includes.

mojo/public/tools/bindings/generators/mojom_cpp_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.
 
 """Generates C++ source files from a mojom.Module."""
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 import mojom.generate.pack as pack
 from mojom.generate.template_expander import UseJinja
@@ skipping 33 matching lines @@
 
 # TODO(rockot): Get rid of these globals. This requires some refactoring of the
 # generator library code so that filters can use the generator as context.
 _current_typemap = {}
 _for_blink = False
 # TODO(rockot, yzshen): The variant handling is kind of a hack currently. Make
 # it right.
 _variant = None
 
 
+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, internal=False,
+             include_variant=False, add_same_module_namespaces=False):
+    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(internal))
+    return separator.join(parts)
+
+  def FormatForCpp(self, add_same_module_namespaces=False, internal=False):
+    return self.Format(
+        "::", prefixed=True,
+        add_same_module_namespaces=add_same_module_namespaces,
+        internal=internal, include_variant=True)
+
+  def FormatForTypemap(self):
+    return self.Format(".", add_same_module_namespaces=True)
+
+  def _MapKindName(self, token, internal):
+    if not internal:
+      return token.name
+    if mojom.IsStructKind(token) and token.native_only:
+      return "mojo::Array_Data<uint8_t>"
+    if (mojom.IsStructKind(token) or mojom.IsUnionKind(token) or
+        mojom.IsInterfaceKind(token) or mojom.IsEnumKind(token)):
+      return token.name + "_Data"
+    return token.name
+
+  def _GetName(self, internal):
+    name = []
+    if internal:
+      name.append("internal")
+    if self._token.parent_kind:
+      name.append(self._MapKindName(self._token.parent_kind, internal))
+    # 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, internal))
+    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 ConstantValue(constant):
   return ExpressionToText(constant.value, kind=constant.kind)
 
 def DefaultValue(field):
   if field.default:
     if mojom.IsStructKind(field.kind):
       assert field.default == "default"
       return "%s::New()" % GetNameForKind(field.kind)
     return ExpressionToText(field.default, kind=field.kind)
   if mojom.IsArrayKind(field.kind) or mojom.IsMapKind(field.kind):
     return "nullptr";
   if mojom.IsStringKind(field.kind):
     return "" if _for_blink else "nullptr"
   return ""
 
 def NamespaceToArray(namespace):
   return namespace.split(".") if namespace else []
 
-def GetNamePartsForKind(kind, add_same_module_namespaces, add_variant,
-                        internal):
-  def MapKindName_(kind):
-    if not internal:
-      return kind.name
-    if mojom.IsStructKind(kind) and kind.native_only:
-      return "mojo::Array_Data<uint8_t>"
-    if (mojom.IsStructKind(kind) or mojom.IsUnionKind(kind) or
-        mojom.IsInterfaceKind(kind) or mojom.IsEnumKind(kind)):
-      return kind.name + "_Data"
-    return kind.name
-
-  parts = []
-  if kind.imported_from:
-    parts.extend(NamespaceToArray(kind.imported_from["namespace"]))
-    if _variant and add_variant:
-      parts.append(_variant)
-  elif add_same_module_namespaces:
-    if hasattr(kind, "module"):
-      parts.extend(NamespaceToArray(kind.module.namespace))
-    if _variant and add_variant:
-      parts.append(_variant)
-  if internal:
-    parts.append("internal")
-  if kind.parent_kind:
-    parts.append(MapKindName_(kind.parent_kind))
-  parts.append(MapKindName_(kind))
-  return parts
-
 def GetNameForKind(kind, internal=False):
-  parts = GetNamePartsForKind(kind, False, True, internal)
-  return "::".join(parts)
+  return _NameFormatter(kind, _variant).FormatForCpp(internal=internal)
 
 def GetQualifiedNameForKind(kind, internal=False):
-  # Always start with an empty part to force a leading "::" on output.
-  parts = [""]
-  parts.extend(GetNamePartsForKind(kind, True, True, internal))
-  return "::".join(parts)
+  return _NameFormatter(kind, _variant).FormatForCpp(
+      internal=internal, add_same_module_namespaces=True)
 
 def GetFullMojomNameForKind(kind):
-  parts = GetNamePartsForKind(kind, True, False, False)
-  return ".".join(parts)
+  return _NameFormatter(kind, _variant).FormatForTypemap()
 
 def IsTypemappedKind(kind):
   return hasattr(kind, "name") and \
       GetFullMojomNameForKind(kind) in _current_typemap
 
 def IsCloneableKind(kind):
   return mojom.IsCloneableKind(kind, IsTypemappedKind)
 
 def IsNativeOnlyKind(kind):
   return mojom.IsStructKind(kind) and kind.native_only
@@ skipping 247 matching lines @@
 def GetUnionGetterReturnType(kind):
   if (mojom.IsStructKind(kind) or mojom.IsUnionKind(kind) or
       mojom.IsArrayKind(kind) or mojom.IsMapKind(kind) or
       mojom.IsAnyHandleKind(kind) or mojom.IsInterfaceKind(kind)
       or mojom.IsAssociatedKind(kind)):
     return "%s&" % GetCppWrapperType(kind)
   return GetCppResultWrapperType(kind)
 
 def TranslateConstants(token, kind):
   if isinstance(token, mojom.NamedValue):
-    # Both variable and enum constants are constructed like:
-    # Namespace::Struct::CONSTANT_NAME
-    # For enums, CONSTANT_NAME is ENUM_NAME_ENUM_VALUE.
-    name = []
-    if token.imported_from:
-      name.extend(NamespaceToArray(token.namespace))
-    if _variant:
-      name.append(_variant)
-    if token.parent_kind:
-      name.append(token.parent_kind.name)
-    if isinstance(token, mojom.EnumValue):
-      name.extend([token.enum.name, token.name])
-    else:
-      name.append(token.name)
-    return "::".join(name)
+    return _NameFormatter(token, _variant).FormatForCpp()
 
   if isinstance(token, mojom.BuiltinValue):
     if token.value == "double.INFINITY" or token.value == "float.INFINITY":
       return "INFINITY";
     if token.value == "double.NEGATIVE_INFINITY" or \
        token.value == "float.NEGATIVE_INFINITY":
       return "-INFINITY";
     if token.value == "double.NAN" or token.value == "float.NAN":
       return "NAN";
 
@@ skipping 112 matching lines @@
     "is_union_kind": mojom.IsUnionKind,
     "passes_associated_kinds": mojom.PassesAssociatedKinds,
     "struct_size": lambda ps: ps.GetTotalSize() + _HEADER_SIZE,
     "stylize_method": generator.StudlyCapsToCamel,
     "supports_equality": DoesKindSupportEquality,
     "under_to_camel": generator.UnderToCamel,
   }
 
   def GetExtraHeaders(self):
     extra_headers = set()
-    for name, entry in self.typemap.iteritems():
-      extra_headers.update(entry["headers"])
+    for entry in self.typemap.itervalues():
+      extra_headers.update(entry.get("headers", []))
+    return list(extra_headers)
+
+  def GetExtraPublicHeaders(self):
+    extra_headers = set()
+    for entry in self.typemap.itervalues():
+      extra_headers.update(entry.get("public_headers", []))
     return list(extra_headers)
 
   def GetJinjaExports(self):
     return {
       "module": self.module,
       "namespace": self.module.namespace,
       "namespaces_as_array": NamespaceToArray(self.module.namespace),
       "imports": self.module.imports,
       "kinds": self.module.kinds,
       "enums": self.module.enums,
       "structs": self.GetStructs(),
       "unions": self.GetUnions(),
       "interfaces": self.GetInterfaces(),
       "variant": self.variant,
       "extra_headers": self.GetExtraHeaders(),
+      "extra_public_headers": self.GetExtraPublicHeaders(),
       "for_blink": self.for_blink,
     }
 
   @staticmethod
   def GetTemplatePrefix():
     return "cpp_templates"
 
   @classmethod
   def GetFilters(cls):
     return cls.cpp_filters
@@ skipping 17 matching lines @@
     _for_blink = self.for_blink
     global _variant
     _variant = self.variant
     suffix = "-%s" % self.variant if self.variant else ""
     self.Write(self.GenerateModuleHeader(),
         self.MatchMojomFilePath("%s%s.h" % (self.module.name, suffix)))
     self.Write(self.GenerateModuleInternalHeader(),
         self.MatchMojomFilePath("%s%s-internal.h" % (self.module.name, suffix)))
     self.Write(self.GenerateModuleSource(),
         self.MatchMojomFilePath("%s%s.cc" % (self.module.name, suffix)))