Add ipc_mojo_perftests

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 "build/build_config.h"
+#include "ipc/ipc_perftest_support.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/perf_time_logger.h"
 #include "base/test/test_io_thread.h"
 #include "base/threading/thread.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 "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 {
-};
+namespace IPC {
+namespace test {
 
 // This class simply collects stats about abstract "events" (each of which has a
 // start time and an end time).
 class EventTimeTracker {
  public:
   explicit EventTimeTracker(const char* name)
       : name_(name),
         count_(0) {
   }
 
@@ skipping 28 matching lines @@
   uint64 count_;
   base::TimeDelta total_duration_;
   base::TimeDelta max_duration_;
 
   DISALLOW_COPY_AND_ASSIGN(EventTimeTracker);
 };
 
 // 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 {
+class ChannelReflectorListener : public Listener {
  public:
   ChannelReflectorListener()
       : channel_(NULL),
         latency_tracker_("Client messages") {
     VLOG(1) << "Client listener up";
   }
 
   virtual ~ChannelReflectorListener() {
     VLOG(1) << "Client listener down";
     latency_tracker_.ShowResults();
   }
 
-  void Init(IPC::Channel* channel) {
+  void Init(Channel* channel) {
     DCHECK(!channel_);
     channel_ = channel;
   }
 
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+  virtual bool OnMessageReceived(const Message& message) OVERRIDE {
     CHECK(channel_);
 
     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));
 
     // Include message deserialization in latency.
     base::TimeTicks now = base::TimeTicks::Now();
 
     if (payload == "hello") {
       latency_tracker_.Reset();
     } else if (payload == "quit") {
       latency_tracker_.ShowResults();
       base::MessageLoop::current()->QuitWhenIdle();
       return true;
     } else {
       // Don't track hello and quit messages.
       latency_tracker_.AddEvent(
           base::TimeTicks::FromInternalValue(time_internal), now);
     }
 
-    IPC::Message* msg = new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+    Message* msg = new Message(0, 2, Message::PRIORITY_NORMAL);
     msg->WriteInt64(base::TimeTicks::Now().ToInternalValue());
     msg->WriteInt(msgid);
     msg->WriteString(payload);
     channel_->Send(msg);
     return true;
   }
 
  private:
-  IPC::Channel* channel_;
+  Channel* channel_;
   EventTimeTracker latency_tracker_;
 };
 
-class PerformanceChannelListener : public IPC::Listener {
+class PerformanceChannelListener : public Listener {
  public:
   explicit PerformanceChannelListener(const std::string& label)
       : label_(label),
         sender_(NULL),
         msg_count_(0),
         msg_size_(0),
         count_down_(0),
         latency_tracker_("Server messages") {
     VLOG(1) << "Server listener up";
   }
 
   virtual ~PerformanceChannelListener() {
     VLOG(1) << "Server listener down";
   }
 
-  void Init(IPC::Sender* sender) {
+  void Init(Sender* sender) {
     DCHECK(!sender_);
     sender_ = sender;
   }
 
   // Call this before running the message loop.
   void SetTestParams(int msg_count, size_t msg_size) {
     DCHECK_EQ(0, count_down_);
     msg_count_ = msg_count;
     msg_size_ = msg_size;
     count_down_ = msg_count_;
     payload_ = std::string(msg_size_, 'a');
   }
 
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+  virtual bool OnMessageReceived(const Message& message) OVERRIDE {
     CHECK(sender_);
 
     PickleIterator iter(message);
     int64 time_internal;
     EXPECT_TRUE(iter.ReadInt64(&time_internal));
     int msgid;
     EXPECT_TRUE(iter.ReadInt(&msgid));
     std::string reflected_payload;
     EXPECT_TRUE(iter.ReadString(&reflected_payload));
 
@@ skipping 19 matching lines @@
       CHECK(count_down_ > 0);
       count_down_--;
       if (count_down_ == 0) {
         perf_logger_.reset();  // Stop the perf timer now.
         latency_tracker_.ShowResults();
         base::MessageLoop::current()->QuitWhenIdle();
         return true;
       }
     }
 
-    IPC::Message* msg = new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+    Message* msg = new Message(0, 2, Message::PRIORITY_NORMAL);
     msg->WriteInt64(base::TimeTicks::Now().ToInternalValue());
     msg->WriteInt(count_down_);
     msg->WriteString(payload_);
     sender_->Send(msg);
     return true;
   }
 
  private:
   std::string label_;
-  IPC::Sender* sender_;
+  Sender* sender_;
   int msg_count_;
   size_t msg_size_;
 
   int count_down_;
   std::string payload_;
   EventTimeTracker latency_tracker_;
   scoped_ptr<base::PerfTimeLogger> perf_logger_;
 };
 
-TEST_F(IPCChannelPerfTest, ChannelPingPong) {
+std::vector<PingPongTestParams>
+IPCChannelPerfTestBase::GetDefaultTestParams() {
+  // Test several sizes. We use 12^N for message size, and limit the message
+  // count to keep the test duration reasonable.
+  std::vector<PingPongTestParams> list;
+  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, 100));
+  return list;
+}
+
+void IPCChannelPerfTestBase::RunTestChannelPingPong(
+    const std::vector<PingPongTestParams>& params) {
   Init("PerformanceClient");
 
   // Set up IPC channel and start client.
   PerformanceChannelListener listener("Channel");
   CreateChannel(&listener);
   listener.Init(channel());
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
-  // Test several sizes. We use 12^N for message size, and limit the message
-  // count to keep the test duration reasonable.
-  const size_t kMsgSize[5] = {12, 144, 1728, 20736, 248832};
-  const int kMessageCount[5] = {50000, 50000, 50000, 12000, 1000};
-
-  for (size_t i = 0; i < 5; i++) {
-    listener.SetTestParams(kMessageCount[i], kMsgSize[i]);
+  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.
-    IPC::Message* message =
-        new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+    Message* message =
+        new Message(0, 2, Message::PRIORITY_NORMAL);
     message->WriteInt64(base::TimeTicks::Now().ToInternalValue());
     message->WriteInt(-1);
     message->WriteString("hello");
     sender()->Send(message);
 
     // Run message loop.
     base::MessageLoop::current()->Run();
   }
 
   // Send quit message.
-  IPC::Message* message = new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+  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());
   DestroyChannel();
 }
 
-// This message loop bounces all messages back to the sender.
-MULTIPROCESS_IPC_TEST_CLIENT_MAIN(PerformanceClient) {
-  base::MessageLoopForIO main_message_loop;
-  ChannelReflectorListener listener;
-  scoped_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
-      IPCTestBase::GetChannelName("PerformanceClient"), &listener));
-  listener.Init(channel.get());
-  CHECK(channel->Connect());
-
-  base::MessageLoop::current()->Run();
-  return 0;
-}
-
-TEST_F(IPCChannelPerfTest, ChannelProxyPingPong) {
+void IPCChannelPerfTestBase::RunTestChannelProxyPingPong(
+    const std::vector<PingPongTestParams>& params) {
   InitWithCustomMessageLoop("PerformanceClient",
                             make_scoped_ptr(new base::MessageLoop()));
 
   base::TestIOThread io_thread(base::TestIOThread::kAutoStart);
 
   // Set up IPC channel and start client.
   PerformanceChannelListener listener("ChannelProxy");
   CreateChannelProxy(&listener, io_thread.task_runner());
   listener.Init(channel_proxy());
   ASSERT_TRUE(StartClient());
 
-  // Test several sizes. We use 12^N for message size, and limit the message
-  // count to keep the test duration reasonable.
-  const size_t kMsgSize[5] = {12, 144, 1728, 20736, 248832};
-  const int kMessageCount[5] = {50000, 50000, 50000, 12000, 1000};
-
-  for (size_t i = 0; i < 5; i++) {
-    listener.SetTestParams(kMessageCount[i], kMsgSize[i]);
+  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.
-    IPC::Message* message =
-        new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+    Message* message =
+        new Message(0, 2, Message::PRIORITY_NORMAL);
     message->WriteInt64(base::TimeTicks::Now().ToInternalValue());
     message->WriteInt(-1);
     message->WriteString("hello");
     sender()->Send(message);
 
     // Run message loop.
     base::MessageLoop::current()->Run();
   }
 
   // Send quit message.
-  IPC::Message* message = new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+  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();
 }
 
-}  // namespace
+
+PingPongTestClient::PingPongTestClient()
+    : listener_(new ChannelReflectorListener()) {
+}
+
+PingPongTestClient::~PingPongTestClient() {
+}
+
+scoped_ptr<Channel> PingPongTestClient::CreateChannel(
+    Listener* listener) {
+  return Channel::CreateClient(
+      IPCTestBase::GetChannelName("PerformanceClient"), listener);
+}
+
+int PingPongTestClient::RunMain() {
+  scoped_ptr<Channel> channel = CreateChannel(listener_.get());
+  listener_->Init(channel.get());
+  CHECK(channel->Connect());
+
+  base::MessageLoop::current()->Run();
+  return 0;
+}
+
+scoped_refptr<base::TaskRunner> PingPongTestClient::task_runner() {
+  return main_message_loop_.message_loop_proxy();
+}
+
+}  // namespace test
+}  // namespace IPC