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

mojo/edk/system/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 "mojo/edk/system/message_pipe.h"
 
-#include "base/memory/ref_counted.h"
 #include "mojo/edk/system/waiter.h"
 #include "mojo/edk/system/waiter_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
 const MojoHandleSignals kAllSignals = MOJO_HANDLE_SIGNAL_READABLE |
                                       MOJO_HANDLE_SIGNAL_WRITABLE |
                                       MOJO_HANDLE_SIGNAL_PEER_CLOSED;
 
 // Tests:
 //  - only default flags
 //  - reading messages from a port
 //    - when there are no/one/two messages available for that port
 //    - with buffer size 0 (and null buffer) -- should get size
 //    - with too-small buffer -- should get size
 //    - also verify that buffers aren't modified when/where they shouldn't be
 //  - writing messages to a port
 //    - in the obvious scenarios (as above)
 //    - to a port that's been closed
 //  - writing a message to a port, closing the other (would be the source) port,
 //    and reading it
 TEST(MessagePipeTest, Basic) {
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
+  auto mp = MessagePipe::CreateLocalLocal();
 
   int32_t buffer[2];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Nothing to read yet on port 0.
   buffer[0] = 123;
   buffer[1] = 456;
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
@@ skipping 141 matching lines @@
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             mp->ReadMessage(1, UserPointer<void>(buffer),
                             MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
 
   mp->Close(1);
 }
 
 TEST(MessagePipeTest, CloseWithQueuedIncomingMessages) {
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
+  auto mp = MessagePipe::CreateLocalLocal();
 
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Write some messages from port 1 (to port 0).
   for (int32_t i = 0; i < 5; i++) {
     buffer[0] = i;
     EXPECT_EQ(MOJO_RESULT_OK,
               mp->WriteMessage(1, UserPointer<const void>(buffer), kBufferSize,
                                nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   }
 
   // Port 0 shouldn't be empty.
   buffer_size = 0;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             mp->ReadMessage(0, NullUserPointer(), MakeUserPointer(&buffer_size),
                             0, nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kBufferSize, buffer_size);
 
   // Close port 0 first, which should have outstanding (incoming) messages.
   mp->Close(0);
   mp->Close(1);
 }
 
 TEST(MessagePipeTest, DiscardMode) {
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
+  auto mp = MessagePipe::CreateLocalLocal();
 
   int32_t buffer[2];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Write from port 1 (to port 0).
   buffer[0] = 789012345;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             mp->WriteMessage(1, UserPointer<const void>(buffer),
@@ skipping 83 matching lines @@
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             mp->ReadMessage(0, UserPointer<void>(buffer),
                             MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   mp->Close(0);
   mp->Close(1);
 }
 
 TEST(MessagePipeTest, BasicWaiting) {
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
+  auto mp = MessagePipe::CreateLocalLocal();
   Waiter waiter;
   HandleSignalsState hss;
 
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Always writable (until the other port is closed).
   waiter.Init();
   hss = HandleSignalsState();
@@ skipping 121 matching lines @@
 
 TEST(MessagePipeTest, ThreadedWaiting) {
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
 
   MojoResult result;
   uint32_t context;
 
   // Write to wake up waiter waiting for read.
   {
-    scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
+    auto mp = MessagePipe::CreateLocalLocal();
     test::SimpleWaiterThread thread(&result, &context);
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
               mp->AddAwakable(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
                               1, nullptr));
     thread.Start();
 
     buffer[0] = 123456789;
     // Write from port 0 (to port 1), which should wake up the waiter.
     EXPECT_EQ(MOJO_RESULT_OK,
               mp->WriteMessage(0, UserPointer<const void>(buffer), kBufferSize,
                                nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     HandleSignalsState hss;
     mp->RemoveAwakable(1, thread.waiter(), &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
               hss.satisfied_signals);
     EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
     mp->Close(0);
     mp->Close(1);
   }  // Joins |thread|.
   // The waiter should have woken up successfully.
   EXPECT_EQ(MOJO_RESULT_OK, result);
   EXPECT_EQ(1u, context);
 
   // Close to cancel waiter.
   {
-    scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
+    auto mp = MessagePipe::CreateLocalLocal();
     test::SimpleWaiterThread thread(&result, &context);
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
               mp->AddAwakable(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
                               2, nullptr));
     thread.Start();
 
     // Close port 1 first -- this should result in the waiter being cancelled.
     mp->CancelAllAwakables(1);
     mp->Close(1);
 
     // Port 1 is closed, so |Dispatcher::RemoveAwakable()| wouldn't call into
     // the |MessagePipe| to remove any waiter.
 
     mp->Close(0);
   }  // Joins |thread|.
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
   EXPECT_EQ(2u, context);
 
   // Close to cancel waiter using peer closed signal.
   {
-    scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
+    auto mp = MessagePipe::CreateLocalLocal();
     test::SimpleWaiterThread thread(&result, &context);
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
               mp->AddAwakable(1, thread.waiter(),
                               MOJO_HANDLE_SIGNAL_PEER_CLOSED, 3, nullptr));
     thread.Start();
 
     // Close port 1 first -- this should result in the waiter being cancelled.
     mp->CancelAllAwakables(1);
     mp->Close(1);
 
     // Port 1 is closed, so |Dispatcher::RemoveAwakable()| wouldn't call into
     // the |MessagePipe| to remove any waiter.
 
     mp->Close(0);
   }  // Joins |thread|.
   EXPECT_EQ(MOJO_RESULT_CANCELLED, result);
   EXPECT_EQ(3u, context);
 
   // Close to make waiter un-wake-up-able.
   {
-    scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
+    auto mp = MessagePipe::CreateLocalLocal();
     test::SimpleWaiterThread thread(&result, &context);
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
               mp->AddAwakable(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE,
                               4, nullptr));
     thread.Start();
 
     // Close port 0 first -- this should wake the waiter up, since port 1 will
     // never be readable.
     mp->CancelAllAwakables(0);
     mp->Close(0);
 
     HandleSignalsState hss;
     mp->RemoveAwakable(1, thread.waiter(), &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 
     mp->CancelAllAwakables(1);
     mp->Close(1);
   }  // Joins |thread|.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
   EXPECT_EQ(4u, context);
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo