POSIX: Add a macro for handling EINTR.

net/base/listen_socket_unittest.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/listen_socket_unittest.h"
 
 #include <fcntl.h>
 
+#include "base/eintr_wrappers.h"
 #include "net/base/net_util.h"
 #include "testing/platform_test.h"
 
 const int ListenSocketTester::kTestPort = 9999;
 
 static const int kReadBufSize = 1024;
 static const char* kHelloWorld = "HELLO, WORLD";
 static const int kMaxQueueSize = 20;
 static const char* kLoopback = "127.0.0.1";
 static const int kDefaultTimeoutMs = 5000;
@@ skipping 31 matching lines @@
   ASSERT_TRUE(NextAction(kDefaultTimeoutMs));
   ASSERT_FALSE(server_ == NULL);
   ASSERT_EQ(ACTION_LISTEN, last_action_.type());
 
   // verify the connect/accept and setup test_socket_
   test_socket_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   struct sockaddr_in client;
   client.sin_family = AF_INET;
   client.sin_addr.s_addr = inet_addr(kLoopback);
   client.sin_port = htons(kTestPort);
-  int ret = connect(test_socket_,
-                    reinterpret_cast<sockaddr*>(&client), sizeof(client));
+  int ret =
+      HANDLE_EINTR(connect(test_socket_, reinterpret_cast<sockaddr*>(&client),
+                           sizeof(client)));
   ASSERT_NE(ret, SOCKET_ERROR);
 
   net::SetNonBlocking(test_socket_);
   ASSERT_TRUE(NextAction(kDefaultTimeoutMs));
   ASSERT_EQ(ACTION_ACCEPT, last_action_.type());
 }
 
 void ListenSocketTester::TearDown() {
   // verify close
 #if defined(OS_WIN)
@@ skipping 75 matching lines @@
   pthread_mutex_unlock(&lock_);
   return true;
 #endif
 }
 
 int ListenSocketTester::ClearTestSocket() {
   char buf[kReadBufSize];
   int len_ret = 0;
   int time_out = 0;
   do {
-    int len = recv(test_socket_, buf, kReadBufSize, 0);
+    int len = HANDLE_EINTR(recv(test_socket_, buf, kReadBufSize, 0));
 #if defined(OS_WIN)
     if (len == SOCKET_ERROR) {
       int err = WSAGetLastError();
       if (err == WSAEWOULDBLOCK) {
 #elif defined(OS_POSIX)
     if (len == SOCKET_ERROR) {
       if (errno == EWOULDBLOCK || errno == EAGAIN) {
 #endif
         PlatformThread::Sleep(1);
         time_out++;
@@ skipping 44 matching lines @@
                                  const std::string& data) {
   ReportAction(ListenSocketTestAction(ACTION_READ, data));
 }
 
 void ListenSocketTester::DidClose(ListenSocket *sock) {
   ReportAction(ListenSocketTestAction(ACTION_CLOSE));
 }
 
 bool ListenSocketTester::Send(SOCKET sock, const std::string& str) {
   int len = static_cast<int>(str.length());
-  int send_len = send(sock, str.data(), len, 0);
+  int send_len = HANDLE_EINTR(send(sock, str.data(), len, 0));
   if (send_len == SOCKET_ERROR) {
     LOG(ERROR) << "send failed: " << errno;
     return false;
   } else if (send_len != len) {
     return false;
   }
   return true;
 }
 
 void ListenSocketTester::TestClientSend() {
@@ skipping 33 matching lines @@
   ASSERT_EQ(ACTION_SEND, last_action_.type());
   // TODO(erikkay): Without this sleep, the recv seems to fail a small amount
   // of the time.  I could fix this by making the socket blocking, but then
   // this test might hang in the case of errors.  It would be nice to do
   // something that felt more reliable here.
   PlatformThread::Sleep(10);  // sleep for 10ms
   const int buf_len = 200;
   char buf[buf_len+1];
   int recv_len;
   do {
-    recv_len = recv(test_socket_, buf, buf_len, 0);
+    recv_len = HANDLE_EINTR(recv(test_socket_, buf, buf_len, 0));
 #if defined(OS_POSIX)
   } while (recv_len == SOCKET_ERROR && errno == EINTR);
 #else
   } while (false);
 #endif
   ASSERT_NE(recv_len, SOCKET_ERROR);
   buf[recv_len] = 0;
   ASSERT_STREQ(buf, kHelloWorld);
 }
 
@@ skipping 23 matching lines @@
   tester_->TestClientSend();
 }
 
 TEST_F(ListenSocketTest, ClientSendLong) {
   tester_->TestClientSendLong();
 }
 
 TEST_F(ListenSocketTest, ServerSend) {
   tester_->TestServerSend();
 }