Mojo: Abstract out write/writev vs send/sendmsg (for Unix domain sockets).

mojo/system/raw_channel_posix.cc

 // Copyright 2013 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/system/raw_channel.h"
 
 #include <errno.h>
-#include <sys/socket.h>
-#include <sys/types.h>
 #include <sys/uio.h>
 #include <unistd.h>
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/synchronization/lock.h"
-#include "build/build_config.h"
+#include "mojo/embedder/platform_channel_utils_posix.h"
 #include "mojo/embedder/platform_handle.h"
 
 namespace mojo {
 namespace system {
 
 namespace {
 
 class RawChannelPosix : public RawChannel,
                         public base::MessageLoopForIO::Watcher {
  public:
@@ skipping 102 matching lines @@
   write_lock().AssertAcquired();
 
   DCHECK(!pending_write_);
 
   std::vector<WriteBuffer::Buffer> buffers;
   write_buffer_no_lock()->GetBuffers(&buffers);
   DCHECK(!buffers.empty());
 
   ssize_t write_result = -1;
   if (buffers.size() == 1) {
-    write_result = HANDLE_EINTR(
-        write(fd_.get().fd, buffers[0].addr, buffers[0].size));
+    write_result = embedder::PlatformChannelWrite(fd_.get(), buffers[0].addr,
+                                                  buffers[0].size);
   } else {
     // Note that using |writev()|/|sendmsg()| is measurably slower than using
     // |write()| -- at least in a microbenchmark -- but much faster than using
     // multiple |write()|s. (|sendmsg()| is also measurably slightly slower than
     // |writev()|.)
     //
     // On Linux, we need to use |sendmsg()| since it's the only way to suppress
     // |SIGPIPE| (on Mac, this is suppressed on the socket itself using
     // |setsockopt()|, since |MSG_NOSIGNAL| is not supported -- see
     // platform_channel_pair_posix.cc).
     const size_t kMaxBufferCount = 10;
     iovec iov[kMaxBufferCount];
     size_t buffer_count = std::min(buffers.size(), kMaxBufferCount);
 
     for (size_t i = 0; i < buffer_count; ++i) {
       iov[i].iov_base = const_cast<char*>(buffers[i].addr);
       iov[i].iov_len = buffers[i].size;
     }
 
-    // On Mac, we can use |writev()|, which is slightly faster, but on Linux we
-    // need to use |sendmsg()|. See comment above.
-    // TODO(vtl): We should have an actual test that |SIGPIPE| is suppressed for
-    // |RawChannelPosix|, since it has to be suppressed at "use" time on Linux.
-    // Or maybe I should abstract out |write()|/|send()| and
-    // |writev()|/|sendmsg()|. crbug.com/356195
-#if defined(OS_MACOSX)
-    write_result = HANDLE_EINTR(writev(fd_.get().fd, iov, buffer_count));
-#else
-    struct msghdr msg = {};
-    msg.msg_iov = iov;
-    msg.msg_iovlen = buffer_count;
-    write_result = HANDLE_EINTR(sendmsg(fd_.get().fd, &msg, MSG_NOSIGNAL));
-#endif
+    write_result = embedder::PlatformChannelWritev(fd_.get(), iov,
+                                                   buffer_count);
   }
 
   if (write_result >= 0) {
     *bytes_written = static_cast<size_t>(write_result);
     return IO_SUCCEEDED;
   }
 
   if (errno != EAGAIN && errno != EWOULDBLOCK) {
     PLOG(ERROR) << "write of size "
                 << write_buffer_no_lock()->GetTotalBytesToWrite();
@@ skipping 137 matching lines @@
 
 // Static factory method declared in raw_channel.h.
 // static
 scoped_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return scoped_ptr<RawChannel>(new RawChannelPosix(handle.Pass()));
 }
 
 }  // namespace system
 }  // namespace mojo