Mojo C++ bindings: make ipc/ mojom targets to use STL string/vector types

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 161 matching lines @@
       mojom::SerializedHandle::Type::WIN_HANDLE, serialized);
   handle_attachment.reset_handle_ownership();
   return result;
 #else
   NOTREACHED();
   return MOJO_RESULT_UNKNOWN;
 #endif  // defined(OS_MACOSX)
 }
 
 MojoResult WrapAttachment(MessageAttachment* attachment,
-                          mojo::Array<mojom::SerializedHandlePtr>* handles) {
+                          std::vector<mojom::SerializedHandlePtr>* handles) {
   mojom::SerializedHandlePtr serialized_handle;
   MojoResult wrap_result = WrapAttachmentImpl(attachment, &serialized_handle);
   if (wrap_result != MOJO_RESULT_OK) {
     LOG(WARNING) << "Pipe failed to wrap handles. Closing: " << wrap_result;
     return wrap_result;
   }
   handles->push_back(std::move(serialized_handle));
   return MOJO_RESULT_OK;
 }
 
@@ skipping 209 matching lines @@
 }
 
 base::ScopedFD ChannelMojo::TakeClientFileDescriptor() {
   return base::ScopedFD(GetClientFileDescriptor());
 }
 #endif  // defined(OS_POSIX) && !defined(OS_NACL_SFI)
 
 // static
 MojoResult ChannelMojo::ReadFromMessageAttachmentSet(
     Message* message,
-    mojo::Array<mojom::SerializedHandlePtr>* handles) {
-  if (message->HasAttachments()) {
-    MessageAttachmentSet* set = message->attachment_set();
-    for (unsigned i = 0; i < set->num_non_brokerable_attachments(); ++i) {
-      MojoResult result = WrapAttachment(
-              set->GetNonBrokerableAttachmentAt(i).get(), handles);
-      if (result != MOJO_RESULT_OK) {
-        set->CommitAllDescriptors();
-        return result;
-      }
-    }
-    for (unsigned i = 0; i < set->num_brokerable_attachments(); ++i) {
-      MojoResult result =
-          WrapAttachment(set->GetBrokerableAttachmentAt(i).get(), handles);
-      if (result != MOJO_RESULT_OK) {
-        set->CommitAllDescriptors();
-        return result;
-      }
-    }
-    set->CommitAllDescriptors();
+    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->num_non_brokerable_attachments();
+       ++i) {
+    result = WrapAttachment(set->GetNonBrokerableAttachmentAt(i).get(),
+                            &output_handles);
   }
-  return MOJO_RESULT_OK;
+  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(
-    mojo::Array<mojom::SerializedHandlePtr> handle_buffer,
+    base::Optional<std::vector<mojom::SerializedHandlePtr>> handle_buffer,
     Message* message) {
-  for (size_t i = 0; i < handle_buffer.size(); ++i) {
+  if (!handle_buffer)
+    return MOJO_RESULT_OK;
+  for (size_t i = 0; i < handle_buffer->size(); ++i) {
     scoped_refptr<MessageAttachment> unwrapped_attachment;
-    MojoResult unwrap_result = UnwrapAttachment(std::move(handle_buffer[i]),
-                                                    &unwrapped_attachment);
+    MojoResult unwrap_result =
+        UnwrapAttachment(std::move((*handle_buffer)[i]), &unwrapped_attachment);
     if (unwrap_result != MOJO_RESULT_OK) {
       LOG(WARNING) << "Pipe failed to unwrap handles. Closing: "
                    << unwrap_result;
       return unwrap_result;
     }
     DCHECK(unwrapped_attachment);
 
     bool ok = message->attachment_set()->AddAttachment(
         std::move(unwrapped_attachment));
     DCHECK(ok);
@@ skipping 19 matching lines @@
 }
 
 void ChannelMojo::GetGenericRemoteAssociatedInterface(
     const std::string& name,
     mojo::ScopedInterfaceEndpointHandle handle) {
   if (message_reader_)
     message_reader_->GetRemoteInterface(name, std::move(handle));
 }
 
 }  // namespace IPC