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

ipc/attachment_broker_privileged.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.h"
 
 #include <algorithm>
 
+#include "base/bind.h"
 #include "base/lazy_instance.h"
+#include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "build/build_config.h"
 #include "ipc/ipc_endpoint.h"
 
 #if defined(OS_WIN)
 #include "ipc/attachment_broker_privileged_win.h"
 #endif
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 #include <mach/mach.h>
@@ skipping 83 matching lines @@
 // static
 void AttachmentBrokerPrivileged::CreateBrokerForSingleProcessTests() {
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   CreateBrokerIfNeeded(&g_fake_port_provider.Get());
 #else
   CreateBrokerIfNeeded();
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 }
 
 void AttachmentBrokerPrivileged::RegisterCommunicationChannel(
-    Endpoint* endpoint) {
+    Endpoint* endpoint,
+    scoped_refptr<base::SingleThreadTaskRunner> runner) {
   base::AutoLock auto_lock(*get_lock());
   endpoint->SetAttachmentBrokerEndpoint(true);
-  auto it = std::find(endpoints_.begin(), endpoints_.end(), endpoint);
+  auto it = std::find_if(endpoints_.begin(), endpoints_.end(),
+                         [endpoint](const EndpointRunnerPair& pair) {
+                           return pair.first == endpoint;
+                         });
   DCHECK(endpoints_.end() == it);
-  endpoints_.push_back(endpoint);
+  endpoints_.push_back(std::make_pair(endpoint, runner));
 }
 
 void AttachmentBrokerPrivileged::DeregisterCommunicationChannel(
     Endpoint* endpoint) {
   base::AutoLock auto_lock(*get_lock());
-  auto it = std::find(endpoints_.begin(), endpoints_.end(), endpoint);
+  auto it = std::find_if(endpoints_.begin(), endpoints_.end(),
+                         [endpoint](const EndpointRunnerPair& pair) {
+                           return pair.first == endpoint;
+                         });
   if (it != endpoints_.end())
     endpoints_.erase(it);
 }
 
 bool AttachmentBrokerPrivileged::IsPrivilegedBroker() {
   return true;
 }
 
-Sender* AttachmentBrokerPrivileged::GetSenderWithProcessId(base::ProcessId id) {
+AttachmentBrokerPrivileged::EndpointRunnerPair
+AttachmentBrokerPrivileged::GetSenderWithProcessId(base::ProcessId id) {
   get_lock()->AssertAcquired();
   auto it = std::find_if(endpoints_.begin(), endpoints_.end(),
-                         [id](Endpoint* c) { return c->GetPeerPID() == id; });
+                         [id](const EndpointRunnerPair& pair) {
+                           return pair.first->GetPeerPID() == id;
+                         });
   if (it == endpoints_.end())
-    return nullptr;
+    return std::make_pair(nullptr, nullptr);
   return *it;
 }
 
+void AttachmentBrokerPrivileged::SendMessageToEndpoint(EndpointRunnerPair pair,
+                                                       Message* message) {
+  if (!pair.second || pair.second->BelongsToCurrentThread()) {
+    pair.first->Send(message);
+  } else {
+    pair.second->PostTask(
+        FROM_HERE,
+        base::Bind(&AttachmentBrokerPrivileged::SendMessageToEndpoint,
+                   base::Unretained(this), pair, message));
+  }
+}
+
 void AttachmentBrokerPrivileged::LogError(UMAError error) {
   UMA_HISTOGRAM_ENUMERATION(
       "IPC.AttachmentBrokerPrivileged.BrokerAttachmentError", error, ERROR_MAX);
 }
 
 }  // namespace IPC