ipc: Create AttachmentBrokerPrivileged and AttachmentBrokerUnprivileged.

ipc/attachment_broker_privileged_win.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_win.h"
 
 #include <windows.h>
 
 #include "base/process/process.h"
 #include "ipc/attachment_broker_messages.h"
@@ skipping 29 matching lines @@
 bool AttachmentBrokerPrivilegedWin::OnMessageReceived(const Message& msg) {
   bool handled = true;
   switch (msg.type()) {
     IPC_MESSAGE_HANDLER_GENERIC(AttachmentBrokerMsg_DuplicateWinHandle,
                                 OnDuplicateWinHandle(msg))
     IPC_MESSAGE_UNHANDLED(handled = false)
   }
   return handled;
 }
 
-void AttachmentBrokerPrivilegedWin::RegisterCommunicationChannel(
-    Channel* channel) {
-  auto it = std::find(channels_.begin(), channels_.end(), channel);
-  DCHECK(channels_.end() == it);
-  channels_.push_back(channel);
-}
-
-void AttachmentBrokerPrivilegedWin::DeregisterCommunicationChannel(
-    Channel* channel) {
-  auto it = std::find(channels_.begin(), channels_.end(), channel);
-  DCHECK(it != channels_.end());
-  channels_.erase(it);
-}
-
 void AttachmentBrokerPrivilegedWin::OnDuplicateWinHandle(
     const IPC::Message& message) {
   AttachmentBrokerMsg_DuplicateWinHandle::Param param;
   if (!AttachmentBrokerMsg_DuplicateWinHandle::Read(&message, &param))
     return;
   IPC::internal::HandleAttachmentWin::WireFormat wire_format =
       base::get<0>(param);
 
   if (wire_format.destination_process == base::kNullProcessId)
     return;
 
   HandleWireFormat new_wire_format =
       DuplicateWinHandle(wire_format, message.get_sender_pid());
   RouteDuplicatedHandle(new_wire_format);
 }
 
 void AttachmentBrokerPrivilegedWin::RouteDuplicatedHandle(
     const HandleWireFormat& wire_format) {
   // This process is the destination.
   if (wire_format.destination_process == base::Process::Current().Pid()) {
     scoped_refptr<BrokerableAttachment> attachment(
         new internal::HandleAttachmentWin(wire_format));
     HandleReceivedAttachment(attachment);
     return;
   }
 
   // Another process is the destination.
   base::ProcessId dest = wire_format.destination_process;
-  auto it =
-      std::find_if(channels_.begin(), channels_.end(),
-                   [dest](Channel* c) { return c->GetPeerPID() == dest; });
-  if (it == channels_.end()) {
+  Channel* channel = GetChannelWithProcessId(dest);
+  if (!channel) {
     // 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;
     return;
   }
 
-  (*it)->Send(new AttachmentBrokerMsg_WinHandleHasBeenDuplicated(wire_format));
+  channel->Send(
+      new AttachmentBrokerMsg_WinHandleHasBeenDuplicated(wire_format));
 }
 
 AttachmentBrokerPrivilegedWin::HandleWireFormat
 AttachmentBrokerPrivilegedWin::DuplicateWinHandle(
     const HandleWireFormat& wire_format,
     base::ProcessId source_pid) {
   HandleWireFormat new_wire_format;
   new_wire_format.destination_process = wire_format.destination_process;
   new_wire_format.attachment_id = wire_format.attachment_id;
 
@@ skipping 10 matching lines @@
                                      FALSE, DUPLICATE_SAME_ACCESS);
 
     new_wire_format.handle = (result != 0) ? HandleToLong(new_handle) : 0;
   } else {
     new_wire_format.handle = 0;
   }
   return new_wire_format;
 }
 
 }  // namespace IPC