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

mojo/edk/system/remote_message_pipe_unittest.cc

 // Copyright 2014 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 <utility>
@@ skipping 169 matching lines @@
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // Connect message pipes. MP 0, port 1 will be attached to channel 0 and
   // connected to MP 1, port 0, which will be attached to channel 1. This leaves
   // MP 0, port 0 and MP 1, port 1 as the "user-facing" endpoints.
 
   RefPtr<ChannelEndpoint> ep0;
-  scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+  auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
-  scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+  auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // Write in one direction: MP 0, port 0 -> ... -> MP 1, port 1.
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
@@ skipping 76 matching lines @@
 TEST_F(RemoteMessagePipeTest, PeerClosed) {
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // Connect message pipes. MP 0, port 1 will be attached to channel 0 and
   // connected to MP 1, port 0, which will be attached to channel 1. This leaves
   // MP 0, port 0 and MP 1, port 1 as the "user-facing" endpoints.
 
   RefPtr<ChannelEndpoint> ep0;
-  scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+  auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
-  scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+  auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // Close MP 0, port 0.
   mp0->Close(0);
 
   // Try to wait for MP 1, port 1 to be signaled with peer closed.
   waiter.Init();
   hss = HandleSignalsState();
   MojoResult result =
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 101, &hss);
@@ skipping 15 matching lines @@
   static const char kWorld[] = "world!!!1!!!1!";
   char buffer[100] = {0};
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // Connect message pipes as in the |Basic| test.
 
   RefPtr<ChannelEndpoint> ep0;
-  scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+  auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
-  scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+  auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // Now put another message pipe on the channel.
 
   // Do this by creating a message pipe (for the |channels(0)| side) and
   // attaching and running it, yielding the remote ID. A message is then sent
   // via |ep0| (i.e., sent using |mp0|, port 0) with this remote ID. Upon
   // receiving this message, |PassIncomingMessagePipe()| is used to obtain the
   // message pipe on the other side.
-  scoped_refptr<MessagePipe> mp2(MessagePipe::CreateLocalLocal());
+  auto mp2 = MessagePipe::CreateLocalLocal();
   ASSERT_TRUE(channels(0));
   size_t max_endpoint_info_size;
   size_t max_platform_handle_count;
   mp2->StartSerialize(1, channels(0), &max_endpoint_info_size,
                       &max_platform_handle_count);
   EXPECT_GT(max_endpoint_info_size, 0u);
   ASSERT_EQ(0u, max_platform_handle_count);
   std::unique_ptr<char[]> endpoint_info(new char[max_endpoint_info_size]);
   size_t endpoint_info_size;
   mp2->EndSerialize(1, channels(0), endpoint_info.get(), &endpoint_info_size,
@@ skipping 23 matching lines @@
   buffer_size = static_cast<uint32_t>(endpoint_info_size);
   EXPECT_EQ(MOJO_RESULT_OK,
             mp1->ReadMessage(1, UserPointer<void>(received_endpoint_info.get()),
                              MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(endpoint_info_size, static_cast<size_t>(buffer_size));
   EXPECT_EQ(0, memcmp(received_endpoint_info.get(), endpoint_info.get(),
                       endpoint_info_size));
 
   // Warning: The local side of mp3 is port 0, not port 1.
-  scoped_refptr<IncomingEndpoint> incoming_endpoint =
+  RefPtr<IncomingEndpoint> incoming_endpoint =
       channels(1)->DeserializeEndpoint(received_endpoint_info.get());
   ASSERT_TRUE(incoming_endpoint);
-  scoped_refptr<MessagePipe> mp3 = incoming_endpoint->ConvertToMessagePipe();
+  RefPtr<MessagePipe> mp3 = incoming_endpoint->ConvertToMessagePipe();
   ASSERT_TRUE(mp3);
 
   // Write: MP 2, port 0 -> MP 3, port 1.
 
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp3->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
 
   EXPECT_EQ(
@@ skipping 93 matching lines @@
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // Connect message pipes. MP 0, port 1 will be attached to channel 0 and
   // connected to MP 1, port 0, which will be attached to channel 1. This leaves
   // MP 0, port 0 and MP 1, port 1 as the "user-facing" endpoints.
 
   RefPtr<ChannelEndpoint> ep0;
-  scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+  auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
 
   // Write to MP 0, port 0.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                         nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Close MP 0, port 0 before it's even been attached to the channel and run.
   mp0->Close(0);
 
   BootstrapChannelEndpointNoWait(0, std::move(ep0));
 
   RefPtr<ChannelEndpoint> ep1;
-  scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+  auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   BootstrapChannelEndpointNoWait(1, std::move(ep1));
 
@@ skipping 27 matching lines @@
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // Connect message pipes. MP 0, port 1 will be attached to channel 0 and
   // connected to MP 1, port 0, which will be attached to channel 1. This leaves
   // MP 0, port 0 and MP 1, port 1 as the "user-facing" endpoints.
 
   RefPtr<ChannelEndpoint> ep0;
-  scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+  auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
 
   // Write to MP 0, port 0.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
                         nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   BootstrapChannelEndpointNoWait(0, std::move(ep0));
 
   // Close MP 0, port 0 before channel 1 is even connected.
   mp0->Close(0);
 
   RefPtr<ChannelEndpoint> ep1;
-  scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+  auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   BootstrapChannelEndpointNoWait(1, std::move(ep1));
 
@@ skipping 21 matching lines @@
   mp1->Close(1);
 }
 
 TEST_F(RemoteMessagePipeTest, HandlePassing) {
   static const char kHello[] = "hello";
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   RefPtr<ChannelEndpoint> ep0;
-  scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+  auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
-  scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+  auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // We'll try to pass this dispatcher.
   scoped_refptr<MessagePipeDispatcher> dispatcher =
       MessagePipeDispatcher::Create(
           MessagePipeDispatcher::kDefaultCreateOptions);
-  scoped_refptr<MessagePipe> local_mp(MessagePipe::CreateLocalLocal());
-  dispatcher->Init(local_mp, 0);
+  auto local_mp = MessagePipe::CreateLocalLocal();
+  dispatcher->Init(local_mp.Clone(), 0);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
@@ skipping 123 matching lines @@
   static const char kHello[] = "hello";
   static const char kWorld[] = "world!";
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // We'll try to pass this dispatcher.
   scoped_refptr<MessagePipeDispatcher> dispatcher =
       MessagePipeDispatcher::Create(
           MessagePipeDispatcher::kDefaultCreateOptions);
-  scoped_refptr<MessagePipe> local_mp(MessagePipe::CreateLocalLocal());
-  dispatcher->Init(local_mp, 0);
+  auto local_mp = MessagePipe::CreateLocalLocal();
+  dispatcher->Init(local_mp.Clone(), 0);
 
   hss = local_mp->GetHandleSignalsState(0);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
   // Write to the other end (|local_mp|, port 1), and then close it.
   EXPECT_EQ(
       MOJO_RESULT_OK,
       local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
                              nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = local_mp->GetHandleSignalsState(0);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
   // Then the second message....
   EXPECT_EQ(
       MOJO_RESULT_OK,
       local_mp->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
                              nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = local_mp->GetHandleSignalsState(0);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
   // Then close it.
   local_mp->Close(1);
 
   RefPtr<ChannelEndpoint> ep0;
-  scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+  auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
-  scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+  auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
@@ skipping 86 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
 }
 
 TEST_F(RemoteMessagePipeTest, SharedBufferPassing) {
   static const char kHello[] = "hello";
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   RefPtr<ChannelEndpoint> ep0;
-  scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+  auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
-  scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+  auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // We'll try to pass this dispatcher.
   scoped_refptr<SharedBufferDispatcher> dispatcher;
   EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
                                 platform_support(),
                                 SharedBufferDispatcher::kDefaultCreateOptions,
                                 100, &dispatcher));
   ASSERT_TRUE(dispatcher);
 
@@ skipping 98 matching lines @@
 TEST_F(RemoteMessagePipeTest, PlatformHandlePassing) {
   mojo::test::ScopedTestDir test_dir;
 
   static const char kHello[] = "hello";
   static const char kWorld[] = "world";
   Waiter waiter;
   uint32_t context = 0;
   HandleSignalsState hss;
 
   RefPtr<ChannelEndpoint> ep0;
-  scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+  auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
-  scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+  auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   util::ScopedFILE fp(test_dir.CreateFile());
   EXPECT_EQ(sizeof(kHello), fwrite(kHello, 1, sizeof(kHello), fp.get()));
   // We'll try to pass this dispatcher, which will cause a |PlatformHandle| to
   // be passed.
   scoped_refptr<PlatformHandleDispatcher> dispatcher =
       PlatformHandleDispatcher::Create(
           mojo::test::PlatformHandleFromFILE(fp.Pass()));
 
@@ skipping 76 matching lines @@
 // Test racing closes (on each end).
 // Note: A flaky failure would almost certainly indicate a problem in the code
 // itself (not in the test). Also, any logged warnings/errors would also
 // probably be indicative of bugs.
 TEST_F(RemoteMessagePipeTest, RacingClosesStress) {
   MojoDeadline delay = test::DeadlineFromMilliseconds(5);
 
   for (unsigned i = 0; i < 256; i++) {
     DVLOG(2) << "---------------------------------------- " << i;
     RefPtr<ChannelEndpoint> ep0;
-    scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+    auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
     BootstrapChannelEndpointNoWait(0, std::move(ep0));
 
     RefPtr<ChannelEndpoint> ep1;
-    scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+    auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
     BootstrapChannelEndpointNoWait(1, std::move(ep1));
 
     if (i & 1u) {
       io_thread()->task_runner()->PostTask(FROM_HERE,
                                            base::Bind(&test::Sleep, delay));
     }
     if (i & 2u)
       test::Sleep(delay);
 
     mp0->Close(0);
@@ skipping 15 matching lines @@
 // passing that end back.
 // TODO(vtl): Also test passing a message pipe across two remote message pipes.
 TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) {
   static const char kHello[] = "hello";
   static const char kWorld[] = "world";
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   RefPtr<ChannelEndpoint> ep0;
-  scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
+  auto mp0 = MessagePipe::CreateLocalProxy(&ep0);
   RefPtr<ChannelEndpoint> ep1;
-  scoped_refptr<MessagePipe> mp1(MessagePipe::CreateProxyLocal(&ep1));
+  auto mp1 = MessagePipe::CreateProxyLocal(&ep1);
   BootstrapChannelEndpoints(std::move(ep0), std::move(ep1));
 
   // We'll try to pass this dispatcher.
   scoped_refptr<MessagePipeDispatcher> dispatcher =
       MessagePipeDispatcher::Create(
           MessagePipeDispatcher::kDefaultCreateOptions);
-  scoped_refptr<MessagePipe> local_mp(MessagePipe::CreateLocalLocal());
-  dispatcher->Init(local_mp, 0);
+  auto local_mp = MessagePipe::CreateLocalLocal();
+  dispatcher->Init(local_mp.Clone(), 0);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
   {
@@ skipping 170 matching lines @@
   mp0->Close(0);
   mp1->Close(1);
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
   // Note that |local_mp|'s port 0 belong to |dispatcher|, which was closed.
   local_mp->Close(1);
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo