ipc: Use a global for the process's attachment broker.

ipc/attachment_broker_privileged_win_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 <windows.h>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 202 matching lines @@
     IPCTestBase::SetUp();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_path_));
   }
 
   void TearDown() override { IPCTestBase::TearDown(); }
 
   // Takes ownership of |broker|. Has no effect if called after CommonSetUp().
   void set_broker(IPC::AttachmentBrokerUnprivilegedWin* broker) {
     broker_.reset(broker);
+    IPC::AttachmentBroker::SetGlobal(broker);
   }
 
   void CommonSetUp() {
     if (!broker_.get())
       set_broker(new IPC::AttachmentBrokerUnprivilegedWin);
     broker_->AddObserver(&observer_);
     set_attachment_broker(broker_.get());
     CreateChannel(&proxy_listener_);
     broker_->DesignateBrokerCommunicationChannel(channel());
     ASSERT_TRUE(ConnectChannel());
@@ skipping 184 matching lines @@
                                            const IPC::Message& message);
 
 int CommonPrivilegedProcessMain(OnMessageReceivedCallback callback,
                                 const char* channel_name) {
   LOG(INFO) << "Privileged process start.";
   base::MessageLoopForIO main_message_loop;
   ProxyListener listener;
 
   // Set up IPC channel.
   IPC::AttachmentBrokerPrivilegedWin broker;
+  IPC::AttachmentBroker::SetGlobal(&broker);

[Tom Sepez, 2015/09/11 15:58:30]

This goes out of scope while the process is still alive, seemingly contradicting
the previous comments. Now the process is well on its way to exiting when the
code returns ...

[erikchen, 2015/09/11 20:16:02]

I updated the comment to say:
"""
Each process has at most one attachment broker. The process is responsible
for ensuring that |broker| stays alive for as long as the process is
sending/receiving ipc messages.
"""

   scoped_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
       IPCTestBase::GetChannelName(channel_name), &listener, &broker));
   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)
@@ skipping 114 matching lines @@
     SendControlMessage(sender, success);
   }
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendHandleTwice) {
   return CommonPrivilegedProcessMain(&SendHandleTwiceCallback,
                                      "SendHandleTwice");
 }
 
 }  // namespace