EDK: Add MojoHandleRights to DispatcherTransport.

mojo/edk/system/multiprocess_message_pipe_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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "build/build_config.h"  // TODO(vtl): Remove this.
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/edk/platform/platform_handle_utils_posix.h"
 #include "mojo/edk/platform/platform_shared_buffer.h"
 #include "mojo/edk/platform/scoped_platform_handle.h"
 #include "mojo/edk/system/channel.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_test_utils.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/system/shared_buffer_dispatcher.h"
 #include "mojo/edk/system/test/scoped_test_dir.h"
 #include "mojo/edk/util/ref_ptr.h"
 #include "mojo/edk/util/scoped_file.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 284 matching lines @@
   auto mp = MessagePipe::CreateLocalProxy(&ep);
   Init(std::move(ep));
 
   // Make a shared buffer.
   MojoResult result = MOJO_RESULT_INTERNAL;
   auto dispatcher = SharedBufferDispatcher::Create(
       platform_support(), SharedBufferDispatcher::kDefaultCreateOptions, 100,
       &result);
   EXPECT_EQ(MOJO_RESULT_OK, result);
   ASSERT_TRUE(dispatcher);
+  Handle handle(std::move(dispatcher),
+                MOJO_HANDLE_RIGHT_DUPLICATE | MOJO_HANDLE_RIGHT_TRANSFER |
+                    MOJO_HANDLE_RIGHT_READ | MOJO_HANDLE_RIGHT_WRITE);
 
   // Make a mapping.
   std::unique_ptr<PlatformSharedBufferMapping> mapping;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
+  EXPECT_EQ(MOJO_RESULT_OK, handle.dispatcher->MapBuffer(
+                                0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
   ASSERT_TRUE(mapping);
   ASSERT_TRUE(mapping->GetBase());
   ASSERT_EQ(100u, mapping->GetLength());
 
   // Send the shared buffer.
   const std::string go1("go 1");
-  DispatcherTransport transport(
-      test::DispatcherTryStartTransport(dispatcher.get()));
+  DispatcherTransport transport(test::HandleTryStartTransport(handle));
   ASSERT_TRUE(transport.is_valid());
 
   std::vector<DispatcherTransport> transports;
   transports.push_back(transport);
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(0, UserPointer<const void>(&go1[0]),
                              static_cast<uint32_t>(go1.size()), &transports,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   transport.End();
 
-  EXPECT_TRUE(dispatcher->HasOneRef());
-  dispatcher = nullptr;
+  EXPECT_TRUE(handle.dispatcher->HasOneRef());
+  handle.reset();
 
   // Wait for a message from the child.
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_OK,
             test::WaitIfNecessary(mp.get(), MOJO_HANDLE_SIGNAL_READABLE, &hss));
   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
@@ skipping 96 matching lines @@
 
 TEST_P(MultiprocessMessagePipeTestWithPipeCount, PlatformHandlePassing) {
   test::ScopedTestDir test_dir;
 
   helper()->StartChild("CheckPlatformHandleFile");
 
   RefPtr<ChannelEndpoint> ep;
   auto mp = MessagePipe::CreateLocalProxy(&ep);
   Init(std::move(ep));
 
-  std::vector<RefPtr<PlatformHandleDispatcher>> dispatchers;
+  std::vector<Handle> handles;
   std::vector<DispatcherTransport> transports;
 
   size_t pipe_count = GetParam();
   for (size_t i = 0; i < pipe_count; ++i) {
     util::ScopedFILE fp(test_dir.CreateFile());
     const std::string world("world");
     CHECK_EQ(fwrite(&world[0], 1, world.size(), fp.get()), world.size());
     fflush(fp.get());
     rewind(fp.get());
 
-    auto dispatcher = PlatformHandleDispatcher::Create(
-        ScopedPlatformHandle(PlatformHandleFromFILE(std::move(fp))));
-    dispatchers.push_back(dispatcher);
+    Handle handle(PlatformHandleDispatcher::Create(ScopedPlatformHandle(
+                      PlatformHandleFromFILE(std::move(fp)))),
+                  MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_READ |
+                      MOJO_HANDLE_RIGHT_WRITE);
+    handles.push_back(std::move(handle));
     DispatcherTransport transport(
-        test::DispatcherTryStartTransport(dispatcher.get()));
+        test::HandleTryStartTransport(handles.back()));
     ASSERT_TRUE(transport.is_valid());
     transports.push_back(transport);
   }
 
   char message[128];
   sprintf(message, "hello %d", static_cast<int>(pipe_count));
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(0, UserPointer<const void>(message),
                              static_cast<uint32_t>(strlen(message)),
                              &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   for (size_t i = 0; i < pipe_count; ++i) {
     transports[i].End();
-    EXPECT_TRUE(dispatchers[i]->HasOneRef());
+    EXPECT_TRUE(handles[i].dispatcher->HasOneRef());
   }
 
-  dispatchers.clear();
+  handles.clear();
 
   // Wait for it to become readable, which should fail.
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             test::WaitIfNecessary(mp.get(), MOJO_HANDLE_SIGNAL_READABLE, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
   mp->Close(0);
 
   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 // Android multi-process tests are not executing the new process. This is flaky.
 #if !defined(OS_ANDROID)
 INSTANTIATE_TEST_CASE_P(PipeCount,
                         MultiprocessMessagePipeTestWithPipeCount,
                         testing::Values(1u, 128u, 140u));
 #endif
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo