Make ipc_tests file structure a little saner and add an ipc_perftests target.

This means that the (one, semi-manual) IPC perf test that we have will build
without manual hackery (and do so separately from the ipc_tests target).


Review URL: https://chromiumcodereview.appspot.com/11819041

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@176341 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 414 insertions, 313 deletions

diff --git a/build/android/gtest_filter/ipc_tests_disabled b/build/android/gtest_filter/ipc_tests_disabled
index e6d5f2d..fcd5e73 100644
--- a/build/android/gtest_filter/ipc_tests_disabled
+++ b/build/android/gtest_filter/ipc_tests_disabled
@@ -8,7 +8,7 @@ IPCChannelPosixTest.MultiConnection
 IPCFuzzingTest.SanityTest
 IPCFuzzingTest.MsgBadPayloadArgs
 IPCFuzzingTest.MsgBadPayloadShort
-IPCChannelTest.DescriptorTest
+IPCSendFdsTest.DescriptorTest
 IPCChannelTest.ChannelTest
 IPCChannelTest.ChannelProxyTest
 IPCChannelTest.SendMessageInChannelConnected
diff --git a/ipc/ipc.gyp b/ipc/ipc.gyp
index 678d166..c56f68a 100644
--- a/ipc/ipc.gyp
+++ b/ipc/ipc.gyp
@@ -37,6 +37,7 @@
         'test_support_ipc',
         '../base/base.gyp:base',
         '../base/base.gyp:base_i18n',
+        '../base/base.gyp:run_all_unittests',
         '../base/base.gyp:test_support_base',
         '../testing/gtest.gyp:gtest',
       ],
@@ -46,6 +47,7 @@
       'sources': [
         'file_descriptor_set_posix_unittest.cc',
         'ipc_channel_posix_unittest.cc',
+        'ipc_channel_unittest.cc',
         'ipc_fuzzing_tests.cc',
         'ipc_message_unittest.cc',
         'ipc_message_utils_unittest.cc',
@@ -53,8 +55,8 @@
         'ipc_sync_channel_unittest.cc',
         'ipc_sync_message_unittest.cc',
         'ipc_sync_message_unittest.h',
-        'ipc_tests.cc',
-        'ipc_tests.h',
+        'ipc_test_base.cc',
+        'ipc_test_base.h',
         'sync_socket_unittest.cc',
       ],
       'conditions': [
@@ -80,6 +82,49 @@
       ],
     },
     {
+      'target_name': 'ipc_perftests',
+      'type': '<(gtest_target_type)',
+      # TODO(viettrungluu): Figure out which dependencies are really needed.
+      'dependencies': [
+        'ipc',
+        'test_support_ipc',
+        '../base/base.gyp:base',
+        '../base/base.gyp:base_i18n',
+        '../base/base.gyp:test_support_base',
+        '../base/base.gyp:test_support_perf',
+        '../testing/gtest.gyp:gtest',
+      ],
+      'include_dirs': [
+        '..'
+      ],
+      'sources': [
+        'ipc_perftests.cc',
+        'ipc_test_base.cc',
+        'ipc_test_base.h',
+      ],
+      'conditions': [
+        ['toolkit_uses_gtk == 1', {
+          'dependencies': [
+            '../build/linux/system.gyp:gtk',
+          ],
+        }],
+        ['OS == "android" and gtest_target_type == "shared_library"', {
+          'dependencies': [
+            '../testing/android/native_test.gyp:native_test_native_code',
+          ],
+        }],
+        ['os_posix == 1 and OS != "mac" and OS != "android"', {
+          'conditions': [
+            ['linux_use_tcmalloc==1', {
+              'dependencies': [
+                '../base/allocator/allocator.gyp:allocator',
+              ],
+            }],
+          ],
+        }]
+      ],
+    },
+    {
       'target_name': 'test_support_ipc',
       'type': 'static_library',
       'dependencies': [
diff --git a/ipc/ipc_tests.cc b/ipc/ipc_channel_unittest.cc
index 81d6716..6b63ae0 100644
--- a/ipc/ipc_tests.cc
+++ b/ipc/ipc_channel_unittest.cc
@@ -15,8 +15,6 @@
 #include <string>
 #include <utility>
 
-#include "ipc/ipc_tests.h"
-
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/debug/debug_on_start_win.h"
@@ -33,106 +31,14 @@
 #include "ipc/ipc_multiprocess_test.h"
 #include "ipc/ipc_sender.h"
 #include "ipc/ipc_switches.h"
+#include "ipc/ipc_test_base.h"
 #include "testing/multiprocess_func_list.h"
 
-// Define to enable IPC performance testing instead of the regular unit tests
-// #define PERFORMANCE_TEST
-
-const char kTestClientChannel[] = "T1";
-const char kReflectorChannel[] = "T2";
-const char kFuzzerChannel[] = "F3";
-const char kSyncSocketChannel[] = "S4";
-
 const size_t kLongMessageStringNumBytes = 50000;
 
-void IPCChannelTest::SetUp() {
-  MultiProcessTest::SetUp();
-
-  // Construct a fresh IO Message loop for the duration of each test.
-  message_loop_ = new MessageLoopForIO();
-}
-
-void IPCChannelTest::TearDown() {
-  delete message_loop_;
-  message_loop_ = NULL;
-
-  MultiProcessTest::TearDown();
-}
-
-#if defined(OS_WIN)
-base::ProcessHandle IPCChannelTest::SpawnChild(ChildType child_type,
-                                               IPC::Channel *channel) {
-  // kDebugChildren support.
-  bool debug_on_start =
-      CommandLine::ForCurrentProcess()->HasSwitch(switches::kDebugChildren);
-
-  switch (child_type) {
-  case TEST_CLIENT:
-    return MultiProcessTest::SpawnChild("RunTestClient", debug_on_start);
-  case TEST_REFLECTOR:
-    return MultiProcessTest::SpawnChild("RunReflector", debug_on_start);
-  case FUZZER_SERVER:
-    return MultiProcessTest::SpawnChild("RunFuzzServer", debug_on_start);
-  case SYNC_SOCKET_SERVER:
-    return MultiProcessTest::SpawnChild("RunSyncSocketServer", debug_on_start);
-  default:
-    return NULL;
-  }
-}
-#elif defined(OS_POSIX)
-base::ProcessHandle IPCChannelTest::SpawnChild(ChildType child_type,
-                                               IPC::Channel *channel) {
-  // kDebugChildren support.
-  bool debug_on_start =
-      CommandLine::ForCurrentProcess()->HasSwitch(switches::kDebugChildren);
-
-  base::FileHandleMappingVector fds_to_map;
-  const int ipcfd = channel->GetClientFileDescriptor();
-  if (ipcfd > -1) {
-    fds_to_map.push_back(std::pair<int, int>(ipcfd, kPrimaryIPCChannel + 3));
-  }
-
-  base::ProcessHandle ret = base::kNullProcessHandle;
-  switch (child_type) {
-  case TEST_CLIENT:
-    ret = MultiProcessTest::SpawnChild("RunTestClient",
-                                       fds_to_map,
-                                       debug_on_start);
-    break;
-  case TEST_DESCRIPTOR_CLIENT:
-    ret = MultiProcessTest::SpawnChild("RunTestDescriptorClient",
-                                       fds_to_map,
-                                       debug_on_start);
-    break;
-  case TEST_DESCRIPTOR_CLIENT_SANDBOXED:
-    ret = MultiProcessTest::SpawnChild("RunTestDescriptorClientSandboxed",
-                                       fds_to_map,
-                                       debug_on_start);
-    break;
-  case TEST_REFLECTOR:
-    ret = MultiProcessTest::SpawnChild("RunReflector",
-                                       fds_to_map,
-                                       debug_on_start);
-    break;
-  case FUZZER_SERVER:
-    ret = MultiProcessTest::SpawnChild("RunFuzzServer",
-                                       fds_to_map,
-                                       debug_on_start);
-    break;
-  case SYNC_SOCKET_SERVER:
-    ret = MultiProcessTest::SpawnChild("RunSyncSocketServer",
-                                       fds_to_map,
-                                       debug_on_start);
-    break;
-  default:
-    return base::kNullProcessHandle;
-    break;
-  }
-  return ret;
-}
-#endif  // defined(OS_POSIX)
+class IPCChannelTest : public IPCTestBase {
+};
 
-#ifndef PERFORMANCE_TEST
 TEST_F(IPCChannelTest, BasicMessageTest) {
   int v1 = 10;
   std::string v2("foobar");
@@ -428,188 +334,3 @@ MULTIPROCESS_IPC_TEST_MAIN(RunTestClient) {
   MessageLoop::current()->Run();
   return 0;
 }
-
-#endif  // !PERFORMANCE_TEST
-
-#ifdef PERFORMANCE_TEST
-
-//-----------------------------------------------------------------------------
-// Manually performance test
-//
-//    This test times the roundtrip IPC message cycle. It is enabled with a
-//    special preprocessor define to enable it instead of the standard IPC
-//    unit tests. This works around some funny termination conditions in the
-//    regular unit tests.
-//
-//    This test is not automated. To test, you will want to vary the message
-//    count and message size in TEST to get the numbers you want.
-//
-//    FIXME(brettw): Automate this test and have it run by default.
-
-// This channel listener just replies to all messages with the exact same
-// message. It assumes each message has one string parameter. When the string
-// "quit" is sent, it will exit.
-class ChannelReflectorListener : public IPC::Listener {
- public:
-  explicit ChannelReflectorListener(IPC::Channel *channel) :
-    channel_(channel),
-    count_messages_(0) {
-    std::cout << "Reflector up" << std::endl;
-  }
-
-  ~ChannelReflectorListener() {
-    std::cout << "Client Messages: " << count_messages_ << std::endl;
-    std::cout << "Client Latency: " << latency_messages_.InMilliseconds()
-              << std::endl;
-  }
-
-  virtual bool OnMessageReceived(const IPC::Message& message) {
-    count_messages_++;
-    PickleIterator iter(message);
-    int64 time_internal;
-    EXPECT_TRUE(iter.ReadInt64(&time_internal));
-    int msgid;
-    EXPECT_TRUE(iter.ReadInt(&msgid));
-    std::string payload;
-    EXPECT_TRUE(iter.ReadString(&payload));
-    // TODO(vtl): Should we use |HighResNow()| instead of |Now()|?
-    latency_messages_ += base::TimeTicks::Now() -
-                         base::TimeTicks::FromInternalValue(time_internal);
-
-    // cout << "reflector msg received: " << msgid << endl;
-    if (payload == "quit")
-      MessageLoop::current()->Quit();
-
-    IPC::Message* msg = new IPC::Message(0,
-                                         2,
-                                         IPC::Message::PRIORITY_NORMAL);
-    msg->WriteInt64(base::TimeTicks::Now().ToInternalValue());
-    msg->WriteInt(msgid);
-    msg->WriteString(payload);
-    channel_->Send(msg);
-    return true;
-  }
-
- private:
-  IPC::Channel *channel_;
-  int count_messages_;
-  base::TimeDelta latency_messages_;
-};
-
-class ChannelPerfListener : public IPC::Listener {
- public:
-  ChannelPerfListener(IPC::Channel* channel, int msg_count, int msg_size) :
-       count_down_(msg_count),
-       channel_(channel),
-       count_messages_(0) {
-    payload_.resize(msg_size);
-    for (int i = 0; i < static_cast<int>(payload_.size()); i++)
-      payload_[i] = 'a';
-    std::cout << "perflistener up" << std::endl;
-  }
-
-  ~ChannelPerfListener() {
-    std::cout << "Server Messages: " << count_messages_ << std::endl;
-    std::cout << "Server Latency: " << latency_messages_.InMilliseconds()
-              << std::endl;
-  }
-
-  virtual bool OnMessageReceived(const IPC::Message& message) {
-    count_messages_++;
-    // Decode the string so this gets counted in the total time.
-    PickleIterator iter(message);
-    int64 time_internal;
-    EXPECT_TRUE(iter.ReadInt64(&time_internal));
-    int msgid;
-    EXPECT_TRUE(iter.ReadInt(&msgid));
-    std::string cur;
-    EXPECT_TRUE(iter.ReadString(&cur));
-    latency_messages_ += base::TimeTicks::Now() -
-                         base::TimeTicks::FromInternalValue(time_internal);
-
-    count_down_--;
-    if (count_down_ == 0) {
-      IPC::Message* msg = new IPC::Message(0,
-                                           2,
-                                           IPC::Message::PRIORITY_NORMAL);
-      msg->WriteInt64(base::TimeTicks::Now().ToInternalValue());
-      msg->WriteInt(count_down_);
-      msg->WriteString("quit");
-      channel_->Send(msg);
-
-      MessageLoop::current()->QuitWhenIdle();
-      return true;
-    }
-
-    IPC::Message* msg = new IPC::Message(0,
-                                         2,
-                                         IPC::Message::PRIORITY_NORMAL);
-    msg->WriteInt64(base::TimeTicks::Now().ToInternalValue());
-    msg->WriteInt(count_down_);
-    msg->WriteString(payload_);
-    channel_->Send(msg);
-    return true;
-  }
-
- private:
-  int count_down_;
-  std::string payload_;
-  IPC::Channel *channel_;
-  int count_messages_;
-  base::TimeDelta latency_messages_;
-};
-
-TEST_F(IPCChannelTest, Performance) {
-  // setup IPC channel
-  IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_SERVER, NULL);
-  ChannelPerfListener perf_listener(&chan, 10000, 100000);
-  chan.set_listener(&perf_listener);
-  ASSERT_TRUE(chan.Connect());
-
-  base::ProcessHandle process_handle = SpawnChild(TEST_REFLECTOR, &chan);
-  ASSERT_TRUE(process_handle);
-
-  base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
-
-  PerfTimeLogger logger("IPC_Perf");
-
-  // 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);
-
-  // run message loop
-  MessageLoop::current()->Run();
-
-  // Clean up child process.
-  EXPECT_TRUE(base::WaitForSingleProcess(
-      process_handle, base::TimeDelta::FromSeconds(5)));
-  base::CloseProcessHandle(process_handle);
-}
-
-// This message loop bounces all messages back to the sender
-MULTIPROCESS_IPC_TEST_MAIN(RunReflector) {
-  MessageLoopForIO main_message_loop;
-  IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_CLIENT, NULL);
-  ChannelReflectorListener channel_reflector_listener(&chan);
-  chan.set_listener(&channel_reflector_listener);
-  CHECK(chan.Connect());
-
-  MessageLoop::current()->Run();
-  return 0;
-}
-
-#endif  // PERFORMANCE_TEST
-
-int main(int argc, char** argv) {
-#ifdef PERFORMANCE_TEST
-  int retval = base::PerfTestSuite(argc, argv).Run();
-#else
-  int retval = base::TestSuite(argc, argv).Run();
-#endif
-  return retval;
-}
diff --git a/ipc/ipc_fuzzing_tests.cc b/ipc/ipc_fuzzing_tests.cc
index 4c3e9c9..82ac37f 100644
--- a/ipc/ipc_fuzzing_tests.cc
+++ b/ipc/ipc_fuzzing_tests.cc
@@ -12,7 +12,7 @@
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_multiprocess_test.h"
-#include "ipc/ipc_tests.h"
+#include "ipc/ipc_test_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
@@ -257,7 +257,7 @@ MULTIPROCESS_IPC_TEST_MAIN(RunFuzzServer) {
   return 0;
 }
 
-class IPCFuzzingTest : public IPCChannelTest {
+class IPCFuzzingTest : public IPCTestBase {
 };
 
 // This test makes sure that the FuzzerClientListener and FuzzerServerListener
diff --git a/ipc/ipc_perftests.cc b/ipc/ipc_perftests.cc
new file mode 100644
index 0000000..b290c16
--- /dev/null
+++ b/ipc/ipc_perftests.cc
@@ -0,0 +1,205 @@
+// 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 <stdio.h>
+#include <string>
+#include <utility>
+
+#include "ipc/ipc_test_base.h"
+
+#include "base/base_switches.h"
+#include "base/command_line.h"
+#include "base/debug/debug_on_start_win.h"
+#include "base/perftimer.h"
+#include "base/pickle.h"
+#include "base/test/perf_test_suite.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_switches.h"
+#include "testing/multiprocess_func_list.h"
+
+// This test times the roundtrip IPC message cycle. It is enabled with a
+// special preprocessor define to enable it instead of the standard IPC
+// unit tests. This works around some funny termination conditions in the
+// regular unit tests.
+//
+// This test is not automated. To test, you will want to vary the message
+// count and message size in TEST to get the numbers you want.
+//
+// FIXME(brettw): Automate this test and have it run by default.
+
+class IPCChannelPerfTest : public IPCTestBase {
+};
+
+// This channel listener just replies to all messages with the exact same
+// message. It assumes each message has one string parameter. When the string
+// "quit" is sent, it will exit.
+class ChannelReflectorListener : public IPC::Listener {
+ public:
+  explicit ChannelReflectorListener(IPC::Channel *channel) :
+    channel_(channel),
+    count_messages_(0) {
+    std::cout << "Reflector up" << std::endl;
+  }
+
+  ~ChannelReflectorListener() {
+    std::cout << "Client Messages: " << count_messages_ << std::endl;
+    std::cout << "Client Latency: " << latency_messages_.InMilliseconds()
+              << std::endl;
+  }
+
+  virtual bool OnMessageReceived(const IPC::Message& message) {
+    count_messages_++;
+    PickleIterator iter(message);
+    int64 time_internal;
+    EXPECT_TRUE(iter.ReadInt64(&time_internal));
+    int msgid;
+    EXPECT_TRUE(iter.ReadInt(&msgid));
+    std::string payload;
+    EXPECT_TRUE(iter.ReadString(&payload));
+    // TODO(vtl): Should we use |HighResNow()| instead of |Now()|?
+    latency_messages_ += base::TimeTicks::Now() -
+                         base::TimeTicks::FromInternalValue(time_internal);
+
+    // cout << "reflector msg received: " << msgid << endl;
+    if (payload == "quit")
+      MessageLoop::current()->Quit();
+
+    IPC::Message* msg = new IPC::Message(0,
+                                         2,
+                                         IPC::Message::PRIORITY_NORMAL);
+    msg->WriteInt64(base::TimeTicks::Now().ToInternalValue());
+    msg->WriteInt(msgid);
+    msg->WriteString(payload);
+    channel_->Send(msg);
+    return true;
+  }
+
+ private:
+  IPC::Channel *channel_;
+  int count_messages_;
+  base::TimeDelta latency_messages_;
+};
+
+class ChannelPerfListener : public IPC::Listener {
+ public:
+  ChannelPerfListener(IPC::Channel* channel, int msg_count, int msg_size) :
+       count_down_(msg_count),
+       channel_(channel),
+       count_messages_(0) {
+    payload_.resize(msg_size);
+    for (int i = 0; i < static_cast<int>(payload_.size()); i++)
+      payload_[i] = 'a';
+    std::cout << "perflistener up" << std::endl;
+  }
+
+  ~ChannelPerfListener() {
+    std::cout << "Server Messages: " << count_messages_ << std::endl;
+    std::cout << "Server Latency: " << latency_messages_.InMilliseconds()
+              << std::endl;
+  }
+
+  virtual bool OnMessageReceived(const IPC::Message& message) {
+    count_messages_++;
+    // Decode the string so this gets counted in the total time.
+    PickleIterator iter(message);
+    int64 time_internal;
+    EXPECT_TRUE(iter.ReadInt64(&time_internal));
+    int msgid;
+    EXPECT_TRUE(iter.ReadInt(&msgid));
+    std::string cur;
+    EXPECT_TRUE(iter.ReadString(&cur));
+    latency_messages_ += base::TimeTicks::Now() -
+                         base::TimeTicks::FromInternalValue(time_internal);
+
+    count_down_--;
+    if (count_down_ == 0) {
+      IPC::Message* msg = new IPC::Message(0,
+                                           2,
+                                           IPC::Message::PRIORITY_NORMAL);
+      msg->WriteInt64(base::TimeTicks::Now().ToInternalValue());
+      msg->WriteInt(count_down_);
+      msg->WriteString("quit");
+      channel_->Send(msg);
+
+      MessageLoop::current()->QuitWhenIdle();
+      return true;
+    }
+
+    IPC::Message* msg = new IPC::Message(0,
+                                         2,
+                                         IPC::Message::PRIORITY_NORMAL);
+    msg->WriteInt64(base::TimeTicks::Now().ToInternalValue());
+    msg->WriteInt(count_down_);
+    msg->WriteString(payload_);
+    channel_->Send(msg);
+    return true;
+  }
+
+ private:
+  int count_down_;
+  std::string payload_;
+  IPC::Channel *channel_;
+  int count_messages_;
+  base::TimeDelta latency_messages_;
+};
+
+TEST_F(IPCChannelPerfTest, Performance) {
+  // setup IPC channel
+  IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_SERVER, NULL);
+  ChannelPerfListener perf_listener(&chan, 10000, 100000);
+  chan.set_listener(&perf_listener);
+  ASSERT_TRUE(chan.Connect());
+
+  base::ProcessHandle process_handle = SpawnChild(TEST_REFLECTOR, &chan);
+  ASSERT_TRUE(process_handle);
+
+  base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
+
+  PerfTimeLogger logger("IPC_Perf");
+
+  // 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);
+
+  // run message loop
+  MessageLoop::current()->Run();
+
+  // Clean up child process.
+  EXPECT_TRUE(base::WaitForSingleProcess(
+      process_handle, base::TimeDelta::FromSeconds(5)));
+  base::CloseProcessHandle(process_handle);
+}
+
+// This message loop bounces all messages back to the sender
+MULTIPROCESS_IPC_TEST_MAIN(RunReflector) {
+  MessageLoopForIO main_message_loop;
+  IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_CLIENT, NULL);
+  ChannelReflectorListener channel_reflector_listener(&chan);
+  chan.set_listener(&channel_reflector_listener);
+  CHECK(chan.Connect());
+
+  MessageLoop::current()->Run();
+  return 0;
+}
diff --git a/ipc/ipc_send_fds_test.cc b/ipc/ipc_send_fds_test.cc
index 6679088..06a4660 100644
--- a/ipc/ipc_send_fds_test.cc
+++ b/ipc/ipc_send_fds_test.cc
@@ -4,8 +4,6 @@
 
 #include "build/build_config.h"
 
-#include "ipc/ipc_tests.h"
-
 #if defined(OS_MACOSX)
 extern "C" {
 #include <sandbox.h>
@@ -20,6 +18,7 @@ extern "C" {
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/ipc_multiprocess_test.h"
+#include "ipc/ipc_test_base.h"
 #include "testing/multiprocess_func_list.h"
 
 #if defined(OS_POSIX)
@@ -132,7 +131,9 @@ int TestDescriptorClient(ino_t expected_inode_num) {
 
 }  // namespace
 
-// ---------------------------------------------------------------------------
+class IPCSendFdsTest : public IPCTestBase {
+};
+
 #if defined(OS_MACOSX)
 // TODO(port): Make this test cross-platform.
 MULTIPROCESS_IPC_TEST_MAIN(RunTestDescriptorClientSandboxed) {
@@ -165,7 +166,7 @@ MULTIPROCESS_IPC_TEST_MAIN(RunTestDescriptorClientSandboxed) {
 }
 
 // Test that FDs are correctly sent to a sandboxed process.
-TEST_F(IPCChannelTest, DescriptorTestSandboxed) {
+TEST_F(IPCSendFdsTest, DescriptorTestSandboxed) {
     // Setup IPC channel.
   MyChannelDescriptorListener listener(-1);
 
@@ -189,7 +190,7 @@ MULTIPROCESS_IPC_TEST_MAIN(RunTestDescriptorClient) {
   return TestDescriptorClient(st.st_ino);
 }
 
-TEST_F(IPCChannelTest, DescriptorTest) {
+TEST_F(IPCSendFdsTest, DescriptorTest) {
     // Setup IPC channel.
   MyChannelDescriptorListener listener(-1);
 
diff --git a/ipc/ipc_test_base.cc b/ipc/ipc_test_base.cc
new file mode 100644
index 0000000..2d68a76
--- /dev/null
+++ b/ipc/ipc_test_base.cc
@@ -0,0 +1,131 @@
+// 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 <stdio.h>
+#include <string>
+#include <utility>
+
+#include "ipc/ipc_test_base.h"
+
+#include "base/base_switches.h"
+#include "base/command_line.h"
+#include "base/debug/debug_on_start_win.h"
+#include "base/perftimer.h"
+#include "base/pickle.h"
+#include "base/test/perf_test_suite.h"
+#include "base/test/test_suite.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_switches.h"
+#include "testing/multiprocess_func_list.h"
+
+// Define to enable IPC performance testing instead of the regular unit tests
+// #define PERFORMANCE_TEST
+
+const char kTestClientChannel[] = "T1";
+const char kReflectorChannel[] = "T2";
+const char kFuzzerChannel[] = "F3";
+const char kSyncSocketChannel[] = "S4";
+
+void IPCTestBase::SetUp() {
+  MultiProcessTest::SetUp();
+
+  // Construct a fresh IO Message loop for the duration of each test.
+  message_loop_ = new MessageLoopForIO();
+}
+
+void IPCTestBase::TearDown() {
+  delete message_loop_;
+  message_loop_ = NULL;
+
+  MultiProcessTest::TearDown();
+}
+
+#if defined(OS_WIN)
+base::ProcessHandle IPCTestBase::SpawnChild(IPCTestBase::ChildType child_type,
+                                            IPC::Channel *channel) {
+  // kDebugChildren support.
+  bool debug_on_start =
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kDebugChildren);
+
+  switch (child_type) {
+  case TEST_CLIENT:
+    return MultiProcessTest::SpawnChild("RunTestClient", debug_on_start);
+  case TEST_REFLECTOR:
+    return MultiProcessTest::SpawnChild("RunReflector", debug_on_start);
+  case FUZZER_SERVER:
+    return MultiProcessTest::SpawnChild("RunFuzzServer", debug_on_start);
+  case SYNC_SOCKET_SERVER:
+    return MultiProcessTest::SpawnChild("RunSyncSocketServer", debug_on_start);
+  default:
+    return NULL;
+  }
+}
+#elif defined(OS_POSIX)
+base::ProcessHandle IPCTestBase::SpawnChild(IPCTestBase::ChildType child_type,
+                                            IPC::Channel *channel) {
+  // kDebugChildren support.
+  bool debug_on_start =
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kDebugChildren);
+
+  base::FileHandleMappingVector fds_to_map;
+  const int ipcfd = channel->GetClientFileDescriptor();
+  if (ipcfd > -1) {
+    fds_to_map.push_back(std::pair<int, int>(ipcfd, kPrimaryIPCChannel + 3));
+  }
+
+  base::ProcessHandle ret = base::kNullProcessHandle;
+  switch (child_type) {
+  case TEST_CLIENT:
+    ret = MultiProcessTest::SpawnChild("RunTestClient",
+                                       fds_to_map,
+                                       debug_on_start);
+    break;
+  case TEST_DESCRIPTOR_CLIENT:
+    ret = MultiProcessTest::SpawnChild("RunTestDescriptorClient",
+                                       fds_to_map,
+                                       debug_on_start);
+    break;
+  case TEST_DESCRIPTOR_CLIENT_SANDBOXED:
+    ret = MultiProcessTest::SpawnChild("RunTestDescriptorClientSandboxed",
+                                       fds_to_map,
+                                       debug_on_start);
+    break;
+  case TEST_REFLECTOR:
+    ret = MultiProcessTest::SpawnChild("RunReflector",
+                                       fds_to_map,
+                                       debug_on_start);
+    break;
+  case FUZZER_SERVER:
+    ret = MultiProcessTest::SpawnChild("RunFuzzServer",
+                                       fds_to_map,
+                                       debug_on_start);
+    break;
+  case SYNC_SOCKET_SERVER:
+    ret = MultiProcessTest::SpawnChild("RunSyncSocketServer",
+                                       fds_to_map,
+                                       debug_on_start);
+    break;
+  default:
+    return base::kNullProcessHandle;
+    break;
+  }
+  return ret;
+}
+#endif  // defined(OS_POSIX)
diff --git a/ipc/ipc_tests.h b/ipc/ipc_test_base.h
index 76d274c..08d410c 100644
--- a/ipc/ipc_tests.h
+++ b/ipc/ipc_test_base.h
@@ -2,22 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef IPC_IPC_TESTS_H_
-#define IPC_IPC_TESTS_H_
+#ifndef IPC_IPC_TEST_BASE_H_
+#define IPC_IPC_TEST_BASE_H_
 
-#include "base/test/multiprocess_test.h"
 #include "base/process.h"
-
-// This unit test uses 3 types of child processes, a regular pipe client,
-// a client reflector and a IPC server used for fuzzing tests.
-enum ChildType {
-  TEST_CLIENT,
-  TEST_DESCRIPTOR_CLIENT,
-  TEST_DESCRIPTOR_CLIENT_SANDBOXED,
-  TEST_REFLECTOR,
-  FUZZER_SERVER,
-  SYNC_SOCKET_SERVER
-};
+#include "base/test/multiprocess_test.h"
 
 // The different channel names for the child processes.
 extern const char kTestClientChannel[];
@@ -30,11 +19,20 @@ namespace IPC {
 class Channel;
 }  // namespace IPC
 
-//Base class to facilitate Spawning IPC Client processes.
-class IPCChannelTest : public base::MultiProcessTest {
- protected:
+// Base class to facilitate spawning IPC client processes.
+class IPCTestBase : public base::MultiProcessTest {
+ public:
+  enum ChildType {
+    TEST_CLIENT,
+    TEST_DESCRIPTOR_CLIENT,
+    TEST_DESCRIPTOR_CLIENT_SANDBOXED,
+    TEST_REFLECTOR,
+    FUZZER_SERVER,
+    SYNC_SOCKET_SERVER
+  };
 
-  // Create a new MessageLoopForIO For each test.
+ protected:
+  // Create a new MessageLoopForIO for each test.
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
@@ -45,4 +43,4 @@ class IPCChannelTest : public base::MultiProcessTest {
   MessageLoopForIO* message_loop_;
 };
 
-#endif  // IPC_IPC_TESTS_H_
+#endif  // IPC_IPC_TEST_BASE_H_
diff --git a/ipc/sync_socket_unittest.cc b/ipc/sync_socket_unittest.cc
index 69a2dca..a5cfc6b 100644
--- a/ipc/sync_socket_unittest.cc
+++ b/ipc/sync_socket_unittest.cc
@@ -14,7 +14,7 @@
 #include "base/threading/thread.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_multiprocess_test.h"
-#include "ipc/ipc_tests.h"
+#include "ipc/ipc_test_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
@@ -164,7 +164,7 @@ class SyncSocketClientListener : public IPC::Listener {
   DISALLOW_COPY_AND_ASSIGN(SyncSocketClientListener);
 };
 
-class SyncSocketTest : public IPCChannelTest {
+class SyncSocketTest : public IPCTestBase {
 };
 
 TEST_F(SyncSocketTest, SanityTest) {