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

mojo/edk/system/message_pipe_dispatcher_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.
 
 // NOTE(vtl): Some of these tests are inherently flaky (e.g., if run on a
 // heavily-loaded system). Sorry. |test::EpsilonDeadline()| may be increased to
 // increase tolerance and reduce observed flakiness (though doing so reduces the
 // meaningfulness of the test).
 
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 
 #include <string.h>
 
 #include <limits>
+#include <utility>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "mojo/edk/system/message_pipe.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/system/waiter.h"
 #include "mojo/edk/system/waiter_test_utils.h"
 #include "mojo/edk/test/simple_test_thread.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 13 matching lines @@
   uint32_t buffer_size;
 
   // Run this test both with |d0| as port 0, |d1| as port 1 and vice versa.
   for (unsigned i = 0; i < 2; i++) {
     scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     EXPECT_EQ(Dispatcher::Type::MESSAGE_PIPE, d0->GetType());
     scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     {
-      scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
-      d0->Init(mp, i);      // 0, 1.
-      d1->Init(mp, i ^ 1);  // 1, 0.
+      auto mp = MessagePipe::CreateLocalLocal();
+      d0->Init(mp.Clone(), i);         // 0, 1.
+      d1->Init(std::move(mp), i ^ 1);  // 1, 0.
     }
     Waiter w;
     uint32_t context = 0;
     HandleSignalsState hss;
 
     // Try adding a writable waiter when already writable.
     w.Init();
     hss = HandleSignalsState();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
               d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
@@ skipping 88 matching lines @@
 }
 
 TEST(MessagePipeDispatcherTest, InvalidParams) {
   char buffer[1];
 
   scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   {
-    scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
-    d0->Init(mp, 0);
-    d1->Init(mp, 1);
+    auto mp = MessagePipe::CreateLocalLocal();
+    d0->Init(mp.Clone(), 0);
+    d1->Init(std::move(mp), 1);
   }
 
   // |WriteMessage|:
   // Huge buffer size.
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             d0->WriteMessage(UserPointer<const void>(buffer),
                              std::numeric_limits<uint32_t>::max(), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
   EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
 }
 
 // These test invalid arguments that should cause death if we're being paranoid
 // about checking arguments (which we would want to do if, e.g., we were in a
 // true "kernel" situation, but we might not want to do otherwise for
 // performance reasons). Probably blatant errors like passing in null pointers
 // (for required pointer arguments) will still cause death, but perhaps not
 // predictably.
 TEST(MessagePipeDispatcherTest, InvalidParamsDeath) {
   const char kMemoryCheckFailedRegex[] = "Check failed";
 
   scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   {
-    scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
-    d0->Init(mp, 0);
-    d1->Init(mp, 1);
+    auto mp = MessagePipe::CreateLocalLocal();
+    d0->Init(mp.Clone(), 0);
+    d1->Init(std::move(mp), 1);
   }
 
   // |WriteMessage|:
   // Null buffer with nonzero buffer size.
   EXPECT_DEATH_IF_SUPPORTED(d0->WriteMessage(NullUserPointer(), 1, nullptr,
                                              MOJO_WRITE_MESSAGE_FLAG_NONE),
                             kMemoryCheckFailedRegex);
 
   // |ReadMessage|:
   // Null buffer with nonzero buffer size.
@@ skipping 17 matching lines @@
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Run this test both with |d0| as port 0, |d1| as port 1 and vice versa.
   for (unsigned i = 0; i < 2; i++) {
     scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     {
-      scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
-      d0->Init(mp, i);      // 0, 1.
-      d1->Init(mp, i ^ 1);  // 1, 0.
+      auto mp = MessagePipe::CreateLocalLocal();
+      d0->Init(mp.Clone(), i);         // 0, 1.
+      d1->Init(std::move(mp), i ^ 1);  // 1, 0.
     }
     Waiter w;
     HandleSignalsState hss;
 
     // Write (twice) to |d1|.
     buffer[0] = 123456789;
     EXPECT_EQ(MOJO_RESULT_OK,
               d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
                                nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
     buffer[0] = 234567890;
@@ skipping 107 matching lines @@
   uint32_t context;
   HandleSignalsState hss;
 
   // Run this test both with |d0| as port 0, |d1| as port 1 and vice versa.
   for (unsigned i = 0; i < 2; i++) {
     scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     {
-      scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
-      d0->Init(mp, i);      // 0, 1.
-      d1->Init(mp, i ^ 1);  // 1, 0.
+      auto mp = MessagePipe::CreateLocalLocal();
+      d0->Init(mp.Clone(), i);         // 0, 1.
+      d1->Init(std::move(mp), i ^ 1);  // 1, 0.
     }
 
     // Wait for readable on |d1|, which will become readable after some time.
     {
       test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
                                 MOJO_DEADLINE_INDEFINITE, 1, &did_wait, &result,
                                 &context, &hss);
       stopwatch.Start();
       thread.Start();
       test::Sleep(2 * test::EpsilonDeadline());
@@ skipping 60 matching lines @@
 
     EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
   }
 
   for (unsigned i = 0; i < 2; i++) {
     scoped_refptr<MessagePipeDispatcher> d0 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     scoped_refptr<MessagePipeDispatcher> d1 = MessagePipeDispatcher::Create(
         MessagePipeDispatcher::kDefaultCreateOptions);
     {
-      scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
-      d0->Init(mp, i);      // 0, 1.
-      d1->Init(mp, i ^ 1);  // 1, 0.
+      auto mp = MessagePipe::CreateLocalLocal();
+      d0->Init(mp.Clone(), i);         // 0, 1.
+      d1->Init(std::move(mp), i ^ 1);  // 1, 0.
     }
 
     // Wait for readable on |d1| and close |d1| after some time, which should
     // cancel that wait.
     {
       test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
                                 MOJO_DEADLINE_INDEFINITE, 4, &did_wait, &result,
                                 &context, &hss);
       stopwatch.Start();
       thread.Start();
@@ skipping 155 matching lines @@
 
 TEST(MessagePipeDispatcherTest, Stress) {
   static const size_t kNumWriters = 30;
   static const size_t kNumReaders = kNumWriters;
 
   scoped_refptr<MessagePipeDispatcher> d_write = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   scoped_refptr<MessagePipeDispatcher> d_read = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   {
-    scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
-    d_write->Init(mp, 0);
-    d_read->Init(mp, 1);
+    auto mp = MessagePipe::CreateLocalLocal();
+    d_write->Init(mp.Clone(), 0);
+    d_read->Init(std::move(mp), 1);
   }
 
   size_t messages_written[kNumWriters];
   size_t bytes_written[kNumWriters];
   size_t messages_read[kNumReaders];
   size_t bytes_read[kNumReaders];
   {
     // Make writers.
     ScopedVector<WriterThread> writers;
     for (size_t i = 0; i < kNumWriters; i++) {
@@ skipping 39 matching lines @@
   EXPECT_EQ(total_messages_written, total_messages_read);
   EXPECT_EQ(total_bytes_written, total_bytes_read);
 
   EXPECT_EQ(MOJO_RESULT_OK, d_write->Close());
   EXPECT_EQ(MOJO_RESULT_OK, d_read->Close());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo