[mojo-edk] Re-enable ping pong multiprocess tests

mojo/edk/system/channel_posix.cc

 // Copyright 2016 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 "mojo/edk/system/channel.h"
 
 #include <errno.h>
 #include <sys/uio.h>
 
 #include <algorithm>
@@ skipping 48 matching lines @@
 
   size_t data_offset() const { return offset_; }
   void advance_data_offset(size_t num_bytes) {
     DCHECK_GT(message_->data_num_bytes(), offset_ + num_bytes);
     offset_ += num_bytes;
   }
 
   ScopedPlatformHandleVectorPtr TakeHandles() { return std::move(handles_); }
   Channel::MessagePtr TakeMessage() { return std::move(message_); }
 
+  void SetHandles(ScopedPlatformHandleVectorPtr handles) {
+    handles_ = std::move(handles);
+  }
+
  private:
   Channel::MessagePtr message_;
   size_t offset_;
   ScopedPlatformHandleVectorPtr handles_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageView);
 };
 
 class ChannelPosix : public Channel,
                      public base::MessageLoop::DestructionObserver,
@@ skipping 191 matching lines @@
       ssize_t result;
       ScopedPlatformHandleVectorPtr handles = message_view.TakeHandles();
       if (handles && handles->size()) {
         iovec iov = {
           const_cast<void*>(message_view.data()),
           message_view.data_num_bytes()
         };
         // TODO: Handle lots of handles.
         result = PlatformChannelSendmsgWithHandles(
             handle_.get(), &iov, 1, handles->data(), handles->size());
+        if (result >= 0) {
 #if defined(OS_MACOSX)
-        // There is a bug on OSX which makes it dangerous to close
-        // a file descriptor while it is in transit. So instead we
-        // store the file descriptor in a set and send a message to
-        // the recipient, which is queued AFTER the message that
-        // sent the FD. The recipient will reply to the message,
-        // letting us know that it is now safe to close the file
-        // descriptor. For more information, see:
-        // http://crbug.com/298276
-        std::vector<int> fds;
-        for (auto& handle : *handles)
-          fds.push_back(handle.handle);
-        {
-          base::AutoLock l(handles_to_close_lock_);
+          // There is a bug on OSX which makes it dangerous to close
+          // a file descriptor while it is in transit. So instead we
+          // store the file descriptor in a set and send a message to
+          // the recipient, which is queued AFTER the message that
+          // sent the FD. The recipient will reply to the message,
+          // letting us know that it is now safe to close the file
+          // descriptor. For more information, see:
+          // http://crbug.com/298276
+          std::vector<int> fds;
           for (auto& handle : *handles)
-            handles_to_close_->push_back(handle);
+            fds.push_back(handle.handle);
+          {
+            base::AutoLock l(handles_to_close_lock_);
+            for (auto& handle : *handles)
+              handles_to_close_->push_back(handle);
+          }
+          MessagePtr fds_message(
+              new Channel::Message(sizeof(fds[0]) * fds.size(), 0,
+                                   Message::Header::MessageType::HANDLES_SENT));
+          memcpy(fds_message->mutable_payload(), fds.data(),
+                 sizeof(fds[0]) * fds.size());
+          outgoing_messages_.emplace_back(std::move(fds_message), 0);
+          handles->clear();
+#else
+          handles.reset();
+#endif  // defined(OS_MACOSX)
         }
-        MessagePtr fds_message(
-            new Channel::Message(sizeof(fds[0]) * fds.size(), 0,
-                                 Message::Header::MessageType::HANDLES_SENT));
-        memcpy(fds_message->mutable_payload(), fds.data(),
-               sizeof(fds[0]) * fds.size());
-        outgoing_messages_.emplace_back(std::move(fds_message), 0);
-        handles->clear();
-#else
-        handles.reset();
-#endif  // defined(OS_MACOSX)
       } else {
         result = PlatformChannelWrite(handle_.get(), message_view.data(),
                                       message_view.data_num_bytes());
       }
 
       if (result < 0) {
         if (errno != EAGAIN && errno != EWOULDBLOCK)
           return false;
+        message_view.SetHandles(std::move(handles));
         outgoing_messages_.emplace_front(std::move(message_view));
         WaitForWriteOnIOThreadNoLock();
         return true;
       }
 
       bytes_written = static_cast<size_t>(result);
     } while (bytes_written < message_view.data_num_bytes());
 
     return FlushOutgoingMessagesNoLock();
   }
@@ skipping 116 matching lines @@
 // static
 scoped_refptr<Channel> Channel::Create(
     Delegate* delegate,
     ScopedPlatformHandle platform_handle,
     scoped_refptr<base::TaskRunner> io_task_runner) {
   return new ChannelPosix(delegate, std::move(platform_handle), io_task_runner);
 }
 
 }  // namespace edk
 }  // namespace mojo