Convert mojo::system::Dispatcher to use our new refcounting stuff (instead of base's).

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>
 
@@ skipping 26 matching lines @@
 using test::TestIOThread;
 
 namespace system {
 namespace {
 
 const char kConnectionIdFlag[] = "test-connection-id";
 
 // Tests writing a message (containing just data) to |write_mp| and then reading
 // it from |read_mp| (it should be the next message, i.e., there should be no
 // other messages already enqueued in that direction).
-void TestWriteReadMessage(scoped_refptr<MessagePipeDispatcher> write_mp,
-                          scoped_refptr<MessagePipeDispatcher> read_mp) {
+void TestWriteReadMessage(MessagePipeDispatcher* write_mp,
+                          MessagePipeDispatcher* read_mp) {
   // Set up waiting on the read end first (to avoid racing).
   Waiter waiter;
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       read_mp->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 0, nullptr));
 
   // Write a message with just 'x' through the write end.
   EXPECT_EQ(MOJO_RESULT_OK,
             write_mp->WriteMessage(UserPointer<const void>("x"), 1, nullptr,
@@ skipping 10 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).
-scoped_refptr<MessagePipeDispatcher> SendMessagePipeDispatcher(
-    scoped_refptr<MessagePipeDispatcher> write_mp,
-    scoped_refptr<MessagePipeDispatcher> read_mp,
-    scoped_refptr<MessagePipeDispatcher> mp_to_send) {
-  CHECK_NE(mp_to_send, write_mp);
-  CHECK_NE(mp_to_send, read_mp);
+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);
 
   // 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.
   DispatcherTransport transport(
       test::DispatcherTryStartTransport(mp_to_send.get()));
   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;
 
   // Wait for it to arrive.
   CHECK_EQ(waiter.Wait(test::ActionDeadline(), 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,
                            &num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE),
       MOJO_RESULT_OK);
   CHECK_EQ(dispatchers.size(), 1u);
   CHECK_EQ(num_dispatchers, 1u);
   CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::Type::MESSAGE_PIPE);
-  return scoped_refptr<MessagePipeDispatcher>(
+  return RefPtr<MessagePipeDispatcher>(
       static_cast<MessagePipeDispatcher*>(dispatchers[0].get()));
 }
 
 class TestMasterProcessDelegate : public embedder::MasterProcessDelegate {
  public:
   TestMasterProcessDelegate()
       : on_slave_disconnect_event_(false, false) {}  // Auto reset.
   ~TestMasterProcessDelegate() override {}
 
   // Warning: There's only one slave disconnect event (which resets
@@ skipping 36 matching lines @@
                       IPCSupport* master_ipc_support)
       : test_io_thread_(test_io_thread),
         master_ipc_support_(master_ipc_support),
         connection_id_(master_ipc_support_->GenerateConnectionIdentifier()),
         slave_id_(kInvalidProcessIdentifier),
         event_(true, false) {}
   ~TestSlaveConnection() {}
 
   // After this is called, |ShutdownChannelToSlave()| must be called (possibly
   // after |WaitForChannelToSlave()|) before destruction.
-  scoped_refptr<MessagePipeDispatcher> ConnectToSlave() {
+  RefPtr<MessagePipeDispatcher> ConnectToSlave() {
     embedder::PlatformChannelPair channel_pair;
     // Note: |ChannelId|s and |ProcessIdentifier|s are interchangeable.
-    scoped_refptr<MessagePipeDispatcher> mp =
-        master_ipc_support_->ConnectToSlave(
-            connection_id_, nullptr, channel_pair.PassServerHandle(),
-            base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event_)),
-            nullptr, &slave_id_);
+    RefPtr<MessagePipeDispatcher> mp = master_ipc_support_->ConnectToSlave(
+        connection_id_, nullptr, channel_pair.PassServerHandle(),
+        base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event_)),
+        nullptr, &slave_id_);
     EXPECT_TRUE(mp);
     EXPECT_NE(slave_id_, kInvalidProcessIdentifier);
     EXPECT_NE(slave_id_, kMasterProcessIdentifier);
     slave_platform_handle_ = channel_pair.PassClientHandle();
     return mp;
   }
 
   void WaitForChannelToSlave() {
     EXPECT_TRUE(event_.TimedWait(TestTimeouts::action_timeout()));
   }
@@ skipping 13 matching lines @@
     return slave_platform_handle_.Pass();
   }
 
   const ConnectionIdentifier& connection_id() const { return connection_id_; }
 
  private:
   TestIOThread* const test_io_thread_;
   IPCSupport* const master_ipc_support_;
   const ConnectionIdentifier connection_id_;
   // The master's message pipe dispatcher.
-  scoped_refptr<MessagePipeDispatcher> message_pipe_;
+  RefPtr<MessagePipeDispatcher> message_pipe_;
   ProcessIdentifier slave_id_;
   base::WaitableEvent event_;
   embedder::ScopedPlatformHandle slave_platform_handle_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestSlaveConnection);
 };
 
 // Encapsulates the state of a slave. (Note, however, that we share a
 // |PlatformSupport| and an I/O thread.)
 class TestSlave {
  public:
   // Note: Before destruction, |ShutdownIPCSupport()| must be called.
   TestSlave(embedder::PlatformSupport* platform_support,
             TestIOThread* test_io_thread,
             embedder::ScopedPlatformHandle platform_handle)
       : test_io_thread_(test_io_thread),
         slave_ipc_support_(platform_support,
                            embedder::ProcessType::SLAVE,
                            test_io_thread->task_runner(),
                            &slave_process_delegate_,
                            test_io_thread->task_runner(),
                            platform_handle.Pass()),
         event_(true, false) {}
   ~TestSlave() {}
 
   // After this is called, |ShutdownChannelToMaster()| must be called (possibly
   // after |WaitForChannelToMaster()|) before destruction.
-  scoped_refptr<MessagePipeDispatcher> ConnectToMaster(
+  RefPtr<MessagePipeDispatcher> ConnectToMaster(
       const ConnectionIdentifier& connection_id) {
     ProcessIdentifier master_id = kInvalidProcessIdentifier;
-    scoped_refptr<MessagePipeDispatcher> mp =
-        slave_ipc_support_.ConnectToMaster(
-            connection_id,
-            base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event_)),
-            nullptr, &master_id);
+    RefPtr<MessagePipeDispatcher> mp = slave_ipc_support_.ConnectToMaster(
+        connection_id,
+        base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event_)),
+        nullptr, &master_id);
     EXPECT_TRUE(mp);
     EXPECT_EQ(kMasterProcessIdentifier, master_id);
     return mp;
   }
 
   void WaitForChannelToMaster() {
     EXPECT_TRUE(event_.TimedWait(TestTimeouts::action_timeout()));
   }
 
   void ShutdownChannelToMaster() {
@@ skipping 45 matching lines @@
     slave_connection_.reset(
         new TestSlaveConnection(test_io_thread_, master_ipc_support_));
     master_mp_ = slave_connection_->ConnectToSlave();
 
     slave_.reset(new TestSlave(platform_support_, test_io_thread_,
                                slave_connection_->PassSlavePlatformHandle()));
     slave_mp_ = slave_->ConnectToMaster(slave_connection_->connection_id());
   }
 
   void TestConnection() {
-    TestWriteReadMessage(master_mp_, slave_mp_);
-    TestWriteReadMessage(slave_mp_, master_mp_);
+    TestWriteReadMessage(master_mp_.get(), slave_mp_.get());
+    TestWriteReadMessage(slave_mp_.get(), master_mp_.get());
   }
 
-  scoped_refptr<MessagePipeDispatcher> PassMasterMessagePipe() {
+  RefPtr<MessagePipeDispatcher> PassMasterMessagePipe() {
     return master_mp_.Pass();
   }
 
-  scoped_refptr<MessagePipeDispatcher> PassSlaveMessagePipe() {
+  RefPtr<MessagePipeDispatcher> PassSlaveMessagePipe() {
     return slave_mp_.Pass();
   }
 
   void Shutdown() {
     if (master_mp_) {
       master_mp_->Close();
       master_mp_ = nullptr;
     }
     if (slave_mp_) {
       slave_mp_->Close();
@@ skipping 17 matching lines @@
   // Note: To close the slave message pipe, use |PassSlaveMessagePipe()|.
   MessagePipeDispatcher* slave_mp() { return slave_mp_.get(); }
 
  private:
   embedder::SimplePlatformSupport* const platform_support_;
   TestIOThread* const test_io_thread_;
   TestMasterProcessDelegate* const master_process_delegate_;
   IPCSupport* const master_ipc_support_;
 
   std::unique_ptr<TestSlaveConnection> slave_connection_;
-  scoped_refptr<MessagePipeDispatcher> master_mp_;
+  RefPtr<MessagePipeDispatcher> master_mp_;
 
   std::unique_ptr<TestSlave> slave_;
-  scoped_refptr<MessagePipeDispatcher> slave_mp_;
+  RefPtr<MessagePipeDispatcher> slave_mp_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestSlaveSetup);
 };
 
 class IPCSupportTest : public testing::Test {
  public:
   // Note: Run master process delegate methods on the I/O thread.
   IPCSupportTest()
       : test_io_thread_(TestIOThread::StartMode::AUTO),
         master_ipc_support_(&platform_support_,
@@ skipping 32 matching lines @@
   TestIOThread test_io_thread_;
 
   // All tests require a master.
   TestMasterProcessDelegate master_process_delegate_;
   IPCSupport master_ipc_support_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(IPCSupportTest);
 };
 
 using MessagePipeDispatcherPair =
-    std::pair<scoped_refptr<MessagePipeDispatcher>,
-              scoped_refptr<MessagePipeDispatcher>>;
+    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 29 matching lines @@
 // going away.
 TEST_F(IPCSupportTest, ConnectTwoSlaves) {
   std::unique_ptr<TestSlaveSetup> s1(SetupSlave());
   std::unique_ptr<TestSlaveSetup> s2(SetupSlave());
   s1->TestConnection();
   s2->TestConnection();
 
   // Make a message pipe (logically "in" the master) and send one end to each
   // slave.
   MessagePipeDispatcherPair send_mp = CreateMessagePipe();
-  scoped_refptr<MessagePipeDispatcher> slave1_received_mp =
-      SendMessagePipeDispatcher(s1->master_mp(), s1->slave_mp(), send_mp.first);
-  scoped_refptr<MessagePipeDispatcher> slave2_received_mp =
-      SendMessagePipeDispatcher(s2->master_mp(), s2->slave_mp(),
-                                send_mp.second);
+  RefPtr<MessagePipeDispatcher> slave1_received_mp = SendMessagePipeDispatcher(
+      s1->master_mp(), s1->slave_mp(), std::move(send_mp.first));
+  RefPtr<MessagePipeDispatcher> slave2_received_mp = SendMessagePipeDispatcher(
+      s2->master_mp(), s2->slave_mp(), std::move(send_mp.second));
 
   // These should be connected.
-  TestWriteReadMessage(slave1_received_mp, slave2_received_mp);
-  TestWriteReadMessage(slave2_received_mp, slave1_received_mp);
+  TestWriteReadMessage(slave1_received_mp.get(), slave2_received_mp.get());
+  TestWriteReadMessage(slave2_received_mp.get(), slave1_received_mp.get());
 
   s1->PassMasterMessagePipe()->Close();
   s2->PassMasterMessagePipe()->Close();
   s1->PassSlaveMessagePipe()->Close();
   s2->PassSlaveMessagePipe()->Close();
 
   // They should still be connected.
-  TestWriteReadMessage(slave1_received_mp, slave2_received_mp);
-  TestWriteReadMessage(slave2_received_mp, slave1_received_mp);
+  TestWriteReadMessage(slave1_received_mp.get(), slave2_received_mp.get());
+  TestWriteReadMessage(slave2_received_mp.get(), slave1_received_mp.get());
 
   slave1_received_mp->Close();
   slave2_received_mp->Close();
 
   s1->Shutdown();
   s2->Shutdown();
 
   ShutdownMasterIPCSupport();
 }
 
 // Like |ConnectTwoSlaves|, but does it twice, to test reusing a connection.
 TEST_F(IPCSupportTest, ConnectTwoSlavesTwice) {
   std::unique_ptr<TestSlaveSetup> s1(SetupSlave());
   std::unique_ptr<TestSlaveSetup> s2(SetupSlave());
   s1->TestConnection();
   s2->TestConnection();
 
   MessagePipeDispatcherPair send_mp1 = CreateMessagePipe();
-  scoped_refptr<MessagePipeDispatcher> slave1_received_mp1 =
-      SendMessagePipeDispatcher(s1->master_mp(), s1->slave_mp(),
-                                send_mp1.first);
-  scoped_refptr<MessagePipeDispatcher> slave2_received_mp1 =
-      SendMessagePipeDispatcher(s2->master_mp(), s2->slave_mp(),
-                                send_mp1.second);
+  RefPtr<MessagePipeDispatcher> slave1_received_mp1 = SendMessagePipeDispatcher(
+      s1->master_mp(), s1->slave_mp(), std::move(send_mp1.first));
+  RefPtr<MessagePipeDispatcher> slave2_received_mp1 = SendMessagePipeDispatcher(
+      s2->master_mp(), s2->slave_mp(), std::move(send_mp1.second));
 
   MessagePipeDispatcherPair send_mp2 = CreateMessagePipe();
-  scoped_refptr<MessagePipeDispatcher> slave1_received_mp2 =
-      SendMessagePipeDispatcher(s1->master_mp(), s1->slave_mp(),
-                                send_mp2.first);
-  scoped_refptr<MessagePipeDispatcher> slave2_received_mp2 =
-      SendMessagePipeDispatcher(s2->master_mp(), s2->slave_mp(),
-                                send_mp2.second);
+  RefPtr<MessagePipeDispatcher> slave1_received_mp2 = SendMessagePipeDispatcher(
+      s1->master_mp(), s1->slave_mp(), std::move(send_mp2.first));
+  RefPtr<MessagePipeDispatcher> slave2_received_mp2 = SendMessagePipeDispatcher(
+      s2->master_mp(), s2->slave_mp(), std::move(send_mp2.second));
 
   s1->PassMasterMessagePipe()->Close();
   s2->PassMasterMessagePipe()->Close();
   s1->PassSlaveMessagePipe()->Close();
   s2->PassSlaveMessagePipe()->Close();
 
-  TestWriteReadMessage(slave1_received_mp1, slave2_received_mp1);
-  TestWriteReadMessage(slave2_received_mp1, slave1_received_mp1);
+  TestWriteReadMessage(slave1_received_mp1.get(), slave2_received_mp1.get());
+  TestWriteReadMessage(slave2_received_mp1.get(), slave1_received_mp1.get());
 
-  TestWriteReadMessage(slave1_received_mp2, slave2_received_mp2);
-  TestWriteReadMessage(slave2_received_mp2, slave1_received_mp2);
+  TestWriteReadMessage(slave1_received_mp2.get(), slave2_received_mp2.get());
+  TestWriteReadMessage(slave2_received_mp2.get(), slave1_received_mp2.get());
 
   slave1_received_mp1->Close();
   slave2_received_mp1->Close();
 
-  TestWriteReadMessage(slave1_received_mp2, slave2_received_mp2);
-  TestWriteReadMessage(slave2_received_mp2, slave1_received_mp2);
+  TestWriteReadMessage(slave1_received_mp2.get(), slave2_received_mp2.get());
+  TestWriteReadMessage(slave2_received_mp2.get(), slave1_received_mp2.get());
 
   slave1_received_mp2->Close();
   slave2_received_mp2->Close();
 
   s1->Shutdown();
   s2->Shutdown();
 
   ShutdownMasterIPCSupport();
 }
 
 // Creates a message pipe in the slave, which sends both ends (in separate
 // messages) to the master.
 TEST_F(IPCSupportTest, SlavePassBackToMaster) {
   std::unique_ptr<TestSlaveSetup> s(SetupSlave());
 
   s->TestConnection();
 
   // Make a message pipe (logically "in" the slave) and send both ends
   // (separately) to the master.
   MessagePipeDispatcherPair send_mp = CreateMessagePipe();
-  scoped_refptr<MessagePipeDispatcher> received_mp1 =
-      SendMessagePipeDispatcher(s->slave_mp(), s->master_mp(), send_mp.first);
+  RefPtr<MessagePipeDispatcher> received_mp1 = SendMessagePipeDispatcher(
+      s->slave_mp(), s->master_mp(), std::move(send_mp.first));
 
-  TestWriteReadMessage(received_mp1, send_mp.second);
-  TestWriteReadMessage(send_mp.second, received_mp1);
+  TestWriteReadMessage(received_mp1.get(), send_mp.second.get());
+  TestWriteReadMessage(send_mp.second.get(), received_mp1.get());
 
-  scoped_refptr<MessagePipeDispatcher> received_mp2 =
-      SendMessagePipeDispatcher(s->slave_mp(), s->master_mp(), send_mp.second);
+  RefPtr<MessagePipeDispatcher> received_mp2 = SendMessagePipeDispatcher(
+      s->slave_mp(), s->master_mp(), std::move(send_mp.second));
 
   s->PassMasterMessagePipe()->Close();
   s->PassSlaveMessagePipe()->Close();
 
-  TestWriteReadMessage(received_mp1, received_mp2);
-  TestWriteReadMessage(received_mp2, received_mp1);
+  TestWriteReadMessage(received_mp1.get(), received_mp2.get());
+  TestWriteReadMessage(received_mp2.get(), received_mp1.get());
 
   s->Shutdown();
 
   // These should still be connected.
   // TODO(vtl): This is not yet implemented, thus will fail here!
-  // TestWriteReadMessage(received_mp1, received_mp2);
-  // TestWriteReadMessage(received_mp2, received_mp1);
+  // TestWriteReadMessage(received_mp1.get(), received_mp2.get());
+  // TestWriteReadMessage(received_mp2.get(), received_mp1.get());
 
   received_mp1->Close();
   received_mp2->Close();
 
   ShutdownMasterIPCSupport();
 }
 
 }  // namespace
 
 // Note: This test isn't in an anonymous namespace, since it needs to be
@@ skipping 134 matching lines @@
   test_io_thread.PostTaskAndWait(FROM_HERE,
                                  base::Bind(&IPCSupport::ShutdownOnIOThread,
                                             base::Unretained(&ipc_support)));
 }
 
 // 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