Mojo C++ bindings: more consistent Clone() and Equals().

mojo/public/tools/bindings/generators/cpp_templates/wrapper_union_class_declaration.tmpl

 class {{union.name}} {
  public:
   using Data_ = internal::{{union.name}}_Data;
   using Tag = Data_::{{union.name}}_Tag;
 
   static {{union.name}}Ptr New();
 
   template <typename U>
   static {{union.name}}Ptr From(const U& u) {
     return mojo::TypeConverter<{{union.name}}Ptr, U>::Convert(u);
   }
 
   template <typename U>
   U To() const {
     return mojo::TypeConverter<U, {{union.name}}>::Convert(*this);
   }
 
   {{union.name}}();
   ~{{union.name}}();
 
-{%  if union|is_cloneable_kind %}
+  // Clone() is a template so it is only instantiated if it is used. Thus, the
+  // bindings generator does not need to know whether Clone() or copy
+  // constructor/assignment are available for members.
+  template <typename UnionPtrType = {{union.name}}Ptr>
   {{union.name}}Ptr Clone() const;
-{%- endif %}
-  bool Equals(const {{union.name}}& other) const;
+
+  // Equals() is a template so it is only instantiated if it is used. Thus, the
+  // bindings generator does not need to know whether Equals() or == operator
+  // are available for members.
+  template <typename T,
+            typename std::enable_if<std::is_same<
+                T, {{union.name}}>::value>::type* = nullptr>
+  bool Equals(const T& other) const;
 
   Tag which() const {
     return tag_;
   }
 
 {%  for field in union.fields %}
   bool is_{{field.name}}() const;
   {{field.kind|cpp_union_getter_return_type}} get_{{field.name}}() const;
   void set_{{field.name}}({{field.kind|cpp_wrapper_param_type}} {{field.name}});
 {%- endfor %}
@@ skipping 11 matching lines @@
     {{field.kind|cpp_wrapper_type}} {{field.name}};
 {%    endif -%}
 {%- endfor %}
   };
   void SwitchActive(Tag new_active);
   void SetActive(Tag new_active);
   void DestroyActive();
   Tag tag_;
   Union_ data_;
 };