Mojo: Add a C++ DataPipe wrapper paralleling the MessagePipe wrapper.

mojo/public/system/core_cpp.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MOJO_PUBLIC_SYSTEM_CORE_CPP_H_
 #define MOJO_PUBLIC_SYSTEM_CORE_CPP_H_
 
 #include <assert.h>
+#include <stddef.h>
 
 #include <limits>
 
 #include "mojo/public/system/core.h"
 #include "mojo/public/system/macros.h"
 #include "mojo/public/system/system_export.h"
 
 namespace mojo {
 
 // Standalone functions --------------------------------------------------------
@@ skipping 173 matching lines @@
   assert(message_pipe1);
   MessagePipeHandle h0;
   MessagePipeHandle h1;
   MojoResult result MOJO_ALLOW_UNUSED =
       MojoCreateMessagePipe(h0.mutable_value(), h1.mutable_value());
   assert(result == MOJO_RESULT_OK);
   message_pipe0->reset(h0);
   message_pipe1->reset(h1);
 }
 
+// A wrapper class that automatically creates a message pipe and owns both
+// handles.
 class MessagePipe {
  public:
   MessagePipe();
   ~MessagePipe();
 
   ScopedMessagePipeHandle handle0;
   ScopedMessagePipeHandle handle1;
 };
 
-inline MessagePipe::MessagePipe() { CreateMessagePipe(&handle0, &handle1); }
-inline MessagePipe::~MessagePipe() {}
+inline MessagePipe::MessagePipe() {
+  CreateMessagePipe(&handle0, &handle1);
+}
+
+inline MessagePipe::~MessagePipe() {
+}
 
 // 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) {
@@ skipping 38 matching lines @@
 };
 
 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(),
@@ skipping 38 matching lines @@
                                    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);
 }
 
+// A wrapper class that automatically creates a data pipe and owns both handles.
+// TODO(vtl): Make an even more friendly version? (Maybe templatized for a
+// particular type instead of some "element"? Maybe functions that take
+// vectors?)
+class DataPipe {
+ public:
+  DataPipe();
+  explicit DataPipe(const MojoCreateDataPipeOptions& options);
+  ~DataPipe();
+
+  ScopedDataPipeProducerHandle producer_handle;
+  ScopedDataPipeConsumerHandle consumer_handle;
+};
+
+inline DataPipe::DataPipe() {
+  CreateDataPipe(NULL, &producer_handle, &consumer_handle);
+}
+
+inline DataPipe::DataPipe(const MojoCreateDataPipeOptions& options) {
+  CreateDataPipe(&options, &producer_handle, &consumer_handle);
+}
+
+inline DataPipe::~DataPipe() {
+}
+
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_SYSTEM_CORE_CPP_H_