Add support for mojo::TypeConverter to control how convenient conversion should be.

mojo/public/cpp/bindings/array.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_
 
 #include <string.h>
 
 #include <algorithm>
@@ skipping 13 matching lines @@
                                 internal::TypeTraits<T>::kIsObject,
                                 internal::TypeTraits<T>::kIsHandle> Traits_;
   typedef typename Traits_::DataType Data;
   typedef typename Traits_::ConstRef ConstRef;
 
   Array() : data_(NULL) {
   }
 
   template <typename U>
   Array(const U& u, Buffer* buf = Buffer::current()) {
+    MOJO_INTERNAL_CHECK_ALLOW_IMPLICIT_TYPE_CONVERSION(Array<T>, U);
     *this = TypeConverter<Array<T>,U>::ConvertFrom(u, buf);
   }
 
   template <typename U>
   Array& operator=(const U& u) {
+    MOJO_INTERNAL_CHECK_ALLOW_IMPLICIT_TYPE_CONVERSION(Array<T>, U);
     *this = TypeConverter<Array<T>,U>::ConvertFrom(u, Buffer::current());
     return *this;
   }
 
   template <typename U>
   operator U() const {
+    MOJO_INTERNAL_CHECK_ALLOW_IMPLICIT_TYPE_CONVERSION(Array<T>, U);
     return To<U>();
   }
 
   template <typename U>
   U To() const {
     return TypeConverter<Array<T>,U>::ConvertTo(*this);
   }
 
+  template <typename U>
+  static Array From(const U& u, Buffer* buf = Buffer::current()) {
+    return TypeConverter<Array<T>,U>::ConvertFrom(u, buf);
+  }
+
   bool is_null() const { return !data_; }
 
   size_t size() const { return data_->size(); }
 
   ConstRef at(size_t offset) const {
     return Traits_::ToConstRef(data_->at(offset));
   }
   ConstRef operator[](size_t offset) const { return at(offset); }
 
   // Provides a way to initialize an array element-by-element.
@@ skipping 35 matching lines @@
 };
 
 // UTF-8 encoded
 typedef Array<char> String;
 
 template <>
 class TypeConverter<String, std::string> {
  public:
   static String ConvertFrom(const std::string& input, Buffer* buf);
   static std::string ConvertTo(const String& input);
+
+  MOJO_ALLOW_IMPLICIT_TYPE_CONVERSION();
 };
 
 template <size_t N>
 class TypeConverter<String, char[N]> {
  public:
   static String ConvertFrom(const char input[N], Buffer* buf) {
     String::Builder result(N - 1, buf);
     memcpy(&result[0], input, N - 1);
     return result.Finish();
   }
+
+  MOJO_ALLOW_IMPLICIT_TYPE_CONVERSION();
 };
 
 // Appease MSVC.
 template <size_t N>
 class TypeConverter<String, const char[N]> {
  public:
   static String ConvertFrom(const char input[N], Buffer* buf) {
     return TypeConverter<String, char[N]>::ConvertFrom(input, buf);
   }
+
+  MOJO_ALLOW_IMPLICIT_TYPE_CONVERSION();
 };
 
 template <>
 class TypeConverter<String, const char*> {
  public:
   static String ConvertFrom(const char* input, Buffer* buf);
   // NOTE: |ConvertTo| explicitly not implemented since String is not null
   // terminated (and may have embedded null bytes).
+
+  MOJO_ALLOW_IMPLICIT_TYPE_CONVERSION();
 };
 
 template <typename T, typename E>
-class TypeConverter<Array<T>, std::vector<E> > {
+class GenericArrayTypeConverter {
  public:
   static Array<T> ConvertFrom(const std::vector<E>& input, Buffer* buf) {
     typename Array<T>::Builder result(input.size(), buf);
     for (size_t i = 0; i < input.size(); ++i)
       result[i] = TypeConverter<T, E>::ConvertFrom(input[i], buf);
     return result.Finish();
   }
   static std::vector<E> ConvertTo(const Array<T>& input) {
     std::vector<E> result;
     if (!input.is_null()) {
       result.resize(input.size());
       for (size_t i = 0; i < input.size(); ++i)
         result[i] = TypeConverter<T, E>::ConvertTo(input[i]);
     }
     return result;
   }
 };
 
+
+// Implicit conversion is not enabled by default.
+// If you would like to enable that for certain array types, you need to do
+// specializations and specify MOJO_ALLOW_IMPLICIT_TYPE_CONVERSION() yourself.
+//
+// EXAMPLE:
+//
+// namespace mojo {
+// template <>
+// class TypeConverter<Array<X>, std::vector<Y> >
+//     : public GenericArrayTypeConverter<X, Y> {
+//  public:
+//   MOJO_ALLOW_IMPLICIT_TYPE_CONVERSION();
+// };
+// }
+//
+// Please see the comments of MOJO_ALLOW_IMPLICIT_TYPE_CONVERSION() for more
+// details.
+template <typename T, typename E>
+class TypeConverter<Array<T>, std::vector<E> >
+    : public GenericArrayTypeConverter<T, E> {
+};
+
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_