POSIX: Add a macro for handling EINTR.

net/base/tcp_client_socket_libevent.cc

 // Copyright (c) 2006-2008 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 "net/base/tcp_client_socket_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
 
+#include "base/eintr_wrappers.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "net/base/net_errors.h"
 #include "third_party/libevent/event.h"
 
 
 namespace net {
 
 const int kInvalidSocket = -1;
@@ skipping 64 matching lines @@
   DCHECK(!waiting_connect_);
 
   TRACE_EVENT_BEGIN("socket.connect", this, "");
   const addrinfo* ai = current_ai_;
   DCHECK(ai);
 
   int rv = CreateSocket(ai);
   if (rv != OK)
     return rv;
 
-  if (!connect(socket_, ai->ai_addr, static_cast<int>(ai->ai_addrlen))) {
+  if (!HANDLE_EINTR(connect(socket_, ai->ai_addr,
+                            static_cast<int>(ai->ai_addrlen)))) {
     TRACE_EVENT_END("socket.connect", this, "");
     // Connected without waiting!
     return OK;
   }
 
   // Synchronous operation not supported
   DCHECK(callback);
 
   if (errno != EINPROGRESS) {
     DLOG(INFO) << "connect failed: " << errno;
@@ skipping 33 matching lines @@
   // Reset for next time.
   current_ai_ = addresses_.head();
 }
 
 bool TCPClientSocketLibevent::IsConnected() const {
   if (socket_ == kInvalidSocket || waiting_connect_)
     return false;
 
   // Check if connection is alive.
   char c;
-  int rv = recv(socket_, &c, 1, MSG_PEEK);
+  int rv = HANDLE_EINTR(recv(socket_, &c, 1, MSG_PEEK));
   if (rv == 0)
     return false;
   if (rv == -1 && errno != EAGAIN && errno != EWOULDBLOCK)
     return false;
 
   return true;
 }
 
 bool TCPClientSocketLibevent::IsConnectedAndIdle() const {
   if (socket_ == kInvalidSocket || waiting_connect_)
     return false;
 
   // Check if connection is alive and we haven't received any data
   // unexpectedly.
   char c;
-  int rv = recv(socket_, &c, 1, MSG_PEEK);
+  int rv = HANDLE_EINTR(recv(socket_, &c, 1, MSG_PEEK));
   if (rv >= 0)
     return false;
   if (errno != EAGAIN && errno != EWOULDBLOCK)
     return false;
 
   return true;
 }
 
 int TCPClientSocketLibevent::Read(IOBuffer* buf,
                                   int buf_len,
                                   CompletionCallback* callback) {
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(!waiting_connect_);
   DCHECK(!read_callback_);
   // Synchronous operation not supported
   DCHECK(callback);
   DCHECK_GT(buf_len, 0);
 
   TRACE_EVENT_BEGIN("socket.read", this, "");
-  int nread = read(socket_, buf->data(), buf_len);
+  int nread = HANDLE_EINTR(read(socket_, buf->data(), buf_len));
   if (nread >= 0) {
     TRACE_EVENT_END("socket.read", this, StringPrintf("%d bytes", nread));
     return nread;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK) {
     DLOG(INFO) << "read failed, errno " << errno;
     return MapPosixError(errno);
   }
 
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
@@ skipping 13 matching lines @@
                                    int buf_len,
                                    CompletionCallback* callback) {
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(!waiting_connect_);
   DCHECK(!write_callback_);
   // Synchronous operation not supported
   DCHECK(callback);
   DCHECK_GT(buf_len, 0);
 
   TRACE_EVENT_BEGIN("socket.write", this, "");
-  int nwrite = write(socket_, buf->data(), buf_len);
+  int nwrite = HANDLE_EINTR(write(socket_, buf->data(), buf_len));
   if (nwrite >= 0) {
     TRACE_EVENT_END("socket.write", this, StringPrintf("%d bytes", nwrite));
     return nwrite;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK)
     return MapPosixError(errno);
 
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
           socket_, true, MessageLoopForIO::WATCH_WRITE,
           &socket_watcher_, this)) {
@@ skipping 71 matching lines @@
     waiting_connect_ = false;
   }
 
   if (result != ERR_IO_PENDING) {
     DoReadCallback(result);
   }
 }
 
 void TCPClientSocketLibevent::DidCompleteRead() {
   int bytes_transferred;
-  bytes_transferred = read(socket_, read_buf_->data(), read_buf_len_);
+  bytes_transferred = HANDLE_EINTR(read(socket_, read_buf_->data(),
+                                        read_buf_len_));
 
   int result;
   if (bytes_transferred >= 0) {
     TRACE_EVENT_END("socket.read", this,
                     StringPrintf("%d bytes", bytes_transferred));
     result = bytes_transferred;
   } else {
     result = MapPosixError(errno);
   }
 
   if (result != ERR_IO_PENDING) {
     read_buf_ = NULL;
     read_buf_len_ = 0;
     socket_watcher_.StopWatchingFileDescriptor();
     DoReadCallback(result);
   }
 }
 
 void TCPClientSocketLibevent::DidCompleteWrite() {
   int bytes_transferred;
-  bytes_transferred = write(socket_, write_buf_->data(), write_buf_len_);
+  bytes_transferred = HANDLE_EINTR(write(socket_, write_buf_->data(),
+                                         write_buf_len_));
 
   int result;
   if (bytes_transferred >= 0) {
     result = bytes_transferred;
     TRACE_EVENT_END("socket.write", this,
                     StringPrintf("%d bytes", bytes_transferred));
   } else {
     result = MapPosixError(errno);
   }
 
@@ skipping 20 matching lines @@
     DidCompleteWrite();
   }
 }
 
 int TCPClientSocketLibevent::GetPeerName(struct sockaddr *name,
                                          socklen_t *namelen) {
   return ::getpeername(socket_, name, namelen);
 }
 
 }  // namespace net