Remove IPC::Channel::set_listener().

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>
@@ skipping 70 matching lines @@
   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 {
  public:
-  explicit ChannelReflectorListener(IPC::Channel* channel)
-      : channel_(channel),
+  ChannelReflectorListener()
+      : channel_(NULL),
         latency_tracker_("Client messages") {
     VLOG(1) << "Client listener up";
   }
 
   ~ChannelReflectorListener() {
     VLOG(1) << "Client listener down";
     latency_tracker_.ShowResults();
   }
 
+  void Init(IPC::Channel* channel) {
+    DCHECK(!channel_);
+    channel_ = channel;
+  }
+
   virtual bool OnMessageReceived(const IPC::Message& message) {
+    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();
@@ skipping 18 matching lines @@
     return true;
   }
 
  private:
   IPC::Channel* channel_;
   EventTimeTracker latency_tracker_;
 };
 
 class ChannelPerfListener : public IPC::Listener {
  public:
-  ChannelPerfListener(IPC::Channel* channel)
-      : channel_(channel),
+  ChannelPerfListener()
+      : channel_(NULL),
         msg_count_(0),
         msg_size_(0),
         count_down_(0),
         latency_tracker_("Server messages") {
     VLOG(1) << "Server listener up";
   }
 
   ~ChannelPerfListener() {
     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) {
     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) {
+    CHECK(channel_);
+
     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));
 
     // Include message deserialization in latency.
     base::TimeTicks now = base::TimeTicks::Now();
@@ skipping 35 matching lines @@
   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.
-  IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_SERVER, NULL);
-  ChannelPerfListener perf_listener(&chan);
-  chan.set_listener(&perf_listener);
+  ChannelPerfListener perf_listener;
+  IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_SERVER,
+                    &perf_listener);
+  perf_listener.Init(&chan);
   ASSERT_TRUE(chan.Connect());
 
   base::ProcessHandle process_handle = SpawnChild(TEST_REFLECTOR, &chan);
   ASSERT_TRUE(process_handle);
 
   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++) {
@@ skipping 22 matching lines @@
 
   // 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);
+  ChannelReflectorListener channel_reflector_listener;
+  IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_CLIENT,
+                    &channel_reflector_listener);
+  channel_reflector_listener.Init(&chan);
   CHECK(chan.Connect());
 
   MessageLoop::current()->Run();
   return 0;
 }
 
 }  // namespace