Mojo: Basic C++ wrappers for the (still-untested) data pipes.

I'd write tests, but I want to start from the "bottom up".

R=sky@chromium.org

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

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

2 files changed, 116 insertions, 18 deletions

diff --git a/mojo/public/system/core_cpp.h b/mojo/public/system/core_cpp.h
index 2a83862..12a7a4c 100644
--- a/mojo/public/system/core_cpp.h
+++ b/mojo/public/system/core_cpp.h
@@ -15,6 +15,12 @@
 
 namespace mojo {
 
+// Standalone functions --------------------------------------------------------
+
+inline MojoTimeTicks GetTimeTicksNow() {
+  return MojoGetTimeTicksNow();
+}
+
 // ScopedHandleBase ------------------------------------------------------------
 
 // Scoper for the actual handle types defined further below. It's move-only,
@@ -179,7 +185,7 @@ MOJO_COMPILE_ASSERT(sizeof(ScopedMessagePipeHandle) ==
                     bad_size_for_cpp_ScopedMessagePipeHandle);
 
 // TODO(vtl): In C++11, we could instead return a pair of
-// |ScopedHandleBase<MessagePipeHandle>|s.
+// |ScopedMessagePipeHandle|s.
 inline void CreateMessagePipe(ScopedMessagePipeHandle* message_pipe_0,
                               ScopedMessagePipeHandle* message_pipe_1) {
   assert(message_pipe_0);
@@ -196,29 +202,119 @@ inline void CreateMessagePipe(ScopedMessagePipeHandle* message_pipe_0,
 // These "raw" versions fully expose the underlying API, but don't help with
 // ownership of handles (especially when writing messages).
 // TODO(vtl): Write "baked" versions.
-inline MojoResult WriteMessageRaw(
-    MessagePipeHandle message_pipe,
-    const void* bytes, uint32_t num_bytes,
-    const MojoHandle* handles, uint32_t num_handles,
-    MojoWriteMessageFlags flags) {
-  return MojoWriteMessage(message_pipe.value(),
-                          bytes, num_bytes,
-                          handles, num_handles,
-                          flags);
+inline MojoResult WriteMessageRaw(MessagePipeHandle message_pipe,
+                                  const void* bytes,
+                                  uint32_t num_bytes,
+                                  const MojoHandle* handles,
+                                  uint32_t num_handles,
+                                  MojoWriteMessageFlags flags) {
+  return MojoWriteMessage(message_pipe.value(), bytes, num_bytes, handles,
+                          num_handles, flags);
 }
 
 inline MojoResult ReadMessageRaw(MessagePipeHandle message_pipe,
-                                 void* bytes, uint32_t* num_bytes,
-                                 MojoHandle* handles, uint32_t* num_handles,
+                                 void* bytes,
+                                 uint32_t* num_bytes,
+                                 MojoHandle* handles,
+                                 uint32_t* num_handles,
                                  MojoReadMessageFlags flags) {
-  return MojoReadMessage(message_pipe.value(),
-                         bytes, num_bytes,
-                         handles, num_handles,
-                         flags);
+  return MojoReadMessage(message_pipe.value(), bytes, num_bytes, handles,
+                         num_handles, flags);
 }
 
-inline MojoTimeTicks GetTimeTicksNow() {
-  return MojoGetTimeTicksNow();
+// DataPipeProducerHandle and DataPipeConsumerHandle ---------------------------
+
+class DataPipeProducerHandle : public Handle {
+ public:
+  DataPipeProducerHandle() {}
+  explicit DataPipeProducerHandle(MojoHandle value) : Handle(value) {}
+
+  // Copying and assignment allowed.
+};
+
+MOJO_COMPILE_ASSERT(sizeof(DataPipeProducerHandle) == sizeof(Handle),
+                    bad_size_for_cpp_DataPipeProducerHandle);
+
+typedef ScopedHandleBase<DataPipeProducerHandle> ScopedDataPipeProducerHandle;
+MOJO_COMPILE_ASSERT(sizeof(ScopedDataPipeProducerHandle) ==
+                        sizeof(DataPipeProducerHandle),
+                    bad_size_for_cpp_ScopedDataPipeProducerHandle);
+
+class DataPipeConsumerHandle : public Handle {
+ public:
+  DataPipeConsumerHandle() {}
+  explicit DataPipeConsumerHandle(MojoHandle value) : Handle(value) {}
+
+  // Copying and assignment allowed.
+};
+
+MOJO_COMPILE_ASSERT(sizeof(DataPipeConsumerHandle) == sizeof(Handle),
+                    bad_size_for_cpp_DataPipeConsumerHandle);
+
+typedef ScopedHandleBase<DataPipeConsumerHandle> ScopedDataPipeConsumerHandle;
+MOJO_COMPILE_ASSERT(sizeof(ScopedDataPipeConsumerHandle) ==
+                        sizeof(DataPipeConsumerHandle),
+                    bad_size_for_cpp_ScopedDataPipeConsumerHandle);
+
+// TODO(vtl): Make more friendly wrappers (e.g., a create that doesn't "require"
+// |options|; maybe templatized functions that are optimized for a particular
+// "type" instead of some vague "element", or functions that take a "vector").
+inline MojoResult CreateDataPipe(
+    const MojoCreateDataPipeOptions* options,
+    ScopedDataPipeProducerHandle* data_pipe_producer,
+    ScopedDataPipeConsumerHandle* data_pipe_consumer) {
+  assert(data_pipe_producer);
+  assert(data_pipe_consumer);
+  DataPipeProducerHandle producer_handle;
+  DataPipeConsumerHandle consumer_handle;
+  MojoResult rv = MojoCreateDataPipe(options,
+                                     producer_handle.mutable_value(),
+                                     consumer_handle.mutable_value());
+  // Reset even on failure (reduces the chances that a "stale"/incorrect handle
+  // will be used).
+  data_pipe_producer->reset(producer_handle);
+  data_pipe_consumer->reset(consumer_handle);
+  return rv;
+}
+
+inline MojoResult WriteDataRaw(DataPipeProducerHandle data_pipe_producer,
+                               const void* elements,
+                               uint32_t* num_bytes,
+                               MojoWriteDataFlags flags) {
+  return MojoWriteData(data_pipe_producer.value(), elements, num_bytes, flags);
+}
+
+inline MojoResult BeginWriteDataRaw(DataPipeProducerHandle data_pipe_producer,
+                                    void** buffer,
+                                    uint32_t* buffer_num_bytes,
+                                    MojoWriteDataFlags flags) {
+  return MojoBeginWriteData(data_pipe_producer.value(), buffer,
+                            buffer_num_bytes, flags);
+}
+
+inline MojoResult EndWriteDataRaw(DataPipeProducerHandle data_pipe_producer,
+                                  uint32_t num_bytes_written) {
+  return MojoEndWriteData(data_pipe_producer.value(), num_bytes_written);
+}
+
+inline MojoResult ReadDataRaw(DataPipeConsumerHandle data_pipe_consumer,
+                              void* elements,
+                              uint32_t* num_bytes,
+                              MojoReadDataFlags flags) {
+  return MojoReadData(data_pipe_consumer.value(), elements, num_bytes, flags);
+}
+
+inline MojoResult BeginReadDataRaw(DataPipeConsumerHandle data_pipe_consumer,
+                                   const void** buffer,
+                                   uint32_t* buffer_num_bytes,
+                                   MojoReadDataFlags flags) {
+  return MojoBeginReadData(data_pipe_consumer.value(), buffer, buffer_num_bytes,
+                           flags);
+}
+
+inline MojoResult EndReadDataRaw(DataPipeConsumerHandle data_pipe_consumer,
+                                 uint32_t num_bytes_read) {
+  return MojoEndReadData(data_pipe_consumer.value(), num_bytes_read);
 }
 
 }  // namespace mojo
diff --git a/mojo/public/tests/system_core_cpp_unittest.cc b/mojo/public/tests/system_core_cpp_unittest.cc
index a910c6e..8bce421 100644
--- a/mojo/public/tests/system_core_cpp_unittest.cc
+++ b/mojo/public/tests/system_core_cpp_unittest.cc
@@ -374,5 +374,7 @@ TEST(CoreCppTest, TearDownWithMessagesEnqueued) {
   }
 }
 
+// TODO(vtl): Write data pipe tests.
+
 }  // namespace
 }  // namespace mojo