Mojo: more idiomatic C++ bindings

This change eliminates AllocationScope in favor of heap allocating the "wrapper" classes, which are now no longer wrappers in the true sense but rather deep copies of the archived structs. We still use the term "wrapper" in the code generator.

With this design, the fact that structs are encoded as pointers (that may be null) is more apparent. For example, a Foo struct may be allocated and stored in a FooPtr. The FooPtr implements move-only semantics. This is because some of the members of Foo may be move-only (e.g., handles).

Strings are now just thin wrappers around std::string that impose nullability and a more restrictive API. It is not possible to mutate the elements of a string after it has been created. String acts like a pointer to a possibly null array of characters, which is very similar to a char*.

Arrays are now just thin wrappers around std::vector that impose nullability and a more restrictive API. Unlike String, Array does support mutation of its elements after creation, but there is no support for resizing an array. (We can add support for push_back and resize if needed.)

BUG=365922
R=yzshen@chromium.org

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

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

3 files changed, 23 insertions, 35 deletions

diff --git a/mojo/common/common_type_converters.cc b/mojo/common/common_type_converters.cc
index 3aa0e94..a82aa51 100644
--- a/mojo/common/common_type_converters.cc
+++ b/mojo/common/common_type_converters.cc
@@ -12,33 +12,30 @@ namespace mojo {
 
 // static
 String TypeConverter<String, base::StringPiece>::ConvertFrom(
-    const base::StringPiece& input,
-    Buffer* buf) {
-  if (input.empty())
-    return String();
-  String::Builder result(input.size(), buf);
-  memcpy(&result[0], input.data(), input.size());
-  return result.Finish();
+    const base::StringPiece& input) {
+  if (input.empty()) {
+    char c = 0;
+    return String(&c, 0);
+  }
+  return String(input.data(), input.size());
 }
 // static
 base::StringPiece TypeConverter<String, base::StringPiece>::ConvertTo(
     const String& input) {
-  return input.is_null() ? base::StringPiece() :
-                           base::StringPiece(&input[0], input.size());
+  return input.get();
 }
 
 // static
 String TypeConverter<String, base::string16>::ConvertFrom(
-    const base::string16& input,
-    Buffer* buf) {
+    const base::string16& input) {
   return TypeConverter<String, base::StringPiece>::ConvertFrom(
-      base::UTF16ToUTF8(input), buf);
+      base::UTF16ToUTF8(input));
 }
 // static
 base::string16 TypeConverter<String, base::string16>::ConvertTo(
     const String& input) {
-  return input.is_null() ? base::string16() :
-      base::UTF8ToUTF16(base::StringPiece(&input[0], input.size()));
+  return base::UTF8ToUTF16(TypeConverter<String, base::StringPiece>::ConvertTo(
+      input));
 }
 
 }  // namespace mojo
diff --git a/mojo/common/common_type_converters.h b/mojo/common/common_type_converters.h
index a43d18b..a75e734 100644
--- a/mojo/common/common_type_converters.h
+++ b/mojo/common/common_type_converters.h
@@ -8,7 +8,7 @@
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "mojo/common/mojo_common_export.h"
-#include "mojo/public/cpp/bindings/array.h"
+#include "mojo/public/cpp/bindings/string.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 
 namespace mojo {
@@ -16,19 +16,15 @@ namespace mojo {
 template <>
 class MOJO_COMMON_EXPORT TypeConverter<String, base::StringPiece> {
  public:
-  static String ConvertFrom(const base::StringPiece& input, Buffer* buf);
+  static String ConvertFrom(const base::StringPiece& input);
   static base::StringPiece ConvertTo(const String& input);
-
-  MOJO_ALLOW_IMPLICIT_TYPE_CONVERSION();
 };
 
 template <>
 class MOJO_COMMON_EXPORT TypeConverter<String, base::string16> {
  public:
-  static String ConvertFrom(const base::string16& input, Buffer* buf);
+  static String ConvertFrom(const base::string16& input);
   static base::string16 ConvertTo(const String& input);
-
-  MOJO_ALLOW_IMPLICIT_TYPE_CONVERSION();
 };
 
 }  // namespace mojo
diff --git a/mojo/common/common_type_converters_unittest.cc b/mojo/common/common_type_converters_unittest.cc
index 438d1e7..4777139 100644
--- a/mojo/common/common_type_converters_unittest.cc
+++ b/mojo/common/common_type_converters_unittest.cc
@@ -5,7 +5,6 @@
 #include "mojo/common/common_type_converters.h"
 
 #include "base/strings/utf_string_conversions.h"
-#include "mojo/public/cpp/bindings/allocation_scope.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
@@ -20,7 +19,7 @@ void ExpectEqualsStringPiece(const std::string& expected,
 
 void ExpectEqualsMojoString(const std::string& expected,
                             const String& str) {
-  EXPECT_EQ(expected, str.To<std::string>());
+  EXPECT_EQ(expected, str.get());
 }
 
 void ExpectEqualsString16(const base::string16& expected,
@@ -36,40 +35,36 @@ void ExpectEqualsMojoString(const base::string16& expected,
 }  // namespace
 
 TEST(CommonTypeConvertersTest, StringPiece) {
-  AllocationScope scope;
-
   std::string kText("hello world");
 
   base::StringPiece string_piece(kText);
-  String mojo_string(string_piece);
+  String mojo_string(String::From(string_piece));
 
   ExpectEqualsMojoString(kText, mojo_string);
   ExpectEqualsStringPiece(kText, mojo_string.To<base::StringPiece>());
 
   // Test implicit construction and conversion:
-  ExpectEqualsMojoString(kText, string_piece);
-  ExpectEqualsStringPiece(kText, mojo_string);
+  ExpectEqualsMojoString(kText, String::From(string_piece));
+  ExpectEqualsStringPiece(kText, mojo_string.To<base::StringPiece>());
 
   // Test null String:
-  base::StringPiece empty_string_piece = String();
+  base::StringPiece empty_string_piece = String().To<base::StringPiece>();
   EXPECT_TRUE(empty_string_piece.empty());
 }
 
 TEST(CommonTypeConvertersTest, String16) {
-  AllocationScope scope;
-
   const base::string16 string16(base::ASCIIToUTF16("hello world"));
-  const String mojo_string(string16);
+  const String mojo_string(String::From(string16));
 
   ExpectEqualsMojoString(string16, mojo_string);
   EXPECT_EQ(string16, mojo_string.To<base::string16>());
 
   // Test implicit construction and conversion:
-  ExpectEqualsMojoString(string16, string16);
-  ExpectEqualsString16(string16, mojo_string);
+  ExpectEqualsMojoString(string16, String::From(string16));
+  ExpectEqualsString16(string16, mojo_string.To<base::string16>());
 
   // Test empty string conversion.
-  ExpectEqualsMojoString(base::string16(), base::string16());
+  ExpectEqualsMojoString(base::string16(), String::From(base::string16()));
 }
 
 }  // namespace test