ipc: Remove unnecessary attachment broker plumbing.

ipc/ipc_sync_channel_unittest.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_sync_channel.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 137 matching lines @@
     Send(reply_msg);
   }
 
   virtual void OnNestedTestMsg(Message* reply_msg) {
     NOTREACHED();
   }
 
   virtual SyncChannel* CreateChannel() {
     scoped_ptr<SyncChannel> channel = SyncChannel::Create(
         channel_name_, mode_, this, ipc_thread_.task_runner().get(), true,
-        &shutdown_event_, nullptr);
+        &shutdown_event_);
     return channel.release();
   }
 
   base::Thread* ListenerThread() {
     return overrided_thread_ ? overrided_thread_ : &listener_thread_;
   }
 
   const base::Thread& ipc_thread() const { return ipc_thread_; }
 
  private:
@@ skipping 156 matching lines @@
 
   void Run() override {
     SendAnswerToLife(false, true);
     Done();
   }
 
   SyncChannel* CreateChannel() override {
     SyncChannel* channel =
         SyncChannel::Create(channel_name(), mode(), this,
                             ipc_thread().task_runner().get(), create_pipe_now_,
-                            shutdown_event(), nullptr).release();
+                            shutdown_event())
+            .release();
     return channel;
   }
 
   bool create_pipe_now_;
 };
 
 class TwoStepClient : public Worker {
  public:
   TwoStepClient(bool create_pipe_now)
       : Worker(Channel::MODE_CLIENT, "simple_client"),
         create_pipe_now_(create_pipe_now) { }
 
   void OnAnswer(int* answer) override {
     *answer = 42;
     Done();
   }
 
   SyncChannel* CreateChannel() override {
     SyncChannel* channel =
         SyncChannel::Create(channel_name(), mode(), this,
                             ipc_thread().task_runner().get(), create_pipe_now_,
-                            shutdown_event(), nullptr).release();
+                            shutdown_event())
+            .release();
     return channel;
   }
 
   bool create_pipe_now_;
 };
 
 void TwoStep(bool create_server_pipe_now, bool create_client_pipe_now) {
   std::vector<Worker*> workers;
   workers.push_back(new TwoStepServer(create_server_pipe_now));
   workers.push_back(new TwoStepClient(create_client_pipe_now));
@@ skipping 784 matching lines @@
         FROM_HERE, base::Bind(&RestrictedDispatchServer::OnDoPing, server_, 1));
     sent_ping_event_->Wait();
     Send(new SyncChannelTestMsg_NoArgs);
     if (ping_ == 1)
       ++*success_;
     else
       LOG(ERROR) << "Send failed to dispatch incoming message on same channel";
 
     non_restricted_channel_ = SyncChannel::Create(
         "non_restricted_channel", IPC::Channel::MODE_CLIENT, this,
-        ipc_thread().task_runner().get(), true, shutdown_event(), nullptr);
+        ipc_thread().task_runner().get(), true, shutdown_event());
 
     server_->ListenerThread()->task_runner()->PostTask(
         FROM_HERE, base::Bind(&RestrictedDispatchServer::OnDoPing, server_, 2));
     sent_ping_event_->Wait();
     // Check that the incoming message is *not* dispatched when sending on the
     // non restricted channel.
     // TODO(piman): there is a possibility of a false positive race condition
     // here, if the message that was posted on the server-side end of the pipe
     // is not visible yet on the client side, but I don't know how to solve this
     // without hooking into the internals of SyncChannel. I haven't seen it in
@@ skipping 366 matching lines @@
     Done();
   }
 
   void Run() override {
     channel()->SetRestrictDispatchChannelGroup(group_);
     if (is_first())
       event1_->Signal();
     event2_->Wait();
     other_channel_ = SyncChannel::Create(
         other_channel_name_, IPC::Channel::MODE_CLIENT, this,
-        ipc_thread().task_runner().get(), true, shutdown_event(), nullptr);
+        ipc_thread().task_runner().get(), true, shutdown_event());
     other_channel_->SetRestrictDispatchChannelGroup(group_);
     if (!is_first()) {
       event1_->Signal();
       return;
     }
     *success_ = 0;
     int value = 0;
     OnPingTTL(3, &value);
     *success_ += (value == 3);
     OnPingTTL(4, &value);
@@ skipping 61 matching lines @@
 
 class ReentrantReplyServer1 : public Worker {
  public:
   ReentrantReplyServer1(WaitableEvent* server_ready)
       : Worker("reentrant_reply1", Channel::MODE_SERVER),
         server_ready_(server_ready) { }
 
   void Run() override {
     server2_channel_ = SyncChannel::Create(
         "reentrant_reply2", IPC::Channel::MODE_CLIENT, this,
-        ipc_thread().task_runner().get(), true, shutdown_event(), nullptr);
+        ipc_thread().task_runner().get(), true, shutdown_event());
     server_ready_->Signal();
     Message* msg = new SyncChannelTestMsg_Reentrant1();
     server2_channel_->Send(msg);
     server2_channel_.reset();
     Done();
   }
 
  private:
   bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(ReentrantReplyServer1, message)
@@ skipping 158 matching lines @@
 }
 
 // Windows needs to send an out-of-band secret to verify the client end of the
 // channel. Test that we still connect correctly in that case.
 TEST_F(IPCSyncChannelTest, Verified) {
   Verified();
 }
 
 }  // namespace
 }  // namespace IPC