EDK: Add MojoHandleRights to DispatcherTransport.

mojo/edk/system/ipc_support_unittest.cc

 // Copyright 2015 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/ipc_support.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "mojo/edk/embedder/master_process_delegate.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/edk/embedder/slave_process_delegate.h"
 #include "mojo/edk/platform/platform_pipe.h"
 #include "mojo/edk/system/channel_manager.h"
 #include "mojo/edk/system/connection_identifier.h"
 #include "mojo/edk/system/dispatcher.h"
+#include "mojo/edk/system/handle.h"
 #include "mojo/edk/system/handle_transport.h"
 #include "mojo/edk/system/message_pipe.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/process_identifier.h"
 #include "mojo/edk/system/test/test_command_line.h"
 #include "mojo/edk/system/test/test_io_thread.h"
 #include "mojo/edk/system/test/timeouts.h"
 #include "mojo/edk/system/waiter.h"
 #include "mojo/edk/test/multiprocess_test_helper.h"
 #include "mojo/edk/test/test_utils.h"
@@ skipping 42 matching lines @@
             read_mp->ReadMessage(UserPointer<void>(buffer),
                                  MakeUserPointer(&buffer_size), 0, nullptr,
                                  MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(1u, buffer_size);
   EXPECT_EQ('x', buffer[0]);
 }
 
 // Writes a message pipe dispatcher (in a message) to |write_mp| and reads it
 // from |read_mp| (it should be the next message, i.e., there should be no other
 // other messages already enqueued in that direction).
+// TODO(vtl): Probably |mp_to_send| should be a |Handle|, and so should the
+// return value.
 RefPtr<MessagePipeDispatcher> SendMessagePipeDispatcher(
     MessagePipeDispatcher* write_mp,
     MessagePipeDispatcher* read_mp,
     RefPtr<MessagePipeDispatcher>&& mp_to_send) {
   CHECK_NE(mp_to_send.get(), write_mp);
   CHECK_NE(mp_to_send.get(), read_mp);
+  Handle mp_handle_to_send(std::move(mp_to_send), MOJO_HANDLE_RIGHT_TRANSFER |
+                                                      MOJO_HANDLE_RIGHT_READ |
+                                                      MOJO_HANDLE_RIGHT_WRITE);
 
   // Set up waiting on the read end first (to avoid racing).
   Waiter waiter;
   waiter.Init();
   CHECK_EQ(
       read_mp->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 0, nullptr),
       MOJO_RESULT_OK);
 
-  // Write a message with just |mp_to_send| through the write end.
+  // Write a message with just |mp_handle_to_send| through the write end.
   DispatcherTransport transport(
-      test::DispatcherTryStartTransport(mp_to_send.get()));
+      test::HandleTryStartTransport(mp_handle_to_send));
   CHECK(transport.is_valid());
   std::vector<DispatcherTransport> transports;
   transports.push_back(transport);
   CHECK_EQ(write_mp->WriteMessage(NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   transport.End();
-  mp_to_send = nullptr;
+  mp_handle_to_send.reset();
 
   // Wait for it to arrive.
   CHECK_EQ(waiter.Wait(test::ActionTimeout(), nullptr), MOJO_RESULT_OK);
   read_mp->RemoveAwakable(&waiter, nullptr);
 
   // Read the message from the read end.
   DispatcherVector dispatchers;
   uint32_t num_dispatchers = 10;
   CHECK_EQ(
       read_mp->ReadMessage(NullUserPointer(), NullUserPointer(), &dispatchers,
@@ skipping 288 matching lines @@
 
   // All tests require a master.
   TestMasterProcessDelegate master_process_delegate_;
   IPCSupport master_ipc_support_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(IPCSupportTest);
 };
 
 using MessagePipeDispatcherPair =
     std::pair<RefPtr<MessagePipeDispatcher>, RefPtr<MessagePipeDispatcher>>;
+
 MessagePipeDispatcherPair CreateMessagePipe() {
   MessagePipeDispatcherPair rv;
   rv.first = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   rv.second = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   auto mp = MessagePipe::CreateLocalLocal();
   rv.first->Init(mp.Clone(), 0);
   rv.second->Init(std::move(mp), 1);
   return rv;
@@ skipping 287 matching lines @@
 
   test_io_thread.PostTaskAndWait(
       [&ipc_support]() { ipc_support.ShutdownOnIOThread(); });
 }
 
 // TODO(vtl): Also test the case of the master "dying" before the slave. (The
 // slave should get OnMasterDisconnect(), which we currently don't test.)
 
 }  // namespace system
 }  // namespace mojo