Mojo: SimilarityTraits -> TypeConverter

Also Copy{From,To} -> Convert{From,To}.

R=abarth@chromium.org

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@239379 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 40 insertions, 40 deletions

diff --git a/mojo/public/bindings/generators/cpp_templates/wrapper_class_declaration b/mojo/public/bindings/generators/cpp_templates/wrapper_class_declaration
index 402039c..f387607 100644
--- a/mojo/public/bindings/generators/cpp_templates/wrapper_class_declaration
+++ b/mojo/public/bindings/generators/cpp_templates/wrapper_class_declaration
@@ -7,13 +7,13 @@ class $CLASS {
 
   template <typename U>
   $CLASS(const U& u, mojo::Buffer* buf = mojo::Buffer::current()) {
-    *this = mojo::SimilarityTraits<$CLASS,U>::CopyFrom(u, buf);
+    *this = mojo::TypeConverter<$CLASS,U>::ConvertFrom(u, buf);
   }
 
   template <typename U>
   $CLASS& operator=(const U& u) {
     *this =
-        mojo::SimilarityTraits<$CLASS,U>::CopyFrom(u, mojo::Buffer::current());
+        mojo::TypeConverter<$CLASS,U>::ConvertFrom(u, mojo::Buffer::current());
     return *this;
   }
 
@@ -24,7 +24,7 @@ class $CLASS {
 
   template <typename U>
   U To() const {
-    return mojo::SimilarityTraits<$CLASS,U>::CopyTo(*this);
+    return mojo::TypeConverter<$CLASS,U>::ConvertTo(*this);
   }
 
   bool is_null() const { return !data_; }
diff --git a/mojo/public/bindings/lib/bindings.cc b/mojo/public/bindings/lib/bindings.cc
index a9d748f..f748c4e 100644
--- a/mojo/public/bindings/lib/bindings.cc
+++ b/mojo/public/bindings/lib/bindings.cc
@@ -7,7 +7,7 @@
 namespace mojo {
 
 // static
-String SimilarityTraits<String, std::string>::CopyFrom(const std::string& input,
+String TypeConverter<String, std::string>::ConvertFrom(const std::string& input,
                                                        Buffer* buf) {
   String::Builder result(input.size(), buf);
   if (!input.empty())
@@ -15,7 +15,7 @@ String SimilarityTraits<String, std::string>::CopyFrom(const std::string& input,
   return result.Finish();
 }
 // static
-std::string SimilarityTraits<String, std::string>::CopyTo(const String& input) {
+std::string TypeConverter<String, std::string>::ConvertTo(const String& input) {
   if (input.is_null() || input.size() == 0)
     return std::string();
 
@@ -23,7 +23,7 @@ std::string SimilarityTraits<String, std::string>::CopyTo(const String& input) {
 }
 
 // static
-String SimilarityTraits<String, const char*>::CopyFrom(const char* input,
+String TypeConverter<String, const char*>::ConvertFrom(const char* input,
                                                        Buffer* buf) {
   if (!input)
     return String();
diff --git a/mojo/public/bindings/lib/bindings.h b/mojo/public/bindings/lib/bindings.h
index 834b3c1..c0a0861 100644
--- a/mojo/public/bindings/lib/bindings.h
+++ b/mojo/public/bindings/lib/bindings.h
@@ -15,7 +15,7 @@
 
 namespace mojo {
 
-template <typename T, typename U> class SimilarityTraits {};
+template <typename T, typename U> class TypeConverter {};
 
 // Provides read-only access to array data.
 template <typename T>
@@ -30,12 +30,12 @@ class Array {
 
   template <typename U>
   Array(const U& u, Buffer* buf = Buffer::current()) {
-    *this = SimilarityTraits<Array<T>,U>::CopyFrom(u, buf);
+    *this = TypeConverter<Array<T>,U>::ConvertFrom(u, buf);
   }
 
   template <typename U>
   Array& operator=(const U& u) {
-    *this = SimilarityTraits<Array<T>,U>::CopyFrom(u, Buffer::current());
+    *this = TypeConverter<Array<T>,U>::ConvertFrom(u, Buffer::current());
     return *this;
   }
 
@@ -46,7 +46,7 @@ class Array {
 
   template <typename U>
   U To() const {
-    return SimilarityTraits<Array<T>,U>::CopyTo(*this);
+    return TypeConverter<Array<T>,U>::ConvertTo(*this);
   }
 
   bool is_null() const { return !data_; }
@@ -100,16 +100,16 @@ class Array {
 typedef Array<char> String;
 
 template <>
-class SimilarityTraits<String, std::string> {
+class TypeConverter<String, std::string> {
  public:
-  static String CopyFrom(const std::string& input, Buffer* buf);
-  static std::string CopyTo(const String& input);
+  static String ConvertFrom(const std::string& input, Buffer* buf);
+  static std::string ConvertTo(const String& input);
 };
 
 template <size_t N>
-class SimilarityTraits<String, char[N]> {
+class TypeConverter<String, char[N]> {
  public:
-  static String CopyFrom(const char input[N], Buffer* buf) {
+  static String ConvertFrom(const char input[N], Buffer* buf) {
     String::Builder result(N - 1, buf);
     memcpy(&result[0], input, N - 1);
     return result.Finish();
@@ -118,36 +118,36 @@ class SimilarityTraits<String, char[N]> {
 
 // Appease MSVC.
 template <size_t N>
-class SimilarityTraits<String, const char[N]> {
+class TypeConverter<String, const char[N]> {
  public:
-  static String CopyFrom(const char input[N], Buffer* buf) {
-    return SimilarityTraits<String, char[N]>::CopyFrom(input, buf);
+  static String ConvertFrom(const char input[N], Buffer* buf) {
+    return TypeConverter<String, char[N]>::ConvertFrom(input, buf);
   }
 };
 
 template <>
-class SimilarityTraits<String, const char*> {
+class TypeConverter<String, const char*> {
  public:
-  static String CopyFrom(const char* input, Buffer* buf);
-  // NOTE: |CopyTo| explicitly not implemented since String is not null
+  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).
 };
 
 template <typename T, typename E>
-class SimilarityTraits<Array<T>, std::vector<E> > {
+class TypeConverter<Array<T>, std::vector<E> > {
  public:
-  static Array<T> CopyFrom(const std::vector<E>& input, Buffer* buf) {
+  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] = SimilarityTraits<T, E>::CopyFrom(input[i], buf);
+      result[i] = TypeConverter<T, E>::ConvertFrom(input[i], buf);
     return result.Finish();
   }
-  static std::vector<E> CopyTo(const Array<T>& input) {
+  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] = SimilarityTraits<T, E>::CopyTo(input[i]);
+        result[i] = TypeConverter<T, E>::ConvertTo(input[i]);
     }
     return result;
   }
diff --git a/mojo/public/bindings/sample/sample_service_unittests.cc b/mojo/public/bindings/sample/sample_service_unittests.cc
index 51c7b49..170c1bc 100644
--- a/mojo/public/bindings/sample/sample_service_unittests.cc
+++ b/mojo/public/bindings/sample/sample_service_unittests.cc
@@ -15,9 +15,9 @@
 namespace mojo {
 
 template <>
-class SimilarityTraits<sample::Bar, int32_t> {
+class TypeConverter<sample::Bar, int32_t> {
  public:
-  static int32_t CopyTo(const sample::Bar& bar) {
+  static int32_t ConvertTo(const sample::Bar& 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/tests/bindings_type_conversion_unittest.cc b/mojo/public/tests/bindings_type_conversion_unittest.cc
index 6c41bb5..8e62345 100644
--- a/mojo/public/tests/bindings_type_conversion_unittest.cc
+++ b/mojo/public/tests/bindings_type_conversion_unittest.cc
@@ -24,9 +24,9 @@ struct RedmondNamedRegion {
 }  // namespace
 
 template <>
-class SimilarityTraits<test_structs::Rect, RedmondRect> {
+class TypeConverter<test_structs::Rect, RedmondRect> {
  public:
-  static test_structs::Rect CopyFrom(const RedmondRect& input, Buffer* buf) {
+  static test_structs::Rect ConvertFrom(const RedmondRect& input, Buffer* buf) {
     test_structs::Rect::Builder rect(buf);
     rect.set_x(input.left);
     rect.set_y(input.top);
@@ -34,7 +34,7 @@ class SimilarityTraits<test_structs::Rect, RedmondRect> {
     rect.set_height(input.bottom - input.top);
     return rect.Finish();
   }
-  static RedmondRect CopyTo(const test_structs::Rect& input) {
+  static RedmondRect ConvertTo(const test_structs::Rect& input) {
     RedmondRect rect;
     rect.left = input.x();
     rect.top = input.y();
@@ -45,16 +45,16 @@ class SimilarityTraits<test_structs::Rect, RedmondRect> {
 };
 
 template <>
-class SimilarityTraits<test_structs::NamedRegion, RedmondNamedRegion> {
+class TypeConverter<test_structs::NamedRegion, RedmondNamedRegion> {
  public:
-  static test_structs::NamedRegion CopyFrom(const RedmondNamedRegion& input,
-                                            Buffer* buf) {
+  static test_structs::NamedRegion ConvertFrom(const RedmondNamedRegion& input,
+                                               Buffer* buf) {
     test_structs::NamedRegion::Builder region(buf);
     region.set_name(String(input.name, buf));
     region.set_rects(mojo::Array<test_structs::Rect>(input.rects, buf));
     return region.Finish();
   }
-  static RedmondNamedRegion CopyTo(const test_structs::NamedRegion& input) {
+  static RedmondNamedRegion ConvertTo(const test_structs::NamedRegion& input) {
     RedmondNamedRegion region;
     region.name = input.name().To<std::string>();
     region.rects = input.rects().To<std::vector<RedmondRect> >();
@@ -125,7 +125,7 @@ TEST_F(BindingsTypeConversionTest, StringWithEmbeddedNull) {
   EXPECT_EQ(std::string("hel"), b.To<std::string>());
 }
 
-TEST_F(BindingsTypeConversionTest, CustomSimilarityTraits) {
+TEST_F(BindingsTypeConversionTest, CustomTypeConverter) {
   AllocationScope scope;
 
   test_structs::Rect::Builder rect_builder;
@@ -148,7 +148,7 @@ TEST_F(BindingsTypeConversionTest, CustomSimilarityTraits) {
   EXPECT_EQ(rect.height(), rect2.height());
 }
 
-TEST_F(BindingsTypeConversionTest, CustomSimilarityTraits_Array_Null) {
+TEST_F(BindingsTypeConversionTest, CustomTypeConverter_Array_Null) {
   Array<test_structs::Rect> rects;
 
   std::vector<RedmondRect> redmond_rects =
@@ -157,7 +157,7 @@ TEST_F(BindingsTypeConversionTest, CustomSimilarityTraits_Array_Null) {
   EXPECT_TRUE(redmond_rects.empty());
 }
 
-TEST_F(BindingsTypeConversionTest, CustomSimilarityTraits_Array) {
+TEST_F(BindingsTypeConversionTest, CustomTypeConverter_Array) {
   AllocationScope scope;
 
   const RedmondRect kBase = { 10, 20, 30, 40 };
@@ -199,7 +199,7 @@ TEST_F(BindingsTypeConversionTest, CustomSimilarityTraits_Array) {
   }
 }
 
-TEST_F(BindingsTypeConversionTest, CustomSimilarityTraits_Nested) {
+TEST_F(BindingsTypeConversionTest, CustomTypeConverter_Nested) {
   AllocationScope scope;
 
   RedmondNamedRegion redmond_region;
@@ -214,7 +214,7 @@ TEST_F(BindingsTypeConversionTest, CustomSimilarityTraits_Nested) {
     redmond_region.rects.push_back(rect);
   }
 
-  // Round-trip through generated struct and SimilarityTraits.
+  // Round-trip through generated struct and TypeConverter.
 
   test_structs::NamedRegion copy = redmond_region;
   RedmondNamedRegion redmond_region2 = copy.To<RedmondNamedRegion>();