Change TypeConverter<X,Y>::ConvertFrom and ConvertTo into a single symmetric

Convert method.

Also added a ConvertTo<X> helper function.

Also changed it from class to struct, since every method was public.

BUG=406492

Review URL: https://codereview.chromium.org/507173003

Cr-Commit-Position: refs/heads/master@{#293027}

28 files changed, 331 insertions, 305 deletions

diff --git a/mojo/common/common_type_converters.cc b/mojo/common/common_type_converters.cc
index 2439432..ffc1907 100644
--- a/mojo/common/common_type_converters.cc
+++ b/mojo/common/common_type_converters.cc
@@ -12,7 +12,7 @@
 namespace mojo {
 
 // static
-String TypeConverter<String, base::StringPiece>::ConvertFrom(
+String TypeConverter<String, base::StringPiece>::Convert(
     const base::StringPiece& input) {
   if (input.empty()) {
     char c = 0;
@@ -21,29 +21,28 @@ String TypeConverter<String, base::StringPiece>::ConvertFrom(
   return String(input.data(), input.size());
 }
 // static
-base::StringPiece TypeConverter<String, base::StringPiece>::ConvertTo(
+base::StringPiece TypeConverter<base::StringPiece, String>::Convert(
     const String& input) {
   return input.get();
 }
 
 // static
-String TypeConverter<String, base::string16>::ConvertFrom(
+String TypeConverter<String, base::string16>::Convert(
     const base::string16& input) {
-  return TypeConverter<String, base::StringPiece>::ConvertFrom(
+  return TypeConverter<String, base::StringPiece>::Convert(
       base::UTF16ToUTF8(input));
 }
 // static
-base::string16 TypeConverter<String, base::string16>::ConvertTo(
+base::string16 TypeConverter<base::string16, String>::Convert(
     const String& input) {
-  return base::UTF8ToUTF16(TypeConverter<String, base::StringPiece>::ConvertTo(
-      input));
+  return base::UTF8ToUTF16(input.To<base::StringPiece>());
 }
 
-String TypeConverter<String, GURL>::ConvertFrom(const GURL& input) {
+String TypeConverter<String, GURL>::Convert(const GURL& input) {
   return String(input.spec());
 }
 
-GURL TypeConverter<String, GURL>::ConvertTo(const String& input) {
+GURL TypeConverter<GURL, String>::Convert(const String& input) {
   return GURL(input.get());
 }
 
diff --git a/mojo/common/common_type_converters.h b/mojo/common/common_type_converters.h
index 9afbfc6..159325e 100644
--- a/mojo/common/common_type_converters.h
+++ b/mojo/common/common_type_converters.h
@@ -16,24 +16,33 @@ class GURL;
 namespace mojo {
 
 template <>
-class MOJO_COMMON_EXPORT TypeConverter<String, base::StringPiece> {
- public:
-  static String ConvertFrom(const base::StringPiece& input);
-  static base::StringPiece ConvertTo(const String& input);
+struct MOJO_COMMON_EXPORT TypeConverter<String, base::StringPiece> {
+  static String Convert(const base::StringPiece& input);
 };
 
 template <>
-class MOJO_COMMON_EXPORT TypeConverter<String, base::string16> {
- public:
-  static String ConvertFrom(const base::string16& input);
-  static base::string16 ConvertTo(const String& input);
+struct MOJO_COMMON_EXPORT TypeConverter<base::StringPiece, String> {
+  static base::StringPiece Convert(const String& input);
 };
 
 template <>
-class MOJO_COMMON_EXPORT TypeConverter<String, GURL> {
- public:
-  static String ConvertFrom(const GURL& input);
-  static GURL ConvertTo(const String& input);
+struct MOJO_COMMON_EXPORT TypeConverter<String, base::string16> {
+  static String Convert(const base::string16& input);
+};
+
+template <>
+struct MOJO_COMMON_EXPORT TypeConverter<base::string16, String> {
+  static base::string16 Convert(const String& input);
+};
+
+template <>
+struct MOJO_COMMON_EXPORT TypeConverter<String, GURL> {
+  static String Convert(const GURL& input);
+};
+
+template <>
+struct MOJO_COMMON_EXPORT TypeConverter<GURL, String> {
+  static GURL Convert(const String& input);
 };
 
 }  // namespace mojo
diff --git a/mojo/examples/pepper_container_app/type_converters.h b/mojo/examples/pepper_container_app/type_converters.h
index 0f02a0a..9bb2fb1 100644
--- a/mojo/examples/pepper_container_app/type_converters.h
+++ b/mojo/examples/pepper_container_app/type_converters.h
@@ -14,16 +14,18 @@
 namespace mojo {
 
 template <>
-class TypeConverter<PointPtr, PP_Point> {
- public:
-  static PointPtr ConvertFrom(const PP_Point& input) {
+struct TypeConverter<PointPtr, PP_Point> {
+  static PointPtr Convert(const PP_Point& input) {
     PointPtr point(Point::New());
     point->x = input.x;
     point->y = input.y;
     return point.Pass();
   }
+};
 
-  static PP_Point ConvertTo(const PointPtr& input) {
+template <>
+struct TypeConverter<PP_Point, PointPtr> {
+  static PP_Point Convert(const PointPtr& input) {
     if (!input)
       return PP_MakePoint(0, 0);
     return PP_MakePoint(static_cast<int32_t>(input->x),
@@ -32,16 +34,18 @@ class TypeConverter<PointPtr, PP_Point> {
 };
 
 template <>
-class TypeConverter<SizePtr, PP_Size> {
- public:
-  static SizePtr ConvertFrom(const PP_Size& input) {
+struct TypeConverter<SizePtr, PP_Size> {
+  static SizePtr Convert(const PP_Size& input) {
     SizePtr size(Size::New());
     size->width = input.width;
     size->height = input.height;
     return size.Pass();
   }
+};
 
-  static PP_Size ConvertTo(const SizePtr& input) {
+template <>
+struct TypeConverter<PP_Size, SizePtr> {
+  static PP_Size Convert(const SizePtr& input) {
     if (!input)
       return PP_MakeSize(0, 0);
     return PP_MakeSize(static_cast<int32_t>(input->width),
@@ -50,9 +54,8 @@ class TypeConverter<SizePtr, PP_Size> {
 };
 
 template <>
-class TypeConverter<RectPtr, PP_Rect> {
- public:
-  static RectPtr ConvertFrom(const PP_Rect& input) {
+struct TypeConverter<RectPtr, PP_Rect> {
+  static RectPtr Convert(const PP_Rect& input) {
     RectPtr rect(Rect::New());
     rect->x = input.point.x;
     rect->y = input.point.y;
@@ -60,8 +63,11 @@ class TypeConverter<RectPtr, PP_Rect> {
     rect->height = input.size.height;
     return rect.Pass();
   }
+};
 
-  static PP_Rect ConvertTo(const RectPtr& input) {
+template <>
+struct TypeConverter<PP_Rect, RectPtr> {
+  static PP_Rect Convert(const RectPtr& input) {
     if (!input)
       return PP_MakeRectFromXYWH(0, 0, 0, 0);
     return PP_MakeRectFromXYWH(input->x, input->y,
diff --git a/mojo/public/cpp/bindings/array.h b/mojo/public/cpp/bindings/array.h
index daf7125..9b5aff8 100644
--- a/mojo/public/cpp/bindings/array.h
+++ b/mojo/public/cpp/bindings/array.h
@@ -50,12 +50,12 @@ class Array {
 
   template <typename U>
   static Array From(const U& other) {
-    return TypeConverter<Array, U>::ConvertFrom(other);
+    return TypeConverter<Array, U>::Convert(other);
   }
 
   template <typename U>
   U To() const {
-    return TypeConverter<Array, U>::ConvertTo(*this);
+    return TypeConverter<U, Array>::Convert(*this);
   }
 
   void reset() {
@@ -119,20 +119,23 @@ class Array {
 };
 
 template <typename T, typename E>
-class TypeConverter<Array<T>, std::vector<E> > {
- public:
-  static Array<T> ConvertFrom(const std::vector<E>& input) {
+struct TypeConverter<Array<T>, std::vector<E> > {
+  static Array<T> Convert(const std::vector<E>& input) {
     Array<T> result(input.size());
     for (size_t i = 0; i < input.size(); ++i)
-      result[i] = TypeConverter<T, E>::ConvertFrom(input[i]);
+      result[i] = TypeConverter<T, E>::Convert(input[i]);
     return result.Pass();
   }
-  static std::vector<E> ConvertTo(const Array<T>& input) {
+};
+
+template <typename E, typename T>
+struct TypeConverter<std::vector<E>, Array<T> > {
+  static std::vector<E> Convert(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]);
+        result[i] = TypeConverter<E, T>::Convert(input[i]);
     }
     return result;
   }
diff --git a/mojo/public/cpp/bindings/string.h b/mojo/public/cpp/bindings/string.h
index 872dbca..cd7db26 100644
--- a/mojo/public/cpp/bindings/string.h
+++ b/mojo/public/cpp/bindings/string.h
@@ -32,12 +32,12 @@ class String {
 
   template <typename U>
   static String From(const U& other) {
-    return TypeConverter<String, U>::ConvertFrom(other);
+    return TypeConverter<String, U>::Convert(other);
   }
 
   template <typename U>
   U To() const {
-    return TypeConverter<String, U>::ConvertTo(*this);
+    return TypeConverter<U, String>::Convert(*this);
   }
 
   String& operator=(const std::string& str) {
@@ -113,20 +113,18 @@ inline std::ostream& operator<<(std::ostream& out, const String& s) {
 // TODO(darin): Add similar variants of operator<,<=,>,>=
 
 template <>
-class TypeConverter<String, std::string> {
- public:
-  static String ConvertFrom(const std::string& input) {
-    return String(input);
-  }
-  static std::string ConvertTo(const String& input) {
-    return input;
-  }
+struct TypeConverter<String, std::string> {
+  static String Convert(const std::string& input) { return String(input); }
+};
+
+template <>
+struct TypeConverter<std::string, String> {
+  static std::string Convert(const String& input) { return input; }
 };
 
 template <size_t N>
-class TypeConverter<String, char[N]> {
- public:
-  static String ConvertFrom(const char input[N]) {
+struct TypeConverter<String, char[N]> {
+  static String Convert(const char input[N]) {
     MOJO_DCHECK(input);
     return String(input, N-1);
   }
@@ -134,21 +132,17 @@ class TypeConverter<String, char[N]> {
 
 // Appease MSVC.
 template <size_t N>
-class TypeConverter<String, const char[N]> {
- public:
-  static String ConvertFrom(const char input[N]) {
+struct TypeConverter<String, const char[N]> {
+  static String Convert(const char input[N]) {
     MOJO_DCHECK(input);
     return String(input, N-1);
   }
 };
 
 template <>
-class TypeConverter<String, const char*> {
- public:
+struct TypeConverter<String, const char*> {
   // |input| may be null, in which case a null String will be returned.
-  static String ConvertFrom(const char* input) {
-    return String(input);
-  }
+  static String Convert(const char* input) { return String(input); }
 };
 
 }  // namespace mojo
diff --git a/mojo/public/cpp/bindings/struct_ptr.h b/mojo/public/cpp/bindings/struct_ptr.h
index ad77d60..12ec135 100644
--- a/mojo/public/cpp/bindings/struct_ptr.h
+++ b/mojo/public/cpp/bindings/struct_ptr.h
@@ -41,7 +41,7 @@ class StructPtr {
 
   template <typename U>
   U To() const {
-    return TypeConverter<StructPtr, U>::ConvertTo(*this);
+    return TypeConverter<U, StructPtr>::Convert(*this);
   }
 
   void reset() {
@@ -106,7 +106,7 @@ class InlinedStructPtr {
 
   template <typename U>
   U To() const {
-    return TypeConverter<InlinedStructPtr, U>::ConvertTo(*this);
+    return TypeConverter<U, InlinedStructPtr>::Convert(*this);
   }
 
   void reset() {
diff --git a/mojo/public/cpp/bindings/tests/sample_service_unittest.cc b/mojo/public/cpp/bindings/tests/sample_service_unittest.cc
index e27512c..c64ee9a 100644
--- a/mojo/public/cpp/bindings/tests/sample_service_unittest.cc
+++ b/mojo/public/cpp/bindings/tests/sample_service_unittest.cc
@@ -14,9 +14,8 @@
 namespace mojo {
 
 template <>
-class TypeConverter<sample::BarPtr, int32_t> {
- public:
-  static int32_t ConvertTo(const sample::BarPtr& bar) {
+struct TypeConverter<int32_t, sample::BarPtr> {
+  static int32_t Convert(const sample::BarPtr& bar) {
     return static_cast<int32_t>(bar->alpha) << 16 |
            static_cast<int32_t>(bar->beta) << 8 |
            static_cast<int32_t>(bar->gamma);
diff --git a/mojo/public/cpp/bindings/tests/type_conversion_unittest.cc b/mojo/public/cpp/bindings/tests/type_conversion_unittest.cc
index ed652a1..8b0e940 100644
--- a/mojo/public/cpp/bindings/tests/type_conversion_unittest.cc
+++ b/mojo/public/cpp/bindings/tests/type_conversion_unittest.cc
@@ -41,9 +41,8 @@ bool AreEqualRectArrays(const Array<test::RectPtr>& rects1,
 }  // namespace
 
 template <>
-class TypeConverter<test::RectPtr, RedmondRect> {
- public:
-  static test::RectPtr ConvertFrom(const RedmondRect& input) {
+struct TypeConverter<test::RectPtr, RedmondRect> {
+  static test::RectPtr Convert(const RedmondRect& input) {
     test::RectPtr rect(test::Rect::New());
     rect->x = input.left;
     rect->y = input.top;
@@ -51,7 +50,11 @@ class TypeConverter<test::RectPtr, RedmondRect> {
     rect->height = input.bottom - input.top;
     return rect.Pass();
   }
-  static RedmondRect ConvertTo(const test::RectPtr& input) {
+};
+
+template <>
+struct TypeConverter<RedmondRect, test::RectPtr> {
+  static RedmondRect Convert(const test::RectPtr& input) {
     RedmondRect rect;
     rect.left = input->x;
     rect.top = input->y;
@@ -62,15 +65,18 @@ class TypeConverter<test::RectPtr, RedmondRect> {
 };
 
 template <>
-class TypeConverter<test::NamedRegionPtr, RedmondNamedRegion> {
- public:
-  static test::NamedRegionPtr ConvertFrom(const RedmondNamedRegion& input) {
+struct TypeConverter<test::NamedRegionPtr, RedmondNamedRegion> {
+  static test::NamedRegionPtr Convert(const RedmondNamedRegion& input) {
     test::NamedRegionPtr region(test::NamedRegion::New());
     region->name = input.name;
     region->rects = Array<test::RectPtr>::From(input.rects);
     return region.Pass();
   }
-  static RedmondNamedRegion ConvertTo(const test::NamedRegionPtr& input) {
+};
+
+template <>
+struct TypeConverter<RedmondNamedRegion, test::NamedRegionPtr> {
+  static RedmondNamedRegion Convert(const test::NamedRegionPtr& input) {
     RedmondNamedRegion region;
     region.name = input->name;
     region.rects = input->rects.To<std::vector<RedmondRect> >();
diff --git a/mojo/public/cpp/bindings/type_converter.h b/mojo/public/cpp/bindings/type_converter.h
index 0ac5f6d..ff94cda 100644
--- a/mojo/public/cpp/bindings/type_converter.h
+++ b/mojo/public/cpp/bindings/type_converter.h
@@ -8,18 +8,19 @@
 namespace mojo {
 
 // Specialize the following class:
-//   template <typename T, typename U> class TypeConverter;
+//   template <typename T, typename U> struct 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.
+// the target type; U is the input type.
 //
-// Specializations should implement the following interface:
+// Specializations should implement the following interfaces:
 //   namespace mojo {
 //   template <>
-//   class TypeConverter<T, U> {
-//    public:
-//     static T ConvertFrom(const U& input);
-//     static U ConvertTo(const T& input);
+//   struct TypeConverter<X, Y> {
+//     static X Convert(const Y& input);
+//   };
+//   template <>
+//   struct TypeConverter<Y, X> {
+//     static Y Convert(const X& input);
 //   };
 //   }
 //
@@ -39,15 +40,17 @@ namespace mojo {
 //
 //   namespace mojo {
 //   template <>
-//   class TypeConverter<geometry::PointPtr, gfx::Point> {
-//    public:
-//     static geometry::PointPtr ConvertFrom(const gfx::Point& input) {
+//   struct TypeConverter<geometry::PointPtr, gfx::Point> {
+//     static geometry::PointPtr Convert(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) {
+//   };
+//   template <>
+//   struct TypeConverter<gfx::Point, geometry::PointPtr> {
+//     static gfx::Point Convert(const geometry::PointPtr& input) {
 //       return input ? gfx::Point(input->x, input->y) : gfx::Point();
 //     }
 //   };
@@ -61,20 +64,27 @@ namespace mojo {
 //
 //     // With an explicit cast using the static From() method.
 //     geometry::PointPtr output = geometry::Point::From(pt);
+//
+//     // Inferring the input type using the ConvertTo helper function.
+//     gfx::Point pt2 = ConvertTo<gfx::Point>(input);
 //   }
 //
-template <typename T, typename U> class TypeConverter;
+template <typename T, typename U>
+struct 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;
-  }
+template <typename T>
+struct TypeConverter<T, T> {
+  static T Convert(const T& obj) { return obj; }
+};
+
+// The following helper function is useful for shorthand. The compiler can infer
+// the input type, so you can write:
+//   OutputType out = ConvertTo<OutputType>(input);
+template <typename T, typename U>
+inline T ConvertTo(const U& obj) {
+  return TypeConverter<T, U>::Convert(obj);
 };
 
 }  // namespace mojo
diff --git a/mojo/public/tools/bindings/generators/cpp_templates/wrapper_class_declaration.tmpl b/mojo/public/tools/bindings/generators/cpp_templates/wrapper_class_declaration.tmpl
index 0e01976c..3f426a5 100644
--- a/mojo/public/tools/bindings/generators/cpp_templates/wrapper_class_declaration.tmpl
+++ b/mojo/public/tools/bindings/generators/cpp_templates/wrapper_class_declaration.tmpl
@@ -16,7 +16,7 @@ class {{struct.name}} {
 
   template <typename U>
   static {{struct.name}}Ptr From(const U& u) {
-    return mojo::TypeConverter<{{struct.name}}Ptr, U>::ConvertFrom(u);
+    return mojo::TypeConverter<{{struct.name}}Ptr, U>::Convert(u);
   }
 
   {{struct.name}}();
diff --git a/mojo/services/gles2/command_buffer_type_conversions.cc b/mojo/services/gles2/command_buffer_type_conversions.cc
index 3952bef..a144f88 100644
--- a/mojo/services/gles2/command_buffer_type_conversions.cc
+++ b/mojo/services/gles2/command_buffer_type_conversions.cc
@@ -9,7 +9,7 @@
 namespace mojo {
 
 CommandBufferStatePtr
-TypeConverter<CommandBufferStatePtr, gpu::CommandBuffer::State>::ConvertFrom(
+TypeConverter<CommandBufferStatePtr, gpu::CommandBuffer::State>::Convert(
     const gpu::CommandBuffer::State& input) {
   CommandBufferStatePtr result(CommandBufferState::New());
   result->num_entries = input.num_entries;
@@ -23,7 +23,7 @@ TypeConverter<CommandBufferStatePtr, gpu::CommandBuffer::State>::ConvertFrom(
 }
 
 gpu::CommandBuffer::State
-TypeConverter<CommandBufferStatePtr, gpu::CommandBuffer::State>::ConvertTo(
+TypeConverter<gpu::CommandBuffer::State, CommandBufferStatePtr>::Convert(
     const CommandBufferStatePtr& input) {
   gpu::CommandBuffer::State state;
   state.num_entries = input->num_entries;
diff --git a/mojo/services/gles2/command_buffer_type_conversions.h b/mojo/services/gles2/command_buffer_type_conversions.h
index b2334d0..2579681 100644
--- a/mojo/services/gles2/command_buffer_type_conversions.h
+++ b/mojo/services/gles2/command_buffer_type_conversions.h
@@ -14,12 +14,13 @@ namespace mojo {
 class CommandBufferState;
 
 template <>
-class TypeConverter<CommandBufferStatePtr, gpu::CommandBuffer::State> {
- public:
-  static CommandBufferStatePtr ConvertFrom(
-      const gpu::CommandBuffer::State& input);
-  static gpu::CommandBuffer::State ConvertTo(
-      const CommandBufferStatePtr& input);
+struct TypeConverter<CommandBufferStatePtr, gpu::CommandBuffer::State> {
+  static CommandBufferStatePtr Convert(const gpu::CommandBuffer::State& input);
+};
+
+template <>
+struct TypeConverter<gpu::CommandBuffer::State, CommandBufferStatePtr> {
+  static gpu::CommandBuffer::State Convert(const CommandBufferStatePtr& input);
 };
 
 }  // namespace mojo
diff --git a/mojo/services/html_viewer/blink_input_events_type_converters.cc b/mojo/services/html_viewer/blink_input_events_type_converters.cc
index 2e15c0d..ff1a2cb 100644
--- a/mojo/services/html_viewer/blink_input_events_type_converters.cc
+++ b/mojo/services/html_viewer/blink_input_events_type_converters.cc
@@ -180,7 +180,7 @@ scoped_ptr<blink::WebInputEvent> BuildWebMouseWheelEventFrom(
 
 // static
 scoped_ptr<blink::WebInputEvent>
-TypeConverter<EventPtr, scoped_ptr<blink::WebInputEvent> >::ConvertTo(
+TypeConverter<scoped_ptr<blink::WebInputEvent>, EventPtr>::Convert(
     const EventPtr& event) {
   if (event->action == EVENT_TYPE_MOUSE_PRESSED ||
       event->action == EVENT_TYPE_MOUSE_RELEASED ||
diff --git a/mojo/services/html_viewer/blink_input_events_type_converters.h b/mojo/services/html_viewer/blink_input_events_type_converters.h
index e40c02d..3d5860d 100644
--- a/mojo/services/html_viewer/blink_input_events_type_converters.h
+++ b/mojo/services/html_viewer/blink_input_events_type_converters.h
@@ -14,10 +14,9 @@ class WebInputEvent;
 
 namespace mojo {
 
-template<>
-class TypeConverter<EventPtr, scoped_ptr<blink::WebInputEvent> > {
- public:
-  static scoped_ptr<blink::WebInputEvent> ConvertTo(const EventPtr& input);
+template <>
+struct TypeConverter<scoped_ptr<blink::WebInputEvent>, EventPtr> {
+  static scoped_ptr<blink::WebInputEvent> Convert(const EventPtr& input);
 };
 
 }  // namespace mojo
diff --git a/mojo/services/html_viewer/blink_url_request_type_converters.cc b/mojo/services/html_viewer/blink_url_request_type_converters.cc
index 1f6553e..9428d92 100644
--- a/mojo/services/html_viewer/blink_url_request_type_converters.cc
+++ b/mojo/services/html_viewer/blink_url_request_type_converters.cc
@@ -91,7 +91,7 @@ void AddRequestBody(URLRequest* url_request,
 
 } // namespace
 
-URLRequestPtr TypeConverter<URLRequestPtr, blink::WebURLRequest>::ConvertFrom(
+URLRequestPtr TypeConverter<URLRequestPtr, blink::WebURLRequest>::Convert(
     const blink::WebURLRequest& request) {
   URLRequestPtr url_request(URLRequest::New());
   url_request->url = request.url().string().utf8();
diff --git a/mojo/services/html_viewer/blink_url_request_type_converters.h b/mojo/services/html_viewer/blink_url_request_type_converters.h
index 21c3492..583d0ba 100644
--- a/mojo/services/html_viewer/blink_url_request_type_converters.h
+++ b/mojo/services/html_viewer/blink_url_request_type_converters.h
@@ -13,10 +13,9 @@ class WebURLRequest;
 
 namespace mojo {
 
-template<>
-class TypeConverter<URLRequestPtr, blink::WebURLRequest> {
- public:
-  static URLRequestPtr ConvertFrom(const blink::WebURLRequest& request);
+template <>
+struct TypeConverter<URLRequestPtr, blink::WebURLRequest> {
+  static URLRequestPtr Convert(const blink::WebURLRequest& request);
 };
 
 }  // namespace mojo
diff --git a/mojo/services/html_viewer/html_document_view.cc b/mojo/services/html_viewer/html_document_view.cc
index f7a08cb..3408c35 100644
--- a/mojo/services/html_viewer/html_document_view.cc
+++ b/mojo/services/html_viewer/html_document_view.cc
@@ -214,8 +214,7 @@ void HTMLDocumentView::OnViewDestroyed(View* view) {
 
 void HTMLDocumentView::OnViewInputEvent(View* view, const EventPtr& event) {
   scoped_ptr<blink::WebInputEvent> web_event =
-      TypeConverter<EventPtr, scoped_ptr<blink::WebInputEvent> >::ConvertTo(
-          event);
+      event.To<scoped_ptr<blink::WebInputEvent> >();
   if (web_event)
     web_view_->handleInputEvent(*web_event);
 }
diff --git a/mojo/services/native_viewport/native_viewport_impl.cc b/mojo/services/native_viewport/native_viewport_impl.cc
index 9d6ff23..47de692 100644
--- a/mojo/services/native_viewport/native_viewport_impl.cc
+++ b/mojo/services/native_viewport/native_viewport_impl.cc
@@ -118,9 +118,8 @@ bool NativeViewportImpl::OnEvent(ui::Event* ui_event) {
     return false;
 
   client()->OnEvent(
-      TypeConverter<EventPtr, ui::Event>::ConvertFrom(*ui_event),
-      base::Bind(&NativeViewportImpl::AckEvent,
-                 weak_factory_.GetWeakPtr()));
+      Event::From(*ui_event),
+      base::Bind(&NativeViewportImpl::AckEvent, weak_factory_.GetWeakPtr()));
   waiting_for_event_ack_ = true;
   return false;
 }
diff --git a/mojo/services/public/cpp/geometry/geometry_type_converters.h b/mojo/services/public/cpp/geometry/geometry_type_converters.h
index 80728f9..876686e 100644
--- a/mojo/services/public/cpp/geometry/geometry_type_converters.h
+++ b/mojo/services/public/cpp/geometry/geometry_type_converters.h
@@ -15,39 +15,49 @@
 
 namespace mojo {
 
-template<>
-class MOJO_GEOMETRY_EXPORT TypeConverter<PointPtr, gfx::Point> {
- public:
-  static PointPtr ConvertFrom(const gfx::Point& input);
-  static gfx::Point ConvertTo(const PointPtr& input);
+template <>
+struct MOJO_GEOMETRY_EXPORT TypeConverter<PointPtr, gfx::Point> {
+  static PointPtr Convert(const gfx::Point& input);
+};
+template <>
+struct MOJO_GEOMETRY_EXPORT TypeConverter<gfx::Point, PointPtr> {
+  static gfx::Point Convert(const PointPtr& input);
 };
 
 template <>
-class MOJO_GEOMETRY_EXPORT TypeConverter<PointFPtr, gfx::PointF> {
- public:
-  static PointFPtr ConvertFrom(const gfx::PointF& input);
-  static gfx::PointF ConvertTo(const PointFPtr& input);
+struct MOJO_GEOMETRY_EXPORT TypeConverter<PointFPtr, gfx::PointF> {
+  static PointFPtr Convert(const gfx::PointF& input);
+};
+template <>
+struct MOJO_GEOMETRY_EXPORT TypeConverter<gfx::PointF, PointFPtr> {
+  static gfx::PointF Convert(const PointFPtr& input);
 };
 
 template <>
-class MOJO_GEOMETRY_EXPORT TypeConverter<SizePtr, gfx::Size> {
- public:
-  static SizePtr ConvertFrom(const gfx::Size& input);
-  static gfx::Size ConvertTo(const SizePtr& input);
+struct MOJO_GEOMETRY_EXPORT TypeConverter<SizePtr, gfx::Size> {
+  static SizePtr Convert(const gfx::Size& input);
+};
+template <>
+struct MOJO_GEOMETRY_EXPORT TypeConverter<gfx::Size, SizePtr> {
+  static gfx::Size Convert(const SizePtr& input);
 };
 
-template<>
-class MOJO_GEOMETRY_EXPORT TypeConverter<RectPtr, gfx::Rect> {
- public:
-  static RectPtr ConvertFrom(const gfx::Rect& input);
-  static gfx::Rect ConvertTo(const RectPtr& input);
+template <>
+struct MOJO_GEOMETRY_EXPORT TypeConverter<RectPtr, gfx::Rect> {
+  static RectPtr Convert(const gfx::Rect& input);
+};
+template <>
+struct MOJO_GEOMETRY_EXPORT TypeConverter<gfx::Rect, RectPtr> {
+  static gfx::Rect Convert(const RectPtr& input);
 };
 
 template <>
-class MOJO_GEOMETRY_EXPORT TypeConverter<TransformPtr, gfx::Transform> {
- public:
-  static TransformPtr ConvertFrom(const gfx::Transform& input);
-  static gfx::Transform ConvertTo(const TransformPtr& input);
+struct MOJO_GEOMETRY_EXPORT TypeConverter<TransformPtr, gfx::Transform> {
+  static TransformPtr Convert(const gfx::Transform& input);
+};
+template <>
+struct MOJO_GEOMETRY_EXPORT TypeConverter<gfx::Transform, TransformPtr> {
+  static gfx::Transform Convert(const TransformPtr& input);
 };
 
 }  // namespace mojo
diff --git a/mojo/services/public/cpp/geometry/lib/geometry_type_converters.cc b/mojo/services/public/cpp/geometry/lib/geometry_type_converters.cc
index 3b9d787..5a21f24 100644
--- a/mojo/services/public/cpp/geometry/lib/geometry_type_converters.cc
+++ b/mojo/services/public/cpp/geometry/lib/geometry_type_converters.cc
@@ -7,8 +7,7 @@
 namespace mojo {
 
 // static
-PointPtr TypeConverter<PointPtr, gfx::Point>::ConvertFrom(
-    const gfx::Point& input) {
+PointPtr TypeConverter<PointPtr, gfx::Point>::Convert(const gfx::Point& input) {
   PointPtr point(Point::New());
   point->x = input.x();
   point->y = input.y();
@@ -16,15 +15,14 @@ PointPtr TypeConverter<PointPtr, gfx::Point>::ConvertFrom(
 }
 
 // static
-gfx::Point TypeConverter<PointPtr, gfx::Point>::ConvertTo(
-    const PointPtr& input) {
+gfx::Point TypeConverter<gfx::Point, PointPtr>::Convert(const PointPtr& input) {
   if (input.is_null())
     return gfx::Point();
   return gfx::Point(input->x, input->y);
 }
 
 // static
-PointFPtr TypeConverter<PointFPtr, gfx::PointF>::ConvertFrom(
+PointFPtr TypeConverter<PointFPtr, gfx::PointF>::Convert(
     const gfx::PointF& input) {
   PointFPtr point(PointF::New());
   point->x = input.x();
@@ -33,7 +31,7 @@ PointFPtr TypeConverter<PointFPtr, gfx::PointF>::ConvertFrom(
 }
 
 // static
-gfx::PointF TypeConverter<PointFPtr, gfx::PointF>::ConvertTo(
+gfx::PointF TypeConverter<gfx::PointF, PointFPtr>::Convert(
     const PointFPtr& input) {
   if (input.is_null())
     return gfx::PointF();
@@ -41,7 +39,7 @@ gfx::PointF TypeConverter<PointFPtr, gfx::PointF>::ConvertTo(
 }
 
 // static
-SizePtr TypeConverter<SizePtr, gfx::Size>::ConvertFrom(const gfx::Size& input) {
+SizePtr TypeConverter<SizePtr, gfx::Size>::Convert(const gfx::Size& input) {
   SizePtr size(Size::New());
   size->width = input.width();
   size->height = input.height();
@@ -49,14 +47,14 @@ SizePtr TypeConverter<SizePtr, gfx::Size>::ConvertFrom(const gfx::Size& input) {
 }
 
 // static
-gfx::Size TypeConverter<SizePtr, gfx::Size>::ConvertTo(const SizePtr& input) {
+gfx::Size TypeConverter<gfx::Size, SizePtr>::Convert(const SizePtr& input) {
   if (input.is_null())
     return gfx::Size();
   return gfx::Size(input->width, input->height);
 }
 
 // static
-RectPtr TypeConverter<RectPtr, gfx::Rect>::ConvertFrom(const gfx::Rect& input) {
+RectPtr TypeConverter<RectPtr, gfx::Rect>::Convert(const gfx::Rect& input) {
   RectPtr rect(Rect::New());
   rect->x = input.x();
   rect->y = input.y();
@@ -66,14 +64,14 @@ RectPtr TypeConverter<RectPtr, gfx::Rect>::ConvertFrom(const gfx::Rect& input) {
 }
 
 // static
-gfx::Rect TypeConverter<RectPtr, gfx::Rect>::ConvertTo(const RectPtr& input) {
+gfx::Rect TypeConverter<gfx::Rect, RectPtr>::Convert(const RectPtr& input) {
   if (input.is_null())
     return gfx::Rect();
   return gfx::Rect(input->x, input->y, input->width, input->height);
 }
 
 // static
-TransformPtr TypeConverter<TransformPtr, gfx::Transform>::ConvertFrom(
+TransformPtr TypeConverter<TransformPtr, gfx::Transform>::Convert(
     const gfx::Transform& input) {
   std::vector<float> storage(16);
   input.matrix().asRowMajorf(&storage[0]);
@@ -85,7 +83,7 @@ TransformPtr TypeConverter<TransformPtr, gfx::Transform>::ConvertFrom(
 }
 
 // static
-gfx::Transform TypeConverter<TransformPtr, gfx::Transform>::ConvertTo(
+gfx::Transform TypeConverter<gfx::Transform, TransformPtr>::Convert(
     const TransformPtr& input) {
   if (input.is_null())
     return gfx::Transform();
diff --git a/mojo/services/public/cpp/input_events/input_events_type_converters.h b/mojo/services/public/cpp/input_events/input_events_type_converters.h
index 64c1645..bbbbe10 100644
--- a/mojo/services/public/cpp/input_events/input_events_type_converters.h
+++ b/mojo/services/public/cpp/input_events/input_events_type_converters.h
@@ -12,30 +12,29 @@
 
 namespace mojo {
 
-template<>
-class MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventType, ui::EventType> {
- public:
-  static EventType ConvertFrom(ui::EventType type);
-  static ui::EventType ConvertTo(EventType type);
+template <>
+struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventType, ui::EventType> {
+  static EventType Convert(ui::EventType type);
 };
 
-template<>
-class MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr, ui::Event> {
- public:
-  static EventPtr ConvertFrom(const ui::Event& input);
+template <>
+struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<ui::EventType, EventType> {
+  static ui::EventType Convert(EventType type);
 };
 
-template<>
-class MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr, ui::KeyEvent> {
- public:
-  static EventPtr ConvertFrom(const ui::KeyEvent& input);
+template <>
+struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr, ui::Event> {
+  static EventPtr Convert(const ui::Event& input);
 };
 
-template<>
-class MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr,
-                                             scoped_ptr<ui::Event> > {
- public:
-  static scoped_ptr<ui::Event> ConvertTo(const EventPtr& input);
+template <>
+struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr, ui::KeyEvent> {
+  static EventPtr Convert(const ui::KeyEvent& input);
+};
+
+template <>
+struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<scoped_ptr<ui::Event>, EventPtr> {
+  static scoped_ptr<ui::Event> Convert(const EventPtr& input);
 };
 
 }  // namespace mojo
diff --git a/mojo/services/public/cpp/input_events/lib/input_events_type_converters.cc b/mojo/services/public/cpp/input_events/lib/input_events_type_converters.cc
index a4bd330..4520aa4 100644
--- a/mojo/services/public/cpp/input_events/lib/input_events_type_converters.cc
+++ b/mojo/services/public/cpp/input_events/lib/input_events_type_converters.cc
@@ -59,9 +59,7 @@ COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_MOD3_DOWN) ==
 
 
 // static
-EventType TypeConverter<EventType, ui::EventType>::ConvertFrom(
-    ui::EventType type) {
-
+EventType TypeConverter<EventType, ui::EventType>::Convert(ui::EventType type) {
 #define MOJO_INPUT_EVENT_NAME(name) case ui::ET_##name: return EVENT_TYPE_##name
 
   switch (type) {
@@ -78,9 +76,7 @@ EventType TypeConverter<EventType, ui::EventType>::ConvertFrom(
 }
 
 // static
-ui::EventType TypeConverter<EventType, ui::EventType>::ConvertTo(
-  EventType type) {
-
+ui::EventType TypeConverter<ui::EventType, EventType>::Convert(EventType type) {
 #define MOJO_INPUT_EVENT_NAME(name) case EVENT_TYPE_##name: return ui::ET_##name
 
   switch (type) {
@@ -94,11 +90,9 @@ ui::EventType TypeConverter<EventType, ui::EventType>::ConvertTo(
 }
 
 // static
-EventPtr TypeConverter<EventPtr, ui::Event>::ConvertFrom(
-    const ui::Event& input) {
+EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
   EventPtr event(Event::New());
-  event->action = TypeConverter<EventType, ui::EventType>::ConvertFrom(
-      input.type());
+  event->action = ConvertTo<EventType>(input.type());
   event->flags = EventFlags(input.flags());
   event->time_stamp = input.time_stamp().ToInternalValue();
 
@@ -107,13 +101,10 @@ EventPtr TypeConverter<EventPtr, ui::Event>::ConvertFrom(
         static_cast<const ui::LocatedEvent*>(&input);
 
     LocationDataPtr location_data(LocationData::New());
-    location_data->in_view_location =
-        TypeConverter<PointPtr, gfx::Point>::ConvertFrom(
-            located_event->location());
+    location_data->in_view_location = Point::From(located_event->location());
     if (input.HasNativeEvent()) {
       location_data->screen_location =
-          TypeConverter<PointPtr, gfx::Point>::ConvertFrom(
-              ui::EventSystemLocationFromNative(input.native_event()));
+          Point::From(ui::EventSystemLocationFromNative(input.native_event()));
     }
 
     event->location_data = location_data.Pass();
@@ -165,24 +156,21 @@ EventPtr TypeConverter<EventPtr, ui::Event>::ConvertFrom(
 }
 
 // static
-EventPtr TypeConverter<EventPtr, ui::KeyEvent>::ConvertFrom(
+EventPtr TypeConverter<EventPtr, ui::KeyEvent>::Convert(
     const ui::KeyEvent& input) {
   return Event::From(static_cast<const ui::Event&>(input));
 }
 
 // static
-scoped_ptr<ui::Event>
-TypeConverter<EventPtr, scoped_ptr<ui::Event> >::ConvertTo(
+scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
     const EventPtr& input) {
   scoped_ptr<ui::Event> ui_event;
-  ui::EventType ui_event_type =
-      TypeConverter<EventType, ui::EventType>::ConvertTo(input->action);
+  ui::EventType ui_event_type = ConvertTo<ui::EventType>(input->action);
 
   gfx::Point location;
   if (!input->location_data.is_null() &&
       !input->location_data->in_view_location.is_null()) {
-    location = TypeConverter<PointPtr, gfx::Point>::ConvertTo(
-        input->location_data->in_view_location);
+    location = input->location_data->in_view_location.To<gfx::Point>();
   }
 
   switch (input->action) {
diff --git a/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc b/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
index 6b39d9c..b6b348d 100644
--- a/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
+++ b/mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
@@ -36,9 +36,8 @@ ASSERT_ENUM_VALUES_EQUAL(YUV_VIDEO_CONTENT);
 
 namespace {
 
-cc::SharedQuadState* ConvertToSharedQuadState(
-    const SharedQuadStatePtr& input,
-    cc::RenderPass* render_pass) {
+cc::SharedQuadState* ConvertSharedQuadState(const SharedQuadStatePtr& input,
+                                            cc::RenderPass* render_pass) {
   cc::SharedQuadState* state = render_pass->CreateAndAppendSharedQuadState();
   state->SetAll(input->content_to_target_transform.To<gfx::Transform>(),
                 input->content_bounds.To<gfx::Size>(),
@@ -51,9 +50,9 @@ cc::SharedQuadState* ConvertToSharedQuadState(
   return state;
 }
 
-bool ConvertToDrawQuad(const QuadPtr& input,
-                       cc::SharedQuadState* sqs,
-                       cc::RenderPass* render_pass) {
+bool ConvertDrawQuad(const QuadPtr& input,
+                     cc::SharedQuadState* sqs,
+                     cc::RenderPass* render_pass) {
   switch (input->material) {
     case MATERIAL_SOLID_COLOR: {
       if (input->solid_color_quad_state.is_null())
@@ -118,8 +117,7 @@ bool ConvertToDrawQuad(const QuadPtr& input,
 }  // namespace
 
 // static
-SurfaceIdPtr
-TypeConverter<SurfaceIdPtr, cc::SurfaceId>::ConvertFrom(
+SurfaceIdPtr TypeConverter<SurfaceIdPtr, cc::SurfaceId>::Convert(
     const cc::SurfaceId& input) {
   SurfaceIdPtr id(SurfaceId::New());
   id->id = input.id;
@@ -127,27 +125,25 @@ TypeConverter<SurfaceIdPtr, cc::SurfaceId>::ConvertFrom(
 }
 
 // static
-cc::SurfaceId TypeConverter<SurfaceIdPtr, cc::SurfaceId>::ConvertTo(
+cc::SurfaceId TypeConverter<cc::SurfaceId, SurfaceIdPtr>::Convert(
     const SurfaceIdPtr& input) {
   return cc::SurfaceId(input->id);
 }
 
 // static
-ColorPtr TypeConverter<ColorPtr, SkColor>::ConvertFrom(
-    const SkColor& input) {
+ColorPtr TypeConverter<ColorPtr, SkColor>::Convert(const SkColor& input) {
   ColorPtr color(Color::New());
   color->rgba = input;
   return color.Pass();
 }
 
 // static
-SkColor TypeConverter<ColorPtr, SkColor>::ConvertTo(
-    const ColorPtr& input) {
+SkColor TypeConverter<SkColor, ColorPtr>::Convert(const ColorPtr& input) {
   return input->rgba;
 }
 
 // static
-QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::ConvertFrom(
+QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
     const cc::DrawQuad& input) {
   QuadPtr quad = Quad::New();
   quad->material = static_cast<Material>(input.material);
@@ -208,7 +204,7 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::ConvertFrom(
 
 // static
 SharedQuadStatePtr
-TypeConverter<SharedQuadStatePtr, cc::SharedQuadState>::ConvertFrom(
+TypeConverter<SharedQuadStatePtr, cc::SharedQuadState>::Convert(
     const cc::SharedQuadState& input) {
   SharedQuadStatePtr state = SharedQuadState::New();
   state->content_to_target_transform =
@@ -224,7 +220,7 @@ TypeConverter<SharedQuadStatePtr, cc::SharedQuadState>::ConvertFrom(
 }
 
 // static
-PassPtr TypeConverter<PassPtr, cc::RenderPass>::ConvertFrom(
+PassPtr TypeConverter<PassPtr, cc::RenderPass>::Convert(
     const cc::RenderPass& input) {
   PassPtr pass = Pass::New();
   pass->id = input.id.index;
@@ -257,7 +253,9 @@ PassPtr TypeConverter<PassPtr, cc::RenderPass>::ConvertFrom(
 }
 
 // static
-scoped_ptr<cc::RenderPass> ConvertTo(const PassPtr& input) {
+scoped_ptr<cc::RenderPass>
+TypeConverter<scoped_ptr<cc::RenderPass>, PassPtr>::Convert(
+    const PassPtr& input) {
   scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
   pass->SetAll(cc::RenderPassId(1, input->id),
                input->output_rect.To<gfx::Rect>(),
@@ -267,12 +265,12 @@ scoped_ptr<cc::RenderPass> ConvertTo(const PassPtr& input) {
   cc::SharedQuadStateList& sqs_list = pass->shared_quad_state_list;
   sqs_list.reserve(input->shared_quad_states.size());
   for (size_t i = 0; i < input->shared_quad_states.size(); ++i) {
-    ConvertToSharedQuadState(input->shared_quad_states[i], pass.get());
+    ConvertSharedQuadState(input->shared_quad_states[i], pass.get());
   }
   pass->quad_list.reserve(input->quads.size());
   for (size_t i = 0; i < input->quads.size(); ++i) {
     QuadPtr quad = input->quads[i].Pass();
-    if (!ConvertToDrawQuad(
+    if (!ConvertDrawQuad(
             quad, sqs_list[quad->shared_quad_state_index], pass.get()))
       return scoped_ptr<cc::RenderPass>();
   }
@@ -280,7 +278,7 @@ scoped_ptr<cc::RenderPass> ConvertTo(const PassPtr& input) {
 }
 
 // static
-MailboxPtr TypeConverter<MailboxPtr, gpu::Mailbox>::ConvertFrom(
+MailboxPtr TypeConverter<MailboxPtr, gpu::Mailbox>::Convert(
     const gpu::Mailbox& input) {
   Array<int8_t> name(64);
   for (int i = 0; i < 64; ++i) {
@@ -292,7 +290,7 @@ MailboxPtr TypeConverter<MailboxPtr, gpu::Mailbox>::ConvertFrom(
 }
 
 // static
-gpu::Mailbox TypeConverter<MailboxPtr, gpu::Mailbox>::ConvertTo(
+gpu::Mailbox TypeConverter<gpu::Mailbox, MailboxPtr>::Convert(
     const MailboxPtr& input) {
   gpu::Mailbox mailbox;
   if (!input->name.is_null())
@@ -301,8 +299,7 @@ gpu::Mailbox TypeConverter<MailboxPtr, gpu::Mailbox>::ConvertTo(
 }
 
 // static
-MailboxHolderPtr
-TypeConverter<MailboxHolderPtr, gpu::MailboxHolder>::ConvertFrom(
+MailboxHolderPtr TypeConverter<MailboxHolderPtr, gpu::MailboxHolder>::Convert(
     const gpu::MailboxHolder& input) {
   MailboxHolderPtr holder(MailboxHolder::New());
   holder->mailbox = Mailbox::From<gpu::Mailbox>(input.mailbox);
@@ -312,8 +309,7 @@ TypeConverter<MailboxHolderPtr, gpu::MailboxHolder>::ConvertFrom(
 }
 
 // static
-gpu::MailboxHolder
-TypeConverter<MailboxHolderPtr, gpu::MailboxHolder>::ConvertTo(
+gpu::MailboxHolder TypeConverter<gpu::MailboxHolder, MailboxHolderPtr>::Convert(
     const MailboxHolderPtr& input) {
   gpu::MailboxHolder holder;
   holder.mailbox = input->mailbox.To<gpu::Mailbox>();
@@ -323,10 +319,9 @@ TypeConverter<MailboxHolderPtr, gpu::MailboxHolder>::ConvertTo(
 }
 
 // static
-TransferableResourcePtr TypeConverter<
-    TransferableResourcePtr,
-    cc::TransferableResource>::ConvertFrom(const cc::TransferableResource&
-                                               input) {
+TransferableResourcePtr
+TypeConverter<TransferableResourcePtr, cc::TransferableResource>::Convert(
+    const cc::TransferableResource& input) {
   TransferableResourcePtr transferable = TransferableResource::New();
   transferable->id = input.id;
   transferable->format = static_cast<ResourceFormat>(input.format);
@@ -340,8 +335,8 @@ TransferableResourcePtr TypeConverter<
 
 // static
 cc::TransferableResource
-TypeConverter<TransferableResourcePtr, cc::TransferableResource>::
-    ConvertTo(const TransferableResourcePtr& input) {
+TypeConverter<cc::TransferableResource, TransferableResourcePtr>::Convert(
+    const TransferableResourcePtr& input) {
   cc::TransferableResource transferable;
   transferable.id = input->id;
   transferable.format = static_cast<cc::ResourceFormat>(input->format);
@@ -354,10 +349,10 @@ TypeConverter<TransferableResourcePtr, cc::TransferableResource>::
 }
 
 // static
-Array<TransferableResourcePtr>
-TypeConverter<Array<TransferableResourcePtr>,
-              cc::TransferableResourceArray>::
-    ConvertFrom(const cc::TransferableResourceArray& input) {
+Array<TransferableResourcePtr> TypeConverter<
+    Array<TransferableResourcePtr>,
+    cc::TransferableResourceArray>::Convert(const cc::TransferableResourceArray&
+                                                input) {
   Array<TransferableResourcePtr> resources(input.size());
   for (size_t i = 0; i < input.size(); ++i) {
     resources[i] = TransferableResource::From(input[i]);
@@ -367,9 +362,8 @@ TypeConverter<Array<TransferableResourcePtr>,
 
 // static
 cc::TransferableResourceArray
-TypeConverter<Array<TransferableResourcePtr>,
-              cc::TransferableResourceArray>::
-    ConvertTo(const Array<TransferableResourcePtr>& input) {
+TypeConverter<cc::TransferableResourceArray, Array<TransferableResourcePtr> >::
+    Convert(const Array<TransferableResourcePtr>& input) {
   cc::TransferableResourceArray resources(input.size());
   for (size_t i = 0; i < input.size(); ++i) {
     resources[i] = input[i].To<cc::TransferableResource>();
@@ -379,7 +373,7 @@ TypeConverter<Array<TransferableResourcePtr>,
 
 // static
 ReturnedResourcePtr
-TypeConverter<ReturnedResourcePtr, cc::ReturnedResource>::ConvertFrom(
+TypeConverter<ReturnedResourcePtr, cc::ReturnedResource>::Convert(
     const cc::ReturnedResource& input) {
   ReturnedResourcePtr returned = ReturnedResource::New();
   returned->id = input.id;
@@ -391,7 +385,7 @@ TypeConverter<ReturnedResourcePtr, cc::ReturnedResource>::ConvertFrom(
 
 // static
 cc::ReturnedResource
-TypeConverter<ReturnedResourcePtr, cc::ReturnedResource>::ConvertTo(
+TypeConverter<cc::ReturnedResource, ReturnedResourcePtr>::Convert(
     const ReturnedResourcePtr& input) {
   cc::ReturnedResource returned;
   returned.id = input->id;
@@ -402,10 +396,9 @@ TypeConverter<ReturnedResourcePtr, cc::ReturnedResource>::ConvertTo(
 }
 
 // static
-Array<ReturnedResourcePtr> TypeConverter<
-    Array<ReturnedResourcePtr>,
-    cc::ReturnedResourceArray>::ConvertFrom(const cc::ReturnedResourceArray&
-                                                input) {
+Array<ReturnedResourcePtr>
+TypeConverter<Array<ReturnedResourcePtr>, cc::ReturnedResourceArray>::Convert(
+    const cc::ReturnedResourceArray& input) {
   Array<ReturnedResourcePtr> resources(input.size());
   for (size_t i = 0; i < input.size(); ++i) {
     resources[i] = ReturnedResource::From(input[i]);
@@ -414,7 +407,7 @@ Array<ReturnedResourcePtr> TypeConverter<
 }
 
 // static
-FramePtr TypeConverter<FramePtr, cc::CompositorFrame>::ConvertFrom(
+FramePtr TypeConverter<FramePtr, cc::CompositorFrame>::Convert(
     const cc::CompositorFrame& input) {
   FramePtr frame = Frame::New();
   DCHECK(input.delegated_frame_data);
@@ -430,14 +423,17 @@ FramePtr TypeConverter<FramePtr, cc::CompositorFrame>::ConvertFrom(
 }
 
 // static
-scoped_ptr<cc::CompositorFrame> ConvertTo(const FramePtr& input) {
+scoped_ptr<cc::CompositorFrame>
+TypeConverter<scoped_ptr<cc::CompositorFrame>, FramePtr>::Convert(
+    const FramePtr& input) {
   scoped_ptr<cc::DelegatedFrameData> frame_data(new cc::DelegatedFrameData);
   frame_data->device_scale_factor = 1.f;
   frame_data->resource_list =
       input->resources.To<cc::TransferableResourceArray>();
   frame_data->render_pass_list.reserve(input->passes.size());
   for (size_t i = 0; i < input->passes.size(); ++i) {
-    scoped_ptr<cc::RenderPass> pass = ConvertTo(input->passes[i]);
+    scoped_ptr<cc::RenderPass> pass =
+        input->passes[i].To<scoped_ptr<cc::RenderPass> >();
     if (!pass)
       return scoped_ptr<cc::CompositorFrame>();
     frame_data->render_pass_list.push_back(pass.Pass());
diff --git a/mojo/services/public/cpp/surfaces/surfaces_type_converters.h b/mojo/services/public/cpp/surfaces/surfaces_type_converters.h
index 9fdc9df..822c440 100644
--- a/mojo/services/public/cpp/surfaces/surfaces_type_converters.h
+++ b/mojo/services/public/cpp/surfaces/surfaces_type_converters.h
@@ -28,106 +28,118 @@ namespace mojo {
 
 // Types from surface_id.mojom
 template <>
-class MOJO_SURFACES_EXPORT
-TypeConverter<SurfaceIdPtr, cc::SurfaceId> {
- public:
-  static SurfaceIdPtr ConvertFrom(const cc::SurfaceId& input);
-  static cc::SurfaceId ConvertTo(const SurfaceIdPtr& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<SurfaceIdPtr, cc::SurfaceId> {
+  static SurfaceIdPtr Convert(const cc::SurfaceId& input);
+};
+template <>
+struct MOJO_SURFACES_EXPORT TypeConverter<cc::SurfaceId, SurfaceIdPtr> {
+  static cc::SurfaceId Convert(const SurfaceIdPtr& input);
 };
 
 // Types from quads.mojom
 template <>
-class MOJO_SURFACES_EXPORT TypeConverter<ColorPtr, SkColor> {
- public:
-  static ColorPtr ConvertFrom(const SkColor& input);
-  static SkColor ConvertTo(const ColorPtr& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<ColorPtr, SkColor> {
+  static ColorPtr Convert(const SkColor& input);
+};
+template <>
+struct MOJO_SURFACES_EXPORT TypeConverter<SkColor, ColorPtr> {
+  static SkColor Convert(const ColorPtr& input);
 };
 
 template <>
-class MOJO_SURFACES_EXPORT TypeConverter<QuadPtr, cc::DrawQuad> {
- public:
-  static QuadPtr ConvertFrom(const cc::DrawQuad& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<QuadPtr, cc::DrawQuad> {
+  static QuadPtr Convert(const cc::DrawQuad& input);
 };
 
 template <>
-class MOJO_SURFACES_EXPORT
+struct MOJO_SURFACES_EXPORT
 TypeConverter<SharedQuadStatePtr, cc::SharedQuadState> {
- public:
-  static SharedQuadStatePtr ConvertFrom(const cc::SharedQuadState& input);
+  static SharedQuadStatePtr Convert(const cc::SharedQuadState& input);
 };
 
 template <>
-class MOJO_SURFACES_EXPORT TypeConverter<PassPtr, cc::RenderPass> {
- public:
-  static PassPtr ConvertFrom(const cc::RenderPass& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<PassPtr, cc::RenderPass> {
+  static PassPtr Convert(const cc::RenderPass& input);
 };
 
-// This can't use the TypeConverter since cc::RenderPass must be heap allocated
-// and isn't copyable.
-MOJO_SURFACES_EXPORT scoped_ptr<cc::RenderPass> ConvertTo(
-    const PassPtr& input);
+template <>
+struct MOJO_SURFACES_EXPORT TypeConverter<scoped_ptr<cc::RenderPass>, PassPtr> {
+  static scoped_ptr<cc::RenderPass> Convert(const PassPtr& input);
+};
 
 // Types from surfaces.mojom
 template <>
-class MOJO_SURFACES_EXPORT TypeConverter<MailboxPtr, gpu::Mailbox> {
- public:
-  static MailboxPtr ConvertFrom(const gpu::Mailbox& input);
-  static gpu::Mailbox ConvertTo(const MailboxPtr& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<MailboxPtr, gpu::Mailbox> {
+  static MailboxPtr Convert(const gpu::Mailbox& input);
+};
+template <>
+struct MOJO_SURFACES_EXPORT TypeConverter<gpu::Mailbox, MailboxPtr> {
+  static gpu::Mailbox Convert(const MailboxPtr& input);
 };
 
 template <>
-class MOJO_SURFACES_EXPORT
+struct MOJO_SURFACES_EXPORT
 TypeConverter<MailboxHolderPtr, gpu::MailboxHolder> {
- public:
-  static MailboxHolderPtr ConvertFrom(const gpu::MailboxHolder& input);
-  static gpu::MailboxHolder ConvertTo(const MailboxHolderPtr& input);
+  static MailboxHolderPtr Convert(const gpu::MailboxHolder& input);
+};
+template <>
+struct MOJO_SURFACES_EXPORT
+TypeConverter<gpu::MailboxHolder, MailboxHolderPtr> {
+  static gpu::MailboxHolder Convert(const MailboxHolderPtr& input);
 };
 
 template <>
-class MOJO_SURFACES_EXPORT
+struct MOJO_SURFACES_EXPORT
 TypeConverter<TransferableResourcePtr, cc::TransferableResource> {
- public:
-  static TransferableResourcePtr ConvertFrom(
-      const cc::TransferableResource& input);
-  static cc::TransferableResource ConvertTo(
-      const TransferableResourcePtr& input);
+  static TransferableResourcePtr Convert(const cc::TransferableResource& input);
+};
+template <>
+struct MOJO_SURFACES_EXPORT
+TypeConverter<cc::TransferableResource, TransferableResourcePtr> {
+  static cc::TransferableResource Convert(const TransferableResourcePtr& input);
 };
 
 template <>
-class MOJO_SURFACES_EXPORT
+struct MOJO_SURFACES_EXPORT
 TypeConverter<Array<TransferableResourcePtr>, cc::TransferableResourceArray> {
- public:
-  static Array<TransferableResourcePtr> ConvertFrom(
+  static Array<TransferableResourcePtr> Convert(
       const cc::TransferableResourceArray& input);
-  static cc::TransferableResourceArray ConvertTo(
+};
+template <>
+struct MOJO_SURFACES_EXPORT
+TypeConverter<cc::TransferableResourceArray, Array<TransferableResourcePtr> > {
+  static cc::TransferableResourceArray Convert(
       const Array<TransferableResourcePtr>& input);
 };
 
 template <>
-class MOJO_SURFACES_EXPORT
+struct MOJO_SURFACES_EXPORT
 TypeConverter<ReturnedResourcePtr, cc::ReturnedResource> {
- public:
-  static ReturnedResourcePtr ConvertFrom(const cc::ReturnedResource& input);
-  static cc::ReturnedResource ConvertTo(const ReturnedResourcePtr& input);
+  static ReturnedResourcePtr Convert(const cc::ReturnedResource& input);
+};
+template <>
+struct MOJO_SURFACES_EXPORT
+TypeConverter<cc::ReturnedResource, ReturnedResourcePtr> {
+  static cc::ReturnedResource Convert(const ReturnedResourcePtr& input);
 };
 
 template <>
-class MOJO_SURFACES_EXPORT
+struct MOJO_SURFACES_EXPORT
 TypeConverter<Array<ReturnedResourcePtr>, cc::ReturnedResourceArray> {
- public:
-  static Array<ReturnedResourcePtr> ConvertFrom(
+  static Array<ReturnedResourcePtr> Convert(
       const cc::ReturnedResourceArray& input);
 };
 
 template <>
-class MOJO_SURFACES_EXPORT
-TypeConverter<FramePtr, cc::CompositorFrame> {
- public:
-  static FramePtr ConvertFrom(const cc::CompositorFrame& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<FramePtr, cc::CompositorFrame> {
+  static FramePtr Convert(const cc::CompositorFrame& input);
 };
 
-MOJO_SURFACES_EXPORT scoped_ptr<cc::CompositorFrame> ConvertTo(
-    const FramePtr& input);
+template <>
+struct MOJO_SURFACES_EXPORT
+TypeConverter<scoped_ptr<cc::CompositorFrame>, FramePtr> {
+  static scoped_ptr<cc::CompositorFrame> Convert(const FramePtr& input);
+};
 
 }  // namespace mojo
 
diff --git a/mojo/services/public/cpp/surfaces/tests/surface_unittest.cc b/mojo/services/public/cpp/surfaces/tests/surface_unittest.cc
index f269d4e..cc7c2e8 100644
--- a/mojo/services/public/cpp/surfaces/tests/surface_unittest.cc
+++ b/mojo/services/public/cpp/surfaces/tests/surface_unittest.cc
@@ -149,7 +149,8 @@ TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) {
   SharedQuadStatePtr mojo_sqs = SharedQuadState::New();
   mojo_pass->shared_quad_states.push_back(mojo_sqs.Pass());
 
-  scoped_ptr<cc::RenderPass> pass = ConvertTo(mojo_pass.Pass());
+  scoped_ptr<cc::RenderPass> pass = mojo_pass.To<scoped_ptr<cc::RenderPass> >();
+
   EXPECT_FALSE(pass);
 }
 
@@ -164,7 +165,7 @@ TEST_F(SurfaceLibQuadTest, TextureQuadEmptyBackgroundColor) {
   SharedQuadStatePtr mojo_sqs = SharedQuadState::New();
   mojo_pass->shared_quad_states.push_back(mojo_sqs.Pass());
 
-  scoped_ptr<cc::RenderPass> pass = ConvertTo(mojo_pass.Pass());
+  scoped_ptr<cc::RenderPass> pass = mojo_pass.To<scoped_ptr<cc::RenderPass> >();
   EXPECT_FALSE(pass);
 }
 
@@ -291,7 +292,8 @@ TEST(SurfaceLibTest, RenderPass) {
   ASSERT_EQ(3u, mojo_pass->quads.size());
   EXPECT_EQ(0, mojo_pass->quads[0]->shared_quad_state_index);
 
-  scoped_ptr<cc::RenderPass> round_trip_pass = ConvertTo(mojo_pass.Pass());
+  scoped_ptr<cc::RenderPass> round_trip_pass =
+      mojo_pass.To<scoped_ptr<cc::RenderPass> >();
   EXPECT_EQ(pass_id, round_trip_pass->id);
   EXPECT_EQ(output_rect, round_trip_pass->output_rect);
   EXPECT_EQ(damage_rect, round_trip_pass->damage_rect);
diff --git a/mojo/services/public/cpp/view_manager/lib/view_manager_client_impl.cc b/mojo/services/public/cpp/view_manager/lib/view_manager_client_impl.cc
index ec4ec61..88b3548 100644
--- a/mojo/services/public/cpp/view_manager/lib/view_manager_client_impl.cc
+++ b/mojo/services/public/cpp/view_manager/lib/view_manager_client_impl.cc
@@ -301,7 +301,7 @@ void ViewManagerClientImpl::OnEmbed(
   if (!connected_) {
     connected_ = true;
     connection_id_ = connection_id;
-    creator_url_ = TypeConverter<String, std::string>::ConvertFrom(creator_url);
+    creator_url_ = String::From(creator_url);
   } else {
     DCHECK_EQ(connection_id_, connection_id);
     DCHECK_EQ(creator_url_, creator_url);
diff --git a/mojo/services/surfaces/surfaces_impl.cc b/mojo/services/surfaces/surfaces_impl.cc
index 5316ea3..ba1c0b0 100644
--- a/mojo/services/surfaces/surfaces_impl.cc
+++ b/mojo/services/surfaces/surfaces_impl.cc
@@ -45,8 +45,9 @@ void SurfacesImpl::SubmitFrame(SurfaceIdPtr id, FramePtr frame_ptr) {
                << " should be namespace " << id_namespace_;
     return;
   }
-  factory_.SubmitFrame(
-      id.To<cc::SurfaceId>(), mojo::ConvertTo(frame_ptr), base::Closure());
+  factory_.SubmitFrame(id.To<cc::SurfaceId>(),
+                       frame_ptr.To<scoped_ptr<cc::CompositorFrame> >(),
+                       base::Closure());
   client_->FrameSubmitted();
 }
 
diff --git a/mojo/services/window_manager/window_manager_app.cc b/mojo/services/window_manager/window_manager_app.cc
index a6d57c9..dd3fbdb 100644
--- a/mojo/services/window_manager/window_manager_app.cc
+++ b/mojo/services/window_manager/window_manager_app.cc
@@ -237,8 +237,7 @@ void WindowManagerApp::Embed(
 }
 
 void WindowManagerApp::DispatchEvent(EventPtr event) {
-  scoped_ptr<ui::Event> ui_event =
-      TypeConverter<EventPtr, scoped_ptr<ui::Event> >::ConvertTo(event);
+  scoped_ptr<ui::Event> ui_event = event.To<scoped_ptr<ui::Event> >();
   if (ui_event)
     window_tree_host_->SendEventToProcessor(ui_event.get());
 }
@@ -301,9 +300,7 @@ void WindowManagerApp::CompositorContentsChanged(const SkBitmap& bitmap) {
 
 void WindowManagerApp::OnEvent(ui::Event* event) {
   aura::Window* window = static_cast<aura::Window*>(event->target());
-  view_manager_->DispatchEvent(
-      GetViewForWindow(window),
-      TypeConverter<EventPtr, ui::Event>::ConvertFrom(*event));
+  view_manager_->DispatchEvent(GetViewForWindow(window), Event::From(*event));
 }
 
 ////////////////////////////////////////////////////////////////////////////////