Allow Mojo structs as map keys

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 134 matching lines @@
   if not _use_new_wrapper_types:
     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 GetNameForKind(kind, internal=False, flatten_nested_kind=False):
+def GetNameForKind(kind, internal=False, flatten_nested_kind=False,
+                   add_same_module_namespaces=False):
   return _NameFormatter(kind, _variant).FormatForCpp(
-      internal=internal, flatten_nested_kind=flatten_nested_kind)
+      internal=internal, flatten_nested_kind=flatten_nested_kind,
+      add_same_module_namespaces=add_same_module_namespaces)
 
 def GetQualifiedNameForKind(kind, internal=False, flatten_nested_kind=False):

[yzshen1, 2016/09/22 23:48:56]

Just something to think about, we could remove this now. (No need to do it in
this CL.)

[tibell, 2016/09/23 00:07:08]

Acknowledged.

   return _NameFormatter(kind, _variant).FormatForCpp(
       internal=internal, add_same_module_namespaces=True,
       flatten_nested_kind=flatten_nested_kind)
 
 def GetFullMojomNameForKind(kind):
   return _NameFormatter(kind, _variant).FormatForMojom()
 
 def IsTypemappedKind(kind):
   return hasattr(kind, "name") and \
       GetFullMojomNameForKind(kind) in _current_typemap
 
 def IsNativeOnlyKind(kind):
   return (mojom.IsStructKind(kind) or mojom.IsEnumKind(kind)) and \
       kind.native_only
 
+
+def IsHashableKind(kind):
+  """Check if the kind can be hashed.
+
+  Args:
+    kind: {Kind} The kind to check.
+
+  Returns:
+    {bool} True if a value of this kind can be hashed.
+  """
+  checked = set()
+  def Check(kind):
+    if kind.spec in checked:
+      return True
+    checked.add(kind.spec)
+    if mojom.IsNullableKind(kind):
+      return False
+    elif mojom.IsStructKind(kind):
+      if (kind.native_only or

[yzshen1, 2016/09/22 23:48:56]

As we discussed, native-only types may be hashable.

[tibell, 2016/09/23 00:07:08]

Done.

+          (IsTypemappedKind(kind) and
+           not _current_typemap[GetFullMojomNameForKind(kind)]["hashable"])):
+        return False
+      return all(Check(field.kind) for field in kind.fields)
+    elif mojom.IsUnionKind(kind):
+      return all(Check(field.kind) for field in kind.fields)
+    elif mojom.IsAnyHandleKind(kind):
+      return False
+    elif mojom.IsAnyInterfaceKind(kind):
+      return False
+    elif mojom.IsArrayKind(kind):

[yzshen1, 2016/09/22 23:48:56]

Why array/map are not hashable?

[tibell, 2016/09/23 00:07:08]

We didn't think we'd need it. I've added a TODO. It should be easy to add .

+      return False
+    elif mojom.IsMapKind(kind):
+      return False
+    else:
+      return True
+  return Check(kind)
+
+
 def GetNativeTypeName(typemapped_kind):
   return _current_typemap[GetFullMojomNameForKind(typemapped_kind)]["typename"]
 
 def GetCppPodType(kind):
   if mojom.IsStringKind(kind):
     return "char*"
   return _kind_to_cpp_type[kind]
 
-def GetCppWrapperType(kind):
+def GetCppWrapperType(kind, add_same_module_namespaces=False):
   def _AddOptional(type_name):
     pattern = "WTF::Optional<%s>" if _for_blink else "base::Optional<%s>"
     return pattern % type_name
 
   if IsTypemappedKind(kind):
     type_name = GetNativeTypeName(kind)
     if (mojom.IsNullableKind(kind) and
         not _current_typemap[GetFullMojomNameForKind(kind)][
            "nullable_is_same_type"]):
       type_name = _AddOptional(type_name)
     return type_name
   if mojom.IsEnumKind(kind):
-    return GetNameForKind(kind)
+    return GetNameForKind(
+        kind, add_same_module_namespaces=add_same_module_namespaces)
   if mojom.IsStructKind(kind) or mojom.IsUnionKind(kind):
-    return "%sPtr" % GetNameForKind(kind)
+    return "%sPtr" % GetNameForKind(
+        kind, add_same_module_namespaces=add_same_module_namespaces)
   if mojom.IsArrayKind(kind):
     pattern = None
     if _use_new_wrapper_types:
       pattern = "WTF::Vector<%s>" if _for_blink else "std::vector<%s>"
       if mojom.IsNullableKind(kind):
         pattern = _AddOptional(pattern)
     else:
       pattern = "mojo::WTFArray<%s>" if _for_blink else "mojo::Array<%s>"
-    return pattern % GetCppWrapperType(kind.kind)
+    return pattern % GetCppWrapperType(
+        kind.kind, add_same_module_namespaces=add_same_module_namespaces)
   if mojom.IsMapKind(kind):
     pattern = None
     if _use_new_wrapper_types:
       pattern = ("WTF::HashMap<%s, %s>" if _for_blink else
                  "std::unordered_map<%s, %s>")
       if mojom.IsNullableKind(kind):
         pattern = _AddOptional(pattern)
     else:
       pattern = "mojo::WTFMap<%s, %s>" if _for_blink else "mojo::Map<%s, %s>"
-    return pattern % (GetCppWrapperType(kind.key_kind),
-                      GetCppWrapperType(kind.value_kind))
+    return pattern % (
+        GetCppWrapperType(
+            kind.key_kind,
+            add_same_module_namespaces=add_same_module_namespaces),
+        GetCppWrapperType(
+            kind.value_kind,
+            add_same_module_namespaces=add_same_module_namespaces))
   if mojom.IsInterfaceKind(kind):
-    return "%sPtr" % GetNameForKind(kind)
+    return "%sPtr" % GetNameForKind(
+        kind, add_same_module_namespaces=add_same_module_namespaces)
   if mojom.IsInterfaceRequestKind(kind):
-    return "%sRequest" % GetNameForKind(kind.kind)
+    return "%sRequest" % GetNameForKind(
+        kind.kind, add_same_module_namespaces=add_same_module_namespaces)
   if mojom.IsAssociatedInterfaceKind(kind):
-    return "%sAssociatedPtrInfo" % GetNameForKind(kind.kind)
+    return "%sAssociatedPtrInfo" % GetNameForKind(
+        kind.kind, add_same_module_namespaces=add_same_module_namespaces)
   if mojom.IsAssociatedInterfaceRequestKind(kind):
-    return "%sAssociatedRequest" % GetNameForKind(kind.kind)
+    return "%sAssociatedRequest" % GetNameForKind(
+        kind.kind, add_same_module_namespaces=add_same_module_namespaces)
   if mojom.IsStringKind(kind):
     if _for_blink:
       return "WTF::String"
     if not _use_new_wrapper_types:
       return "mojo::String"
     type_name = "std::string"
     return _AddOptional(type_name) if mojom.IsNullableKind(kind) else type_name
   if mojom.IsGenericHandleKind(kind):
     return "mojo::ScopedHandle"
   if mojom.IsDataPipeConsumerKind(kind):
@@ skipping 69 matching lines @@
 def GetCppUnionFieldType(kind):
   if mojom.IsUnionKind(kind):
     return ("mojo::internal::Pointer<%s>" % GetNameForKind(kind, internal=True))
   return GetCppFieldType(kind)
 
 def GetUnionGetterReturnType(kind):
   if mojom.IsReferenceKind(kind):
     return "%s&" % GetCppWrapperType(kind)
   return GetCppWrapperType(kind)
 
+def GetUnionTraitGetterReturnType(kind):
+  """Get field type used in UnionTraits template specialization.
+
+  The type may be qualified as UnionTraits specializations live outside the
+  namespace where e.g. structs are defined.
+
+  Args:
+    kind: {Kind} The type of the field.
+
+  Returns:
+    {str} The C++ type to use for the field.
+  """
+  if mojom.IsReferenceKind(kind):
+    return "%s&" % GetCppWrapperType(kind, add_same_module_namespaces=True)
+  return GetCppWrapperType(kind, add_same_module_namespaces=True)
+
 def GetCppDataViewType(kind, qualified=False):
   def _GetName(input_kind):
     return _NameFormatter(input_kind, None).FormatForCpp(
         add_same_module_namespaces=qualified, flatten_nested_kind=True)
 
   if mojom.IsEnumKind(kind):
     return _GetName(kind)
   if mojom.IsStructKind(kind) or mojom.IsUnionKind(kind):
     return "%sDataView" % _GetName(kind)
   if mojom.IsArrayKind(kind):
@@ skipping 132 matching lines @@
       not mojom.IsStringKind(kind)):
     return "nullptr"
 
   return "new mojo::internal::ContainerValidateParams(%s)" % (
       GetContainerValidateParamsCtorArgs(kind))
 
 class Generator(generator.Generator):
 
   cpp_filters = {
     "constant_value": ConstantValue,
+    "contains_handles": mojom.ContainsHandles,
     "contains_move_only_members": ContainsMoveOnlyMembers,
     "cpp_wrapper_param_type": GetCppWrapperParamType,
     "cpp_data_view_type": GetCppDataViewType,
     "cpp_field_type": GetCppFieldType,
     "cpp_union_field_type": GetCppUnionFieldType,
     "cpp_pod_type": GetCppPodType,
     "cpp_union_getter_return_type": GetUnionGetterReturnType,
+    "cpp_union_trait_getter_return_type": GetUnionTraitGetterReturnType,
     "cpp_wrapper_type": GetCppWrapperType,
     "default_value": DefaultValue,
     "expression_to_text": ExpressionToText,
     "get_container_validate_params_ctor_args":
         GetContainerValidateParamsCtorArgs,
     "get_name_for_kind": GetNameForKind,
     "get_pad": pack.GetPad,
     "get_qualified_name_for_kind": GetQualifiedNameForKind,
     "has_callbacks": mojom.HasCallbacks,
     "has_sync_methods": mojom.HasSyncMethods,
     "requires_context_for_data_view": RequiresContextForDataView,
     "should_inline": ShouldInlineStruct,
     "should_inline_union": ShouldInlineUnion,
     "is_array_kind": mojom.IsArrayKind,
     "is_enum_kind": mojom.IsEnumKind,
     "is_integral_kind": mojom.IsIntegralKind,
     "is_native_only_kind": IsNativeOnlyKind,
     "is_any_handle_kind": mojom.IsAnyHandleKind,
     "is_any_interface_kind": mojom.IsAnyInterfaceKind,
     "is_any_handle_or_interface_kind": mojom.IsAnyHandleOrInterfaceKind,
     "is_associated_kind": mojom.IsAssociatedKind,
+    "is_hashable": IsHashableKind,
     "is_map_kind": mojom.IsMapKind,
     "is_nullable_kind": mojom.IsNullableKind,
     "is_object_kind": mojom.IsObjectKind,
+    "is_reference_kind": mojom.IsReferenceKind,
     "is_string_kind": mojom.IsStringKind,
     "is_struct_kind": mojom.IsStructKind,
     "is_typemapped_kind": IsTypemappedKind,
     "is_union_kind": mojom.IsUnionKind,
     "passes_associated_kinds": mojom.PassesAssociatedKinds,
     "struct_size": lambda ps: ps.GetTotalSize() + _HEADER_SIZE,
     "stylize_method": generator.StudlyCapsToCamel,
     "under_to_camel": generator.UnderToCamel,
     "unmapped_type_for_serializer": GetUnmappedTypeForSerializer,
   }
@@ skipping 84 matching lines @@
       global _use_new_wrapper_types
       _use_new_wrapper_types = self.use_new_wrapper_types
       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.GenerateModuleSource(),
           self.MatchMojomFilePath("%s%s.cc" % (self.module.name, suffix)))