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

extensions/browser/api/serial/serial_api.cc

Index: extensions/browser/api/serial/serial_api.cc
diff --git a/extensions/browser/api/serial/serial_api.cc b/extensions/browser/api/serial/serial_api.cc
index d8b8d7a7d08d6c5bc6fc64749bbc5001651be2f5..92404c11fd2d4fc33f3bedeaaa0bd26fec202afa 100644
--- a/extensions/browser/api/serial/serial_api.cc
+++ b/extensions/browser/api/serial/serial_api.cc
@@ -434,9 +434,9 @@ namespace mojo {
 
 // static
 linked_ptr<extensions::core_api::serial::DeviceInfo>
-TypeConverter<device::serial::DeviceInfoPtr,
-              linked_ptr<extensions::core_api::serial::DeviceInfo> >::
-    ConvertTo(const device::serial::DeviceInfoPtr& device) {
+    TypeConverter<linked_ptr<extensions::core_api::serial::DeviceInfo>,
+                  device::serial::DeviceInfoPtr>>
+    ::Convert(const device::serial::DeviceInfoPtr& device) {

[darin (slow to review), 2014/08/27 03:30:37]

It seems like the second template argument might not be necessary. TypeConverter
could be defined like so:

  template <typename T>
  struct TypeConverter {
    static T Convert(const A& a);
    static T Convert(const B& b);
    static T Convert(const C& c);
  };

Another approach might be to rely on argument-dependent lookup so that these
converters wouldn't need to be in the mojo:: namespace. This would require the
return value to be an out param, like so:

  void Convert(const A& a, T* obj);
  void Convert(const B& b, T* obj);
  void Convert(const C& c, T* obj);

WDYT?

[Matt Perry, 2014/08/27 18:51:31]

I think the converters would still need to be in the mojo namespace so that
things like Array::From() still work.

We could potentially still have mojo::Convert(const A& a, T* obj) - e.g.
function overloading rather than template specializations. I think the drawback
there is that it's easier for the compiler to mess up which conversion function
is used (which would only really happen if there are two similar types). This
might happen if there are 2 similar Convert functions defined in different
translation units, and you include the wrong one.

Based on my reading of this article [1], it's safer to have template
specializations in a struct rather than a global function. I believe the same
reasoning would apply to your first example. (OTOH, I can't think of a concrete
example where this would matter, so maybe it's overly paranoid.)

[1]: http://www.gotw.ca/publications/mill17.htm

   linked_ptr<extensions::core_api::serial::DeviceInfo> info(
       new extensions::core_api::serial::DeviceInfo);
   info->path = device->path;