Add support for Attachment Brokering of IPC::Channels on multiple threads.

ipc/attachment_broker_privileged_mac.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 "ipc/attachment_broker_privileged_mac.h"
 
 #include <stdint.h>
 
 #include "base/mac/scoped_mach_port.h"
 #include "base/memory/shared_memory.h"
@@ skipping 196 matching lines @@
   HandleReceivedAttachment(attachment);
 }
 
 bool AttachmentBrokerPrivilegedMac::RouteWireFormatToAnother(
     const MachPortWireFormat& wire_format) {
   DCHECK_NE(wire_format.destination_process, base::Process::Current().Pid());
 
   // Another process is the destination.
   base::ProcessId dest = wire_format.destination_process;
   base::AutoLock auto_lock(*get_lock());
-  Sender* sender = GetSenderWithProcessId(dest);
-  if (!sender) {
+  AttachmentBrokerPrivileged::EndpointRunnerPair pair =
+      GetSenderWithProcessId(dest);
+  if (!pair.first) {
     // Assuming that this message was not sent from a malicious process, the
     // channel endpoint that would have received this message will block
     // forever.
     LOG(ERROR) << "Failed to deliver brokerable attachment to process with id: "
                << dest;
     LogError(DESTINATION_NOT_FOUND);
     return false;
   }
 
   LogError(DESTINATION_FOUND);
-  sender->Send(new AttachmentBrokerMsg_MachPortHasBeenDuplicated(wire_format));
+  SendMessageToEndpoint(
+      pair, new AttachmentBrokerMsg_MachPortHasBeenDuplicated(wire_format));
   return true;
 }
 
 mach_port_name_t AttachmentBrokerPrivilegedMac::CreateIntermediateMachPort(
     mach_port_t task_port,
     base::mac::ScopedMachSendRight port_to_insert) {
   DCHECK_NE(mach_task_self(), task_port);
   DCHECK_NE(static_cast<mach_port_name_t>(MACH_PORT_NULL), task_port);
 
   // Make a port with receive rights in the destination task.
@@ skipping 77 matching lines @@
   base::AutoLock l(precursors_lock_);
   auto it = precursors_.find(pid);
   if (it == precursors_.end())
     return;
 
   // Whether this process is the destination process.
   bool to_self = pid == base::GetCurrentProcId();
 
   if (!to_self) {
     base::AutoLock auto_lock(*get_lock());
-    if (!GetSenderWithProcessId(pid)) {
+    AttachmentBrokerPrivileged::EndpointRunnerPair pair =
+        GetSenderWithProcessId(pid);
+    if (!pair.first) {
       // If there is no sender, then the destination process is no longer
       // running, or never existed to begin with.
       LogError(DESTINATION_NOT_FOUND);
       delete it->second;
       precursors_.erase(it);
       return;
     }
   }
 
   mach_port_t task_port = port_provider_->TaskForPid(pid);
@@ skipping 49 matching lines @@
 
 void AttachmentBrokerPrivilegedMac::ProcessExtractorsForProcess(
     base::ProcessId pid) {
   base::AutoLock l(extractors_lock_);
   auto it = extractors_.find(pid);
   if (it == extractors_.end())
     return;
 
   {
     base::AutoLock auto_lock(*get_lock());
-    if (!GetSenderWithProcessId(pid)) {
+    AttachmentBrokerPrivileged::EndpointRunnerPair pair =
+        GetSenderWithProcessId(pid);
+    if (!pair.first) {
       // If there is no sender, then the source process is no longer running.
       LogError(ERROR_SOURCE_NOT_FOUND);
       delete it->second;
       extractors_.erase(it);
       return;
     }
   }
 
   mach_port_t task_port = port_provider_->TaskForPid(pid);
 
@@ skipping 34 matching lines @@
 
   auto it = extractors_.find(source_pid);
   if (it == extractors_.end())
     extractors_[source_pid] = new ScopedVector<AttachmentExtractor>;
 
   extractors_[source_pid]->push_back(
       new AttachmentExtractor(source_pid, dest_pid, port, id));
 }
 
 }  // namespace IPC