Generate a templated Clone method for all mojo structs.

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 118 matching lines @@
       internal=internal, add_same_module_namespaces=True)
 
 def GetFullMojomNameForKind(kind):
   return _NameFormatter(kind, _variant).FormatForMojom()
 
 def IsTypemappedKind(kind):
   return hasattr(kind, "name") and \
       GetFullMojomNameForKind(kind) in _current_typemap
 
 def IsCloneableKind(kind):
-  return mojom.IsCloneableKind(kind, IsTypemappedKind)
+  return mojom.IsCloneableKind(
+      kind,
+      lambda kind : IsTypemappedKind(kind) and ShouldPassParamByValue(kind))

[yzshen1, 2016/05/26 16:24:14]

I feel that the cloneable check should probably be reconsidered. 

1) this method is used in .tmpl files to determine whether we generate a Clone()
function for the standard auto-generated struct wrapper for |kind|. Even if
|kind| itself is typemapped and should be passed-by-value, it doesn't mean that
the auto-generated class for |kind| shouldn't have a Clone() method.

Example:
//mojom
struct Foo { int32 value; }

The auto-generated Foo class has a Clone() method.
With the current logic, if we map Foo to CustomFoo which is pass-by-value, the
Foo class's Clone() method will disappear. But to me it shouldn't be affected by
the typemapping at all (unless it has fields that are typemapped to something
that is not cloneable.)

2) |kind| should be passed by value doesn't mean it cannot be cloned. All
auto-generated struct wrappers are passed by value but they are cloneable.

One possible alternative:
- We always generate Clone(), but similar to Equals() we use a template so that
it is only instantiated if it is used. That way the code generator doesn't need
to do the check.
- Support an optional Clone() function in StructTraits. If this function is not
defined, the type is not cloneable (or alternatively, we can fall back to try to
use copy assignment).
  (We probably can do the same to Equals().)

WDYT? Thanks!

[Sam McNally, 2016/05/27 02:57:40]

Done for structs.

 
 def IsNativeOnlyKind(kind):
   return mojom.IsStructKind(kind) and kind.native_only
 
 def GetNativeTypeName(typemapped_kind):
   return _current_typemap[GetFullMojomNameForKind(typemapped_kind)]["typename"]
 
 def GetCppType(kind):
   if mojom.IsArrayKind(kind):
     return "mojo::internal::Array_Data<%s>*" % GetCppType(kind.kind)
@@ skipping 376 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)))