Make it possible to write a message pipe endpoint's peer into it.

mojo/edk/system/core_unittest.cc

 // 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.
 
 #include "mojo/edk/system/core.h"
 
 #include <stdint.h>
 
 #include <limits>
 
@@ skipping 852 matching lines @@
   num_handles = MOJO_ARRAYSIZE(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(
                 h_passing[1], UserPointer<void>(buffer),
                 MakeUserPointer(&num_bytes), MakeUserPointer(handles),
                 MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(0u, num_handles);
 
-  // Make sure that you can't pass either of the message pipe's handles over
-  // itself.
+  // Make sure that you can't pass a message pipe handle over itself.
   EXPECT_EQ(MOJO_RESULT_BUSY,
             core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
                                  kHelloSize, MakeUserPointer(&h_passing[0]), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
-                                 kHelloSize, MakeUserPointer(&h_passing[1]), 1,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   MojoHandle h_passed[2];
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->CreateMessagePipe(NullUserPointer(),
                                       MakeUserPointer(&h_passed[0]),
                                       MakeUserPointer(&h_passed[1])));
 
   // Make sure that |h_passed[]| work properly.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello),
@@ skipping 703 matching lines @@
   // Complete the two-phase read.
   EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]);
   EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 1));
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
 }
 
+// Tests "faux leak" message pipe handle passing situations.
+TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing3) {
+  {
+    MojoHandle h0 = MOJO_HANDLE_INVALID;
+    MojoHandle h1 = MOJO_HANDLE_INVALID;
+    EXPECT_EQ(MOJO_RESULT_OK,
+              core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h0),
+                                        MakeUserPointer(&h1)));
+
+    // You can send a message pipe's peer handle over itself (and nothing bad
+    // happens).
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        core()->WriteMessage(h0, NullUserPointer(), 0, MakeUserPointer(&h1), 1,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+    // Of course, there's nothing to do afterwards except close the handle you
+    // have left.
+    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h0));
+  }
+
+  {
+    MojoHandle h0 = MOJO_HANDLE_INVALID;
+    MojoHandle h1 = MOJO_HANDLE_INVALID;
+    EXPECT_EQ(MOJO_RESULT_OK,
+              core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h0),
+                                        MakeUserPointer(&h1)));
+
+    MojoHandle h_passed[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
+    EXPECT_EQ(MOJO_RESULT_OK,
+              core()->CreateMessagePipe(NullUserPointer(),
+                                        MakeUserPointer(&h_passed[0]),
+                                        MakeUserPointer(&h_passed[1])));
+
+    // You can also write |h1| into some other message pipe.
+    EXPECT_EQ(MOJO_RESULT_OK,
+              core()->WriteMessage(h_passed[0], NullUserPointer(), 0,
+                                   MakeUserPointer(&h1), 1,
+                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+    // And then write both ends of that message pipe to |h0|.
+    EXPECT_EQ(MOJO_RESULT_OK,
+              core()->WriteMessage(h0, NullUserPointer(), 0,
+                                   MakeUserPointer(h_passed), 2,
+                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+    // Again, nothing bad happens, but again you can only close |h0|.
+    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h0));
+  }
+}
+
 struct TestAsyncWaiter {
   TestAsyncWaiter() : result(MOJO_RESULT_UNKNOWN) {}
 
   void Awake(MojoResult r) { result = r; }
 
   MojoResult result;
 };
 
 TEST_F(CoreTest, AsyncWait) {
   TestAsyncWaiter waiter;
@@ skipping 17 matching lines @@
   EXPECT_EQ(MOJO_RESULT_BUSY, waiter.result);
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 }
 
 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo