EDK: Add MojoHandleRights to DispatcherTransport.

mojo/edk/system/remote_data_pipe_impl_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.
 
 // This file tests both |RemoteProducerDataPipeImpl| and
 // |RemoteConsumerDataPipeImpl|.
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/edk/platform/platform_pipe.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint.h"
 #include "mojo/edk/system/data_pipe.h"
 #include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
 #include "mojo/edk/system/data_pipe_producer_dispatcher.h"
+#include "mojo/edk/system/handle.h"
 #include "mojo/edk/system/handle_transport.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/message_pipe.h"
 #include "mojo/edk/system/raw_channel.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/util/ref_ptr.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 138 matching lines @@
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   RefPtr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
   // This is the consumer dispatcher we'll send.
   auto consumer = DataPipeConsumerDispatcher::Create();
   consumer->Init(dp.Clone());
+  Handle consumer_handle(std::move(consumer), MOJO_HANDLE_RIGHT_TRANSFER |
+                                                  MOJO_HANDLE_RIGHT_READ |
+                                                  MOJO_HANDLE_RIGHT_WRITE);
 
   // Write to the producer and close it, before sending the consumer.
   int32_t elements[10] = {123};
   uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(elements),
                                   MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
   dp->ProducerClose();
 
   // Write the consumer to MP 0 (port 0). Wait and receive on MP 1 (port 0).
   // (Add the waiter first, to avoid any handling the case where it's already
   // readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             message_pipe(1)->AddAwakable(
                 0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
   {
     DispatcherTransport transport(
-        test::DispatcherTryStartTransport(consumer.get()));
+        test::HandleTryStartTransport(consumer_handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(MOJO_RESULT_OK, message_pipe(0)->WriteMessage(
                                   0, NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
-    // |consumer| should have been closed. This is |DCHECK()|ed when it is
-    // destroyed.
-    EXPECT_TRUE(consumer->HasOneRef());
-    consumer = nullptr;
+    // |consumer_handle.dispatcher| should have been closed. This is
+    // |DCHECK()|ed when it is destroyed.
+    EXPECT_TRUE(consumer_handle.dispatcher->HasOneRef());
+    consumer_handle.reset();
   }
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::ActionTimeout(), &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   message_pipe(1)->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
                 MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ skipping 68 matching lines @@
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   RefPtr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
   // This is the consumer dispatcher we'll send.
   auto consumer = DataPipeConsumerDispatcher::Create();
   consumer->Init(dp.Clone());
+  Handle consumer_handle(std::move(consumer), MOJO_HANDLE_RIGHT_TRANSFER |
+                                                  MOJO_HANDLE_RIGHT_READ |
+                                                  MOJO_HANDLE_RIGHT_WRITE);
 
   void* write_ptr = nullptr;
   uint32_t num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                        MakeUserPointer(&num_bytes)));
   ASSERT_GE(num_bytes, 1u * sizeof(int32_t));
 
   // Write the consumer to MP 0 (port 0). Wait and receive on MP 1 (port 0).
   // (Add the waiter first, to avoid any handling the case where it's already
   // readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             message_pipe(1)->AddAwakable(
                 0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
   {
     DispatcherTransport transport(
-        test::DispatcherTryStartTransport(consumer.get()));
+        test::HandleTryStartTransport(consumer_handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(MOJO_RESULT_OK, message_pipe(0)->WriteMessage(
                                   0, NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
-    // |consumer| should have been closed. This is |DCHECK()|ed when it is
-    // destroyed.
-    EXPECT_TRUE(consumer->HasOneRef());
-    consumer = nullptr;
+    // |consumer_handle.dispatcher| should have been closed. This is
+    // |DCHECK()|ed when it is destroyed.
+    EXPECT_TRUE(consumer_handle.dispatcher->HasOneRef());
+    consumer_handle.reset();
   }
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::ActionTimeout(), &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   message_pipe(1)->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
                 MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ skipping 62 matching lines @@
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   RefPtr<DataPipe> dp(CreateLocal(sizeof(int32_t), 1000));
   // This is the consumer dispatcher we'll send.
   auto consumer = DataPipeConsumerDispatcher::Create();
   consumer->Init(dp.Clone());
+  Handle consumer_handle(std::move(consumer), MOJO_HANDLE_RIGHT_TRANSFER |
+                                                  MOJO_HANDLE_RIGHT_READ |
+                                                  MOJO_HANDLE_RIGHT_WRITE);
 
   void* write_ptr = nullptr;
   uint32_t num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                        MakeUserPointer(&num_bytes)));
   ASSERT_GE(num_bytes, 1u * sizeof(int32_t));
   *static_cast<int32_t*>(write_ptr) = 123456;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(
                                 static_cast<uint32_t>(1u * sizeof(int32_t))));
 
   write_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                        MakeUserPointer(&num_bytes)));
   ASSERT_GE(num_bytes, 1u * sizeof(int32_t));
 
   // Write the consumer to MP 0 (port 0). Wait and receive on MP 1 (port 0).
   // (Add the waiter first, to avoid any handling the case where it's already
   // readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             message_pipe(1)->AddAwakable(
                 0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
   {
     DispatcherTransport transport(
-        test::DispatcherTryStartTransport(consumer.get()));
+        test::HandleTryStartTransport(consumer_handle));
     EXPECT_TRUE(transport.is_valid());
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
     EXPECT_EQ(MOJO_RESULT_OK, message_pipe(0)->WriteMessage(
                                   0, NullUserPointer(), 0, &transports,
                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
-    // |consumer| should have been closed. This is |DCHECK()|ed when it is
-    // destroyed.
-    EXPECT_TRUE(consumer->HasOneRef());
-    consumer = nullptr;
+    // |consumer_handle.dispatcher| should have been closed. This is
+    // |DCHECK()|ed when it is destroyed.
+    EXPECT_TRUE(consumer_handle.dispatcher->HasOneRef());
+    consumer_handle.reset();
   }
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(test::ActionTimeout(), &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   message_pipe(1)->RemoveAwakable(0, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
                 MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             hss.satisfiable_signals);
@@ skipping 51 matching lines @@
   EXPECT_EQ(123456, elements[0]);
   EXPECT_EQ(789012, elements[1]);
   EXPECT_EQ(0, elements[2]);
 
   consumer->Close();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo