Revert of Remove IPC::BrokerableAttachment.

ipc/ipc_channel_mojo.cc

 // Copyright 2014 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/ipc_channel_mojo.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 108 matching lines @@
 
 base::ScopedFD TakeOrDupFile(internal::PlatformFileAttachment* attachment) {
   return attachment->Owns() ? base::ScopedFD(attachment->TakePlatformFile())
                             : base::ScopedFD(dup(attachment->file()));
 }
 
 #endif
 
 MojoResult WrapAttachmentImpl(MessageAttachment* attachment,
                               mojom::SerializedHandlePtr* serialized) {
-  if (attachment->GetType() == MessageAttachment::Type::MOJO_HANDLE) {
+  if (attachment->GetType() == MessageAttachment::TYPE_MOJO_HANDLE) {
     *serialized = CreateSerializedHandle(
         static_cast<internal::MojoHandleAttachment&>(*attachment).TakeHandle(),
         mojom::SerializedHandle::Type::MOJO_HANDLE);
     return MOJO_RESULT_OK;
   }
 #if defined(OS_POSIX)
-  if (attachment->GetType() == MessageAttachment::Type::PLATFORM_FILE) {
+  if (attachment->GetType() == MessageAttachment::TYPE_PLATFORM_FILE) {
     // We dup() the handles in IPC::Message to transmit.
     // IPC::MessageAttachmentSet has intricate lifecycle semantics
     // of FDs, so just to dup()-and-own them is the safest option.
     base::ScopedFD file = TakeOrDupFile(
         static_cast<IPC::internal::PlatformFileAttachment*>(attachment));
     if (!file.is_valid()) {
       DPLOG(WARNING) << "Failed to dup FD to transmit.";
       return MOJO_RESULT_UNKNOWN;
     }
 
     return WrapPlatformHandle(file.release(),
                               mojom::SerializedHandle::Type::PLATFORM_FILE,
                               serialized);
   }
 #endif
 #if defined(OS_MACOSX)
-  DCHECK_EQ(attachment->GetType(), MessageAttachment::Type::MACH_PORT);
+  DCHECK_EQ(attachment->GetType(),
+            MessageAttachment::TYPE_BROKERABLE_ATTACHMENT);
+  DCHECK_EQ(static_cast<BrokerableAttachment&>(*attachment).GetBrokerableType(),
+            BrokerableAttachment::MACH_PORT);
   internal::MachPortAttachmentMac& mach_port_attachment =
       static_cast<internal::MachPortAttachmentMac&>(*attachment);
   MojoResult result = WrapMachPort(mach_port_attachment.get_mach_port(),
                                    serialized);
   mach_port_attachment.reset_mach_port_ownership();
   return result;
 #elif defined(OS_WIN)
-  DCHECK_EQ(attachment->GetType(), MessageAttachment::Type::WIN_HANDLE);
+  DCHECK_EQ(attachment->GetType(),
+            MessageAttachment::TYPE_BROKERABLE_ATTACHMENT);
+  DCHECK_EQ(static_cast<BrokerableAttachment&>(*attachment).GetBrokerableType(),
+            BrokerableAttachment::WIN_HANDLE);
   internal::HandleAttachmentWin& handle_attachment =
       static_cast<internal::HandleAttachmentWin&>(*attachment);
   MojoResult result = WrapPlatformHandle(
       handle_attachment.get_handle(),
       mojom::SerializedHandle::Type::WIN_HANDLE, serialized);
   handle_attachment.reset_handle_ownership();
   return result;
 #else
   NOTREACHED();
   return MOJO_RESULT_UNKNOWN;
@@ skipping 226 matching lines @@
     base::Optional<std::vector<mojom::SerializedHandlePtr>>* handles) {
   DCHECK(!*handles);
 
   MojoResult result = MOJO_RESULT_OK;
   if (!message->HasAttachments())
     return result;
 
   std::vector<mojom::SerializedHandlePtr> output_handles;
   MessageAttachmentSet* set = message->attachment_set();
 
-  for (unsigned i = 0; result == MOJO_RESULT_OK && i < set->size(); ++i) {
-    result = WrapAttachment(set->GetAttachmentAt(i).get(), &output_handles);
+  for (unsigned i = 0;
+       result == MOJO_RESULT_OK && i < set->num_non_brokerable_attachments();
+       ++i) {
+    result = WrapAttachment(set->GetNonBrokerableAttachmentAt(i).get(),
+                            &output_handles);
   }
+  for (unsigned i = 0;
+       result == MOJO_RESULT_OK && i < set->num_brokerable_attachments(); ++i) {
+    result = WrapAttachment(set->GetBrokerableAttachmentAt(i).get(),
+                            &output_handles);
+  }
+
   set->CommitAllDescriptors();
 
   if (!output_handles.empty())
     *handles = std::move(output_handles);
 
   return result;
 }
 
 // static
 MojoResult ChannelMojo::WriteToMessageAttachmentSet(
@@ skipping 37 matching lines @@
 }
 
 void ChannelMojo::GetGenericRemoteAssociatedInterface(
     const std::string& name,
     mojo::ScopedInterfaceEndpointHandle handle) {
   if (message_reader_)
     message_reader_->GetRemoteInterface(name, std::move(handle));
 }
 
 }  // namespace IPC