1 files changed, 82 insertions, 0 deletions
diff --git a/chromium/mojo/public/cpp/bindings/type_converter.h b/chromium/mojo/public/cpp/bindings/type_converter.h
new file mode 100644
index 00000000000..0ac5f6d4760
--- /dev/null
+++ b/chromium/mojo/public/cpp/bindings/type_converter.h
@@ -0,0 +1,82 @@
+// Copyright 2014 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_TYPE_CONVERTER_H_
+#define MOJO_PUBLIC_CPP_BINDINGS_TYPE_CONVERTER_H_
+
+namespace mojo {
+
+// Specialize the following class:
+//   template <typename T, typename U> class TypeConverter;
+// to perform type conversion for Mojom-defined structs and arrays. Here, T is
+// the Mojom-defined struct or array, and U is some other non-Mojom
+// struct or array type.
+//
+// Specializations should implement the following interface:
+//   namespace mojo {
+//   template <>
+//   class TypeConverter<T, U> {
+//    public:
+//     static T ConvertFrom(const U& input);
+//     static U ConvertTo(const T& input);
+//   };
+//   }
+//
+// EXAMPLE:
+//
+// Suppose you have the following Mojom-defined struct:
+//
+//   module geometry {
+//   struct Point {
+//     int32 x;
+//     int32 y;
+//   };
+//   }
+//
+// Now, imagine you wanted to write a TypeConverter specialization for
+// gfx::Point. It might look like this:
+//
+//   namespace mojo {
+//   template <>
+//   class TypeConverter<geometry::PointPtr, gfx::Point> {
+//    public:
+//     static geometry::PointPtr ConvertFrom(const gfx::Point& input) {
+//       geometry::PointPtr result;
+//       result->x = input.x();
+//       result->y = input.y();
+//       return result.Pass();
+//     }
+//     static gfx::Point ConvertTo(const geometry::PointPtr& input) {
+//       return input ? gfx::Point(input->x, input->y) : gfx::Point();
+//     }
+//   };
+//   }
+//
+// With the above TypeConverter defined, it is possible to write code like this:
+//
+//   void AcceptPoint(const geometry::PointPtr& input) {
+//     // With an explicit cast using the .To<> method.
+//     gfx::Point pt = input.To<gfx::Point>();
+//
+//     // With an explicit cast using the static From() method.
+//     geometry::PointPtr output = geometry::Point::From(pt);
+//   }
+//
+template <typename T, typename U> class TypeConverter;
+
+// The following specialization is useful when you are converting between
+// Array<POD> and std::vector<POD>.
+template <typename T> class TypeConverter<T, T> {
+ public:
+  static T ConvertFrom(const T& obj) {
+    return obj;
+  }
+  static T ConvertTo(const T& obj) {
+    return obj;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // MOJO_PUBLIC_CPP_BINDINGS_TYPE_CONVERTER_H_