[mojo] Implement pipe fusion API

mojo/public/cpp/system/message_pipe.h

 // Copyright 2014 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.
 
 // This file provides a C++ wrapping around the Mojo C API for message pipes,
 // replacing the prefix of "Mojo" with a "mojo" namespace, and using more
 // strongly-typed representations of |MojoHandle|s.
 //
 // Please see "mojo/public/c/system/message_pipe.h" for complete documentation
 // of the API.
@@ skipping 71 matching lines @@
 inline MojoResult ReadMessageRaw(MessagePipeHandle message_pipe,
                                  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);
 }
 
+// Fuses two message pipes together at the given handles. See
+// |MojoFuseMessagePipes()| for complete documentation. Note that this may
+// reset the passed handle arguments on success or unrecoverable failure.
+inline MojoResult FuseMessagePipes(ScopedMessagePipeHandle *message_pipe0,

[yzshen1, 2016/03/10 23:49:03]

nit: * should be adjacent to the type, instead of the name. (here and the next
line)

[Ken Rockot(use gerrit already), 2016/03/11 00:32:46]

WontFix - obsolete :)

+                                   ScopedMessagePipeHandle *message_pipe1) {
+  MojoResult result = MojoFuseMessagePipes(message_pipe0->get().value(),
+                                           message_pipe1->get().value());
+  if (result == MOJO_RESULT_INVALID_ARGUMENT)
+    return result;
+
+  CHECK(result == MOJO_RESULT_FAILED_PRECONDITION || result == MOJO_RESULT_OK);
+
+  // The handles were closed internally.
+  (void)message_pipe0->release();
+  (void)message_pipe1->release();
+
+  return result;
+}
+
 // A wrapper class that automatically creates a message pipe and owns both
 // handles.
 class MessagePipe {
  public:
   MessagePipe();
   explicit MessagePipe(const MojoCreateMessagePipeOptions& options);
   ~MessagePipe();
 
   ScopedMessagePipeHandle handle0;
   ScopedMessagePipeHandle handle1;
 };
 
 inline MessagePipe::MessagePipe() {
   MojoResult result = CreateMessagePipe(nullptr, &handle0, &handle1);
   DCHECK_EQ(MOJO_RESULT_OK, result);
 }
 
 inline MessagePipe::MessagePipe(const MojoCreateMessagePipeOptions& options) {
   MojoResult result = CreateMessagePipe(&options, &handle0, &handle1);
   DCHECK_EQ(MOJO_RESULT_OK, result);
 }
 
 inline MessagePipe::~MessagePipe() {
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_SYSTEM_MESSAGE_PIPE_H_