Revert of 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,
-                          std::vector<mojom::SerializedHandlePtr>* handles) {
+                          mojo::Array<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,
-    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);
+    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();
   }
-  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;
+  return MOJO_RESULT_OK;
 }
 
 // static
 MojoResult ChannelMojo::WriteToMessageAttachmentSet(
-    base::Optional<std::vector<mojom::SerializedHandlePtr>> handle_buffer,
+    mojo::Array<mojom::SerializedHandlePtr> handle_buffer,
     Message* message) {
-  if (!handle_buffer)
-    return MOJO_RESULT_OK;
-  for (size_t i = 0; i < handle_buffer->size(); ++i) {
+  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