Refactor (many) IPC tests, notably most of the multiprocess tests.

ipc/ipc_perftests.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 "build/build_config.h"
 
-#if defined(OS_WIN)
-#include <windows.h>
-#elif defined(OS_POSIX)
-#include <sys/types.h>
-#include <unistd.h>
-#endif
-
 #include <algorithm>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/perftimer.h"
 #include "base/pickle.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "ipc/ipc_descriptors.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message_utils.h"
-#include "ipc/ipc_multiprocess_test.h"
 #include "ipc/ipc_sender.h"
 #include "ipc/ipc_test_base.h"
 
 namespace {
 
 // This test times the roundtrip IPC message cycle.
 //
 // TODO(brettw): Make this test run by default.
 
 class IPCChannelPerfTest : public IPCTestBase {
@@ skipping 96 matching lines @@
     msg->WriteString(payload);
     channel_->Send(msg);
     return true;
   }
 
  private:
   IPC::Channel* channel_;
   EventTimeTracker latency_tracker_;
 };
 
-class ChannelPerfListener : public IPC::Listener {
+class PerformanceChannelListener : public IPC::Listener {
  public:
-  ChannelPerfListener()
+  PerformanceChannelListener()
       : channel_(NULL),
         msg_count_(0),
         msg_size_(0),
         count_down_(0),
         latency_tracker_("Server messages") {
     VLOG(1) << "Server listener up";
   }
 
-  ~ChannelPerfListener() {
+  ~PerformanceChannelListener() {
     VLOG(1) << "Server listener down";
   }
 
   void Init(IPC::Channel* channel) {
     DCHECK(!channel_);
     channel_ = channel;
   }
 
   // Call this before running the message loop.
   void SetTestParams(int msg_count, size_t msg_size) {
@@ skipping 54 matching lines @@
   int msg_count_;
   size_t msg_size_;
 
   int count_down_;
   std::string payload_;
   EventTimeTracker latency_tracker_;
   scoped_ptr<PerfTimeLogger> perf_logger_;
 };
 
 TEST_F(IPCChannelPerfTest, Performance) {
-  // Setup IPC channel.
-  ChannelPerfListener perf_listener;
-  IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_SERVER,
-                    &perf_listener);
-  perf_listener.Init(&chan);
-  ASSERT_TRUE(chan.Connect());
+  Init("PerformanceClient");
 
-  base::ProcessHandle process_handle = SpawnChild(TEST_REFLECTOR, &chan);
-  ASSERT_TRUE(process_handle);
+  // Set up IPC channel and start client.
+  PerformanceChannelListener listener;
+  CreateChannel(&listener);
+  listener.Init(channel());
+  ASSERT_TRUE(ConnectChannel());
+  ASSERT_TRUE(StartClient());
 
   const size_t kMsgSizeBase = 12;
   const int kMsgSizeMaxExp = 5;
   int msg_count = 100000;
   size_t msg_size = kMsgSizeBase;
   for (int i = 1; i <= kMsgSizeMaxExp; i++) {
-    perf_listener.SetTestParams(msg_count, msg_size);
+    listener.SetTestParams(msg_count, msg_size);
 
     // This initial message will kick-start the ping-pong of messages.
     IPC::Message* message =
         new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
     message->WriteInt64(base::TimeTicks::Now().ToInternalValue());
     message->WriteInt(-1);
     message->WriteString("hello");
-    chan.Send(message);
+    sender()->Send(message);
 
     // Run message loop.
     MessageLoop::current()->Run();
 
     msg_size *= kMsgSizeBase;
   }
 
   // Send quit message.
   IPC::Message* message = new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
   message->WriteInt64(base::TimeTicks::Now().ToInternalValue());
   message->WriteInt(-1);
   message->WriteString("quit");
-  chan.Send(message);
+  sender()->Send(message);
 
-  // Clean up child process.
-  EXPECT_TRUE(base::WaitForSingleProcess(process_handle,
-                                         base::TimeDelta::FromSeconds(5)));
-  base::CloseProcessHandle(process_handle);
+  EXPECT_TRUE(WaitForClientShutdown());
+  DestroyChannel();
 }
 
 // This message loop bounces all messages back to the sender.
-MULTIPROCESS_IPC_TEST_MAIN(RunReflector) {
+MULTIPROCESS_IPC_TEST_CLIENT_MAIN(PerformanceClient) {
   MessageLoopForIO main_message_loop;
-  ChannelReflectorListener channel_reflector_listener;
-  IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_CLIENT,
-                    &channel_reflector_listener);
-  channel_reflector_listener.Init(&chan);
-  CHECK(chan.Connect());
+  ChannelReflectorListener listener;
+  IPC::Channel channel(IPCTestBase::GetChannelName("PerformanceClient"),
+                       IPC::Channel::MODE_CLIENT,
+                       &listener);
+  listener.Init(&channel);
+  CHECK(channel.Connect());
 
   MessageLoop::current()->Run();
   return 0;
 }
 
 }  // namespace