Delete IPC::ChannelPosix, IPC::ChannelWin and IPC::AttachmentBroker.

ipc/ipc_perftest_support.cc

 // Copyright (c) 2012 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 "ipc/ipc_perftest_support.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 10 matching lines @@
 #include "base/test/test_io_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_descriptors.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/ipc_sender.h"
+#include "mojo/edk/test/scoped_ipc_support.h"
 
 namespace IPC {
 namespace test {
 
 // Avoid core 0 due to conflicts with Intel's Power Gadget.
 // Setting thread affinity will fail harmlessly on single/dual core machines.
 const int kSharedCore = 2;
 
 // This class simply collects stats about abstract "events" (each of which has a
 // start time and an end time).
@@ skipping 200 matching lines @@
   list.push_back(PingPongTestParams(12, 50000));
   list.push_back(PingPongTestParams(144, 50000));
   list.push_back(PingPongTestParams(1728, 50000));
   list.push_back(PingPongTestParams(20736, 12000));
   list.push_back(PingPongTestParams(248832, 1000));
   return list;
 }
 
 void IPCChannelPerfTestBase::RunTestChannelPingPong(
     const std::vector<PingPongTestParams>& params) {
-  Init("PerformanceClient");
+  auto message_loop = base::MakeUnique<base::MessageLoopForIO>();
+  mojo::edk::test::ScopedIPCSupport ipc_support(message_loop->task_runner());
+  InitWithCustomMessageLoop("MojoPerfTestClient", std::move(message_loop));
 
   // Set up IPC channel and start client.
   PerformanceChannelListener listener("Channel");
   CreateChannel(&listener);
   listener.Init(channel());
   ASSERT_TRUE(ConnectChannel());
-  ASSERT_TRUE(StartClient());
 
   LockThreadAffinity thread_locker(kSharedCore);
   for (size_t i = 0; i < params.size(); i++) {
     listener.SetTestParams(params[i].message_count(),
                            params[i].message_size());
 
     // This initial message will kick-start the ping-pong of messages.
     Message* message =
         new Message(0, 2, Message::PRIORITY_NORMAL);
     message->WriteInt64(base::TimeTicks::Now().ToInternalValue());
@@ skipping 12 matching lines @@
   message->WriteString("quit");
   sender()->Send(message);
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
 void IPCChannelPerfTestBase::RunTestChannelProxyPingPong(
     const std::vector<PingPongTestParams>& params) {
   io_thread_.reset(new base::TestIOThread(base::TestIOThread::kAutoStart));
-  InitWithCustomMessageLoop("PerformanceClient",
-                            base::MakeUnique<base::MessageLoop>());
+  {
+    auto message_loop = base::MakeUnique<base::MessageLoopForIO>();
+    mojo::edk::test::ScopedIPCSupport ipc_support(io_thread_->task_runner());
+    InitWithCustomMessageLoop("MojoPerfTestClient", std::move(message_loop));
 
-  // Set up IPC channel and start client.
-  PerformanceChannelListener listener("ChannelProxy");
-  CreateChannelProxy(&listener, io_thread_->task_runner());
-  listener.Init(channel_proxy());
-  ASSERT_TRUE(StartClient());
+    // Set up IPC channel and start client.
+    PerformanceChannelListener listener("ChannelProxy");
+    auto channel_proxy = IPC::ChannelProxy::Create(
+        TakeHandle().release(), IPC::Channel::MODE_SERVER, &listener,
+        io_thread_->task_runner());
+    listener.Init(channel_proxy.get());
 
-  LockThreadAffinity thread_locker(kSharedCore);
-  for (size_t i = 0; i < params.size(); i++) {
-    listener.SetTestParams(params[i].message_count(),
-                           params[i].message_size());
+    LockThreadAffinity thread_locker(kSharedCore);
+    for (size_t i = 0; i < params.size(); i++) {
+      listener.SetTestParams(params[i].message_count(),
+                             params[i].message_size());
 
-    // This initial message will kick-start the ping-pong of messages.
-    Message* message =
-        new Message(0, 2, Message::PRIORITY_NORMAL);
+      // This initial message will kick-start the ping-pong of messages.
+      Message* message = new Message(0, 2, Message::PRIORITY_NORMAL);
+      message->WriteInt64(base::TimeTicks::Now().ToInternalValue());
+      message->WriteInt(-1);
+      message->WriteString("hello");
+      channel_proxy->Send(message);
+
+      // Run message loop.
+      base::RunLoop().Run();
+    }
+
+    // Send quit message.
+    Message* message = new Message(0, 2, Message::PRIORITY_NORMAL);
     message->WriteInt64(base::TimeTicks::Now().ToInternalValue());
     message->WriteInt(-1);
-    message->WriteString("hello");
-    sender()->Send(message);
+    message->WriteString("quit");
+    channel_proxy->Send(message);
 
-    // Run message loop.
-    base::RunLoop().Run();
+    EXPECT_TRUE(WaitForClientShutdown());
+    channel_proxy.reset();
   }
 
-  // Send quit message.
-  Message* message = new Message(0, 2, Message::PRIORITY_NORMAL);
-  message->WriteInt64(base::TimeTicks::Now().ToInternalValue());
-  message->WriteInt(-1);
-  message->WriteString("quit");
-  sender()->Send(message);
-
-  EXPECT_TRUE(WaitForClientShutdown());
-  DestroyChannelProxy();
-
   io_thread_.reset();
 }
 
 
 PingPongTestClient::PingPongTestClient()
     : listener_(new ChannelReflectorListener()) {
 }
 
 PingPongTestClient::~PingPongTestClient() {
 }
 
-std::unique_ptr<Channel> PingPongTestClient::CreateChannel(Listener* listener) {
-  return Channel::CreateClient(
-      IPCTestBase::GetChannelName("PerformanceClient"), listener,
-      base::ThreadTaskRunnerHandle::Get());
-}
-
 int PingPongTestClient::RunMain() {
   LockThreadAffinity thread_locker(kSharedCore);
   std::unique_ptr<Channel> channel = CreateChannel(listener_.get());
   listener_->Init(channel.get());
   CHECK(channel->Connect());
 
   base::RunLoop().Run();
   return 0;
 }
 
@@ skipping 28 matching lines @@
   auto set_result = SetThreadAffinityMask(GetCurrentThread(), old_affinity_);
   DCHECK_NE(0u, set_result);
 #elif defined(OS_LINUX)
   auto set_result = sched_setaffinity(0, sizeof(old_cpuset_), &old_cpuset_);
   DCHECK_EQ(0, set_result);
 #endif
 }
 
 }  // namespace test
 }  // namespace IPC