ipc: Minor fixes to AttachmentBrokerPrivilegedMac.

ipc/attachment_broker_privileged_mac.h

 // 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.
 
 #ifndef IPC_ATTACHMENT_BROKER_PRIVILEGED_MAC_H_
 #define IPC_ATTACHMENT_BROKER_PRIVILEGED_MAC_H_
 
 #include <mach/mach.h>
 
 #include <map>
@@ skipping 46 matching lines @@
     : public AttachmentBrokerPrivileged,
       public base::PortProvider::Observer {
  public:
   explicit AttachmentBrokerPrivilegedMac(base::PortProvider* port_provider);
   ~AttachmentBrokerPrivilegedMac() override;
 
   // IPC::AttachmentBroker overrides.
   bool SendAttachmentToProcess(
       const scoped_refptr<IPC::BrokerableAttachment>& attachment,
       base::ProcessId destination_process) override;
+  void DeregisterCommunicationChannel(Endpoint* endpoint) override;
 
   // IPC::Listener overrides.
   bool OnMessageReceived(const Message& message) override;
 
   // base::PortProvider::Observer override.
   void OnReceivedTaskPort(base::ProcessHandle process) override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(AttachmentBrokerPrivilegedMacMultiProcessTest,
                            InsertRight);
@@ skipping 66 matching lines @@
   // |port_to_insert| must be a send right in the current task's name space.
   // Creates an intermediate Mach port in |pid| and sends |port_to_insert| as a
   // mach_msg to the intermediate Mach port.
   // Returns the intermediate port on success, and MACH_PORT_NULL on failure.
   // This method takes ownership of |port_to_insert|. On success, ownership is
   // passed to the intermediate Mach port.
   mach_port_name_t CreateIntermediateMachPort(
       mach_port_t task_port,
       base::mac::ScopedMachSendRight port_to_insert);
 
-  // Acquire a send right to a named right in |pid|.
-  // Returns MACH_PORT_NULL on error.
-  base::mac::ScopedMachSendRight AcquireSendRight(base::ProcessId pid,
-                                                  mach_port_name_t named_right);
-
   // Extracts a copy of the send right to |named_right| from |task_port|.
   // Returns MACH_PORT_NULL on error.
   base::mac::ScopedMachSendRight ExtractNamedRight(
       mach_port_t task_port,
       mach_port_name_t named_right);
 
   // Copies an existing |wire_format|, but substitutes in a different mach port.
   MachPortWireFormat CopyWireFormat(const MachPortWireFormat& wire_format,
                                     uint32_t mach_port);
 
   // |wire_format.destination_process| must be this process.
   // |wire_format.mach_port| must be the final Mach port.
   // Consumes a reference to |wire_format.mach_port|, as ownership is implicitly
   // passed to the consumer of the Chrome IPC message.
   // Makes an attachment, queues it, and notifies the observers.
   void RoutePrecursorToSelf(AttachmentPrecursor* precursor);
 
   // |wire_format.destination_process| must be another process.
   // |wire_format.mach_port| must be the intermediate Mach port.
   // Ownership of |wire_format.mach_port| is implicitly passed to the process
   // that receives the Chrome IPC message.
-  void RouteWireFormatToAnother(const MachPortWireFormat& wire_format);
+  // Returns |false| on irrecoverable error.
+  bool RouteWireFormatToAnother(const MachPortWireFormat& wire_format);
 
   // Atempts to broker all precursors whose destination is |pid|. Has no effect
   // if |port_provider_| does not have the task port for |pid|.
   void SendPrecursorsForProcess(base::ProcessId pid);
 
   // Brokers a single precursor into the task represented by |task_port|.
-  void SendPrecursor(AttachmentPrecursor* precursor, mach_port_t task_port);
+  // Returns |false| on irrecoverable error.
+  bool SendPrecursor(AttachmentPrecursor* precursor, mach_port_t task_port);
 
   // Add a precursor to |precursors_|. Takes ownership of |port|.
   void AddPrecursor(base::ProcessId pid,
                     base::mac::ScopedMachSendRight port,
                     const BrokerableAttachment::AttachmentId& id);
 
   // Atempts to process all extractors whose source is |pid|. Has no effect
   // if |port_provider_| does not have the task port for |pid|.
   void ProcessExtractorsForProcess(base::ProcessId pid);
 
@@ skipping 19 matching lines @@
   // processed.
   std::map<base::ProcessId, ScopedVector<AttachmentExtractor>*> extractors_;
   base::Lock extractors_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(AttachmentBrokerPrivilegedMac);
 };
 
 }  // namespace IPC
 
 #endif  // IPC_ATTACHMENT_BROKER_PRIVILEGED_MAC_H_