IPC: Fix attachment brokering race condition.

ipc/attachment_broker_mac_unittest.cc

 // Copyright 2015 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 <fcntl.h>
 #include <mach/mach_vm.h>
 #include <stddef.h>
 #include <sys/mman.h>
@@ skipping 405 matching lines @@
 
   // Mach Setup that needs to occur after child processes are forked.
   void MachPostForkSetUp() {
     client_port_.reset(IPC::ReceiveMachPort(server_port_.get()).release());
     IPC::SendMachPort(
         client_port_.get(), mach_task_self(), MACH_MSG_TYPE_COPY_SEND);
   }
 
   // Setup shared between tests.
   void CommonSetUp(const char* name) {
+    PreConnectSetUp(name);
+    PostConnectSetUp();
+  }
+
+  // All of setup before the channel is connected.
+  void PreConnectSetUp(const char* name) {
     Init(name);
     MachPreForkSetUp();
 
     if (!broker_.get())
       SetBroker(new IPC::AttachmentBrokerUnprivilegedMac);
 
     broker_->AddObserver(&observer_, task_runner());
     CreateChannel(&proxy_listener_);
     broker_->RegisterBrokerCommunicationChannel(channel());
+  }
+
+  // All of setup including the connection and everything after.
+  void PostConnectSetUp() {
     ASSERT_TRUE(ConnectChannel());
     ASSERT_TRUE(StartClient());
 
     MachPostForkSetUp();
     active_names_at_start_ = IPC::GetActiveNameCount();
     get_proxy_listener()->set_listener(&result_listener_);
   }
 
   void CheckChildResult() {
     ASSERT_EQ(ProxyListener::MESSAGE_RECEIVED,
@@ skipping 419 matching lines @@
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendPosixFDAndMachPort) {
   return CommonPrivilegedProcessMain(&SendPosixFDAndMachPortCallback,
                                      "SendPosixFDAndMachPort");
 }
 
 // Similar to SendHandle, except the attachment's destination process is this
 // process. This is an unrealistic scenario, but simulates an unprivileged
 // process sending an attachment to another unprivileged process.
 TEST_F(IPCAttachmentBrokerMacTest, SendSharedMemoryHandleToSelf) {
   SetBroker(new MockBroker);
-  CommonSetUp("SendSharedMemoryHandleToSelf");
-
+  PreConnectSetUp("SendSharedMemoryHandleToSelf");
   // Technically, the channel is an endpoint, but we need the proxy listener to
   // receive the messages so that it can quit the message loop.
   channel()->SetAttachmentBrokerEndpoint(false);
+  PostConnectSetUp();
   get_proxy_listener()->set_listener(get_broker());
 
   {
     std::unique_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
     mach_port_urefs_t ref_count = IPC::GetMachRefCount(
         shared_memory->handle().GetMemoryObject(), MACH_PORT_RIGHT_SEND);
 
     IPC::Message* message =
         new TestSharedMemoryHandleMsg1(100, shared_memory->handle(), 200);
@@ skipping 44 matching lines @@
 
   SetBroker(new IPC::AttachmentBrokerUnprivilegedMac);
   get_broker()->AddObserver(get_observer(), task_runner());
 
   std::unique_ptr<base::Thread> thread(
       new base::Thread("ChannelProxyTestServerThread"));
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   thread->StartWithOptions(options);
 
-  CreateChannelProxy(get_proxy_listener(), thread->task_runner().get());
+  set_channel_proxy(std::unique_ptr<IPC::ChannelProxy>(new IPC::ChannelProxy(
+      get_proxy_listener(), thread->task_runner().get())));
   get_broker()->RegisterBrokerCommunicationChannel(channel_proxy());
+  channel_proxy()->Init(
+      CreateChannelFactory(GetTestChannelHandle(), thread->task_runner().get()),
+      true);
 
   ASSERT_TRUE(StartClient());
 
   MachPostForkSetUp();
   active_names_at_start_ = IPC::GetActiveNameCount();
   get_proxy_listener()->set_listener(get_result_listener());
 
   SendMessage1(kDataBuffer1);
   base::MessageLoop::current()->Run();
 
@@ skipping 98 matching lines @@
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(ShareReadOnlyToProcess) {
   return CommonPrivilegedProcessMain(&ShareReadOnlyToProcessCallback,
                                      "ShareReadOnlyToProcess");
 }
 
 // Similar to SendSharedMemoryHandleToSelf, but the child process pretends to
 // not have the task port for the parent process.
 TEST_F(IPCAttachmentBrokerMacTest, SendSharedMemoryHandleToSelfDelayedPort) {
   SetBroker(new MockBroker);
-  CommonSetUp("SendSharedMemoryHandleToSelfDelayedPort");
-
+  PreConnectSetUp("SendSharedMemoryHandleToSelfDelayedPort");
   // Technically, the channel is an endpoint, but we need the proxy listener to
   // receive the messages so that it can quit the message loop.
   channel()->SetAttachmentBrokerEndpoint(false);
+  PostConnectSetUp();
   get_proxy_listener()->set_listener(get_broker());
 
   {
     std::unique_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
     mach_port_urefs_t ref_count = IPC::GetMachRefCount(
         shared_memory->handle().GetMemoryObject(), MACH_PORT_RIGHT_SEND);
 
     std::vector<IPC::BrokerableAttachment::AttachmentId> ids;
     const int kMessagesToTest = 3;
@@ skipping 197 matching lines @@
     SendControlMessage(sender, success);
   }
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(MemoryUsageManyMessages) {
   return CommonPrivilegedProcessMain(&MemoryUsageManyMessagesCallback,
                                      "MemoryUsageManyMessages");
 }
 
 }  // namespace