Allow Mojo structs as map keys

mojo/public/tools/bindings/pylib/mojom/generate/module.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.
 
 # This module's classes provide an interface to mojo modules. Modules are
 # collections of interfaces and structs to be used by mojo ipc clients and
 # servers.
 #
 # A simple interface would be created this way:
 # module = mojom.generate.module.Module('Foo')
@@ skipping 276 matching lines @@
         if self.attributes else None
 
 
 class StructField(Field): pass
 
 
 class UnionField(Field): pass
 
 
 class Struct(ReferenceKind):
+  """A struct with typed fields.
+
+  Attributes:
+    name: {str} The name of the struct type.
+    native_only: {bool} Does the struct have a body (i.e. any fields) or is it
+        purely a native struct that must be type-mapped.
+    module: {Module} The defining module.
+    imported_from: {dict} Information about where this union was
+        imported from.
+    fields: {List[StructField]} The members of the union.
+    attributes: {dict} Additional information about the struct, such as
+        which Java class name to use to represent it in the generated
+        bindings.
+  """
+
   ReferenceKind.AddSharedProperty('name')
   ReferenceKind.AddSharedProperty('native_only')
   ReferenceKind.AddSharedProperty('module')
   ReferenceKind.AddSharedProperty('imported_from')
   ReferenceKind.AddSharedProperty('fields')
   ReferenceKind.AddSharedProperty('attributes')
 
   def __init__(self, name=None, module=None, attributes=None):
     if name is not None:
       spec = 'x:' + name
@@ skipping 111 matching lines @@
   ReferenceKind.AddSharedProperty('key_kind')
   ReferenceKind.AddSharedProperty('value_kind')
 
   def __init__(self, key_kind=None, value_kind=None):
     if (key_kind is not None and value_kind is not None):
       ReferenceKind.__init__(self,
                              'm[' + key_kind.spec + '][' + value_kind.spec +
                              ']')
       if IsNullableKind(key_kind):
         raise Exception("Nullable kinds cannot be keys in maps.")
-      if IsStructKind(key_kind):
-        # TODO(erg): It would sometimes be nice if we could key on struct
-        # values. However, what happens if the struct has a handle in it? Or
-        # non-copyable data like an array?
-        raise Exception("Structs cannot be keys in maps.")
       if IsAnyHandleKind(key_kind):
         raise Exception("Handles cannot be keys in maps.")
       if IsAnyInterfaceKind(key_kind):
         raise Exception("Interfaces cannot be keys in maps.")
       if IsArrayKind(key_kind):
         raise Exception("Arrays cannot be keys in maps.")
     else:
       ReferenceKind.__init__(self)
 
     self.key_kind = key_kind
@@ skipping 390 matching lines @@
         if _ContainsAssociatedKinds(param.kind, visited_kinds):
           return True
   return False
 
 
 def HasSyncMethods(interface):
   for method in interface.methods:
     if method.sync:
       return True
   return False
+
+
+def ContainsHandles(kind):
+  """Check if the kind contains any handles.
+
+  This check is recursive so it checks all struct fields, containers elements,
+  etc.
+
+  Args:
+    struct: {Kind} The kind to check.
+
+  Returns:
+    {bool}: True if the kind contains handles.
+  """
+  # We remember the types we already checked to avoid infinite recursion when
+  # checking recursive (or mutually recursive) types:
+  checked = set()
+  def Check(kind):
+    if kind.spec in checked:
+      return False
+    checked.add(kind.spec)
+    if IsStructKind(kind):
+      if kind.native_only:
+        # TODO(tibell): We don't know if user-defined types contain handles.

[yzshen1, 2016/09/20 23:44:40]

Native-only types are serialized using old IPC::ParamsTraits and considered as a
byte blob, so it shouldn't contain any handle.

[tibell, 2016/09/21 07:10:54]

Done.

+        return True
+      return any(Check(field.kind) for field in kind.fields)
+    elif IsUnionKind(kind):
+      return any(Check(field.kind) for field in kind.fields)
+    elif IsAnyHandleKind(kind):
+      return True
+    elif IsAnyInterfaceKind(kind):
+      # Interfaces are wrappers around handles.
+      return True
+    elif IsArrayKind(kind):
+      return Check(kind.kind)
+    elif IsMapKind(kind):
+      return Check(kind.key_kind) or Check(kind.value_kind)
+    else:
+      return False
+  return Check(kind)