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

BUG=624136

Review-Url: https://codereview.chromium.org/2181443002
Cr-Commit-Position: refs/heads/master@{#407340}

ipc/BUILD.gn

@@ -165,8 +165,6 @@ mojom("mojom") {
   sources = [
     "ipc.mojom",
   ]
-
-  use_new_wrapper_types = false
 }
 
 mojom("test_interfaces") {
@@ -174,8 +172,6 @@ mojom("test_interfaces") {
   sources = [
     "ipc_test.mojom",
   ]
-
-  use_new_wrapper_types = false
 }
 
 # This is provided as a separate target so other targets can provide param

ipc/ipc.gyp

@@ -45,7 +45,6 @@
         'mojom_files': [
           'ipc.mojom',
         ],
-        'use_new_wrapper_types': 'false',
       },
       'includes': [ '../mojo/mojom_bindings_generator_explicit.gypi' ],
     },
@@ -68,9 +67,6 @@
         'ipc_test.mojom',
       ],
       'includes': [ '../mojo/mojom_bindings_generator.gypi' ],
-      'variables': {
-        'use_new_wrapper_types': 'false',
-      },
     },
     {
       'target_name': 'ipc_run_all_unittests',

ipc/ipc_channel_mojo.cc

@@ -179,7 +179,7 @@ MojoResult WrapAttachmentImpl(MessageAttachment* attachment,
 }
 
 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) {
@@ -409,38 +409,46 @@ base::ScopedFD ChannelMojo::TakeClientFileDescriptor() {
 // 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;

ipc/ipc_channel_mojo.h

@@ -83,11 +83,11 @@ class IPC_EXPORT ChannelMojo
   // These access protected API of IPC::Message, which has ChannelMojo
   // as a friend class.
   static MojoResult WriteToMessageAttachmentSet(
-      mojo::Array<mojom::SerializedHandlePtr> handle_buffer,
+      base::Optional<std::vector<mojom::SerializedHandlePtr>> handle_buffer,
       Message* message);
   static MojoResult ReadFromMessageAttachmentSet(
       Message* message,
-      mojo::Array<mojom::SerializedHandlePtr>* handles);
+      base::Optional<std::vector<mojom::SerializedHandlePtr>>* handles);
 
   // MojoBootstrapDelegate implementation
   void OnPipesAvailable(mojom::ChannelAssociatedPtr sender,

ipc/ipc_channel_mojo_unittest.cc

@@ -628,7 +628,7 @@ class ListenerWithSimpleAssociatedInterface
 
  private:
   // IPC::mojom::SimpleTestDriver:
-  void ExpectString(const mojo::String& str) override {
+  void ExpectString(const std::string& str) override {
     next_expected_string_ = str;
   }
 
@@ -805,7 +805,7 @@ class ListenerWithSimpleProxyAssociatedInterface
 
  private:
   // IPC::mojom::SimpleTestDriver:
-  void ExpectString(const mojo::String& str) override {
+  void ExpectString(const std::string& str) override {
     next_expected_string_ = str;
   }
 

ipc/ipc_message_pipe_reader.cc

@@ -86,20 +86,20 @@ bool MessagePipeReader::Send(std::unique_ptr<Message> message) {
                          "MessagePipeReader::Send",
                          message->flags(),
                          TRACE_EVENT_FLAG_FLOW_OUT);
-  mojo::Array<mojom::SerializedHandlePtr> handles(nullptr);
+  base::Optional<std::vector<mojom::SerializedHandlePtr>> handles;
   MojoResult result = MOJO_RESULT_OK;
   result = ChannelMojo::ReadFromMessageAttachmentSet(message.get(), &handles);
   if (result != MOJO_RESULT_OK)
     return false;
 
-  mojo::Array<uint8_t> data(message->size());
+  std::vector<uint8_t> data(message->size());
   std::copy(reinterpret_cast<const uint8_t*>(message->data()),
             reinterpret_cast<const uint8_t*>(message->data()) + message->size(),
-            &data[0]);
+            data.data());
 
   MessageSerializer serializer;
   mojom::ChannelProxy proxy(&serializer);
-  proxy.Receive(std::move(data), std::move(handles));
+  proxy.Receive(data, std::move(handles));
   mojo::Message* mojo_message = serializer.message();
 
   size_t num_handles = mojo_message->handles()->size();
@@ -127,11 +127,11 @@ void MessagePipeReader::SetPeerPid(int32_t peer_pid) {
 }
 
 void MessagePipeReader::Receive(
-    mojo::Array<uint8_t> data,
-    mojo::Array<mojom::SerializedHandlePtr> handles) {
+    const std::vector<uint8_t>& data,
+    base::Optional<std::vector<mojom::SerializedHandlePtr>> handles) {
   DCHECK_NE(peer_pid_, base::kNullProcessId);
   Message message(
-      data.size() == 0 ? "" : reinterpret_cast<const char*>(&data[0]),
+      data.empty() ? "" : reinterpret_cast<const char*>(data.data()),
       static_cast<uint32_t>(data.size()));
   message.set_sender_pid(peer_pid_);
 
@@ -151,7 +151,7 @@ void MessagePipeReader::Receive(
 }
 
 void MessagePipeReader::GetAssociatedInterface(
-    const mojo::String& name,
+    const std::string& name,
     mojom::GenericInterfaceAssociatedRequest request) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (delegate_)

ipc/ipc_message_pipe_reader.h

@@ -95,10 +95,11 @@ class IPC_EXPORT MessagePipeReader : public NON_EXPORTED_BASE(mojom::Channel) {
  private:
   // mojom::Channel:
   void SetPeerPid(int32_t peer_pid) override;
-  void Receive(mojo::Array<uint8_t> data,
-               mojo::Array<mojom::SerializedHandlePtr> handles) override;
+  void Receive(
+      const std::vector<uint8_t>& data,
+      base::Optional<std::vector<mojom::SerializedHandlePtr>> handles) override;
   void GetAssociatedInterface(
-      const mojo::String& name,
+      const std::string& name,
       mojom::GenericInterfaceAssociatedRequest request) override;
 
   // |delegate_| is null once the message pipe is closed.