ipc: Move AttachmentBrokerPrivileged singleton logic into ipc/.

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 <sys/mman.h>
 
 #include "base/command_line.h"
@@ skipping 437 matching lines @@
 
   ResultListener result_listener_;
 };
 
 using OnMessageReceivedCallback = void (*)(IPC::Sender* sender,
                                            const IPC::Message& message);
 
 // These objects are globally accessible, and are expected to outlive all IPC
 // Channels.
 struct ChildProcessGlobals {
-  IPC::AttachmentBrokerPrivilegedMac broker;
+  scoped_ptr<IPC::AttachmentBrokerPrivilegedMac> broker;
   MockPortProvider port_provider;
   base::mac::ScopedMachSendRight server_task_port;
 };
 
 // Sets up the Mach communication ports with the server. Returns a set of
 // globals that must live at least as long as the test.
 scoped_ptr<ChildProcessGlobals> CommonChildProcessSetUp() {
   base::CommandLine cmd_line = *base::CommandLine::ForCurrentProcess();
   std::string service_name =
       cmd_line.GetSwitchValueASCII(g_service_switch_name);
   base::mac::ScopedMachSendRight server_port(
       IPC::LookupServer(service_name.c_str()));
   base::mac::ScopedMachReceiveRight client_port(IPC::MakeReceivingPort());
 
   // Send the port that this process is listening on to the server.
   IPC::SendMachPort(
       server_port.get(), client_port.get(), MACH_MSG_TYPE_MAKE_SEND);
 
   // Receive the task port of the server process.
   base::mac::ScopedMachSendRight server_task_port(
       IPC::ReceiveMachPort(client_port.get()));
 
   scoped_ptr<ChildProcessGlobals> globals(new ChildProcessGlobals);
+  globals->broker.reset(
+      new IPC::AttachmentBrokerPrivilegedMac(&globals->port_provider));
   globals->port_provider.InsertEntry(getppid(), server_task_port.get());
-  globals->broker.set_port_provider(&globals->port_provider);
   globals->server_task_port.reset(server_task_port.release());
   return globals;
 }
 
 int CommonPrivilegedProcessMain(OnMessageReceivedCallback callback,
                                 const char* channel_name) {
   LOG(INFO) << "Privileged process start.";
   scoped_ptr<ChildProcessGlobals> globals(CommonChildProcessSetUp());
 
   mach_msg_type_number_t active_names_at_start = IPC::GetActiveNameCount();
 
   base::MessageLoopForIO main_message_loop;
   ProxyListener listener;
 
   scoped_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
       IPCTestBase::GetChannelName(channel_name), &listener));
-  globals->broker.RegisterCommunicationChannel(channel.get());
+  globals->broker->RegisterCommunicationChannel(channel.get());
   CHECK(channel->Connect());
 
   while (true) {
     LOG(INFO) << "Privileged process spinning run loop.";
     base::MessageLoop::current()->Run();
     ProxyListener::Reason reason = listener.get_reason();
     if (reason == ProxyListener::CHANNEL_ERROR)
       break;
 
     while (listener.has_message()) {
@@ skipping 320 matching lines @@
   // Do nothing special. The default behavior already runs the
   // AttachmentBrokerPrivilegedMac.
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandleToSelf) {
   return CommonPrivilegedProcessMain(&SendSharedMemoryHandleToSelfCallback,
                                      "SendSharedMemoryHandleToSelf");
 }
 
 }  // namespace