Brushed up listen socket:

net/base/listen_socket.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 "build/build_config.h"
 
 #if defined(OS_WIN)
 // winsock2.h must be included first in order to ensure it is included before
 // windows.h.
 #include <winsock2.h>
@@ skipping 13 matching lines @@
 #include "base/eintr_wrapper.h"
 #include "net/base/net_util.h"
 #include "net/base/listen_socket.h"
 
 #if defined(OS_WIN)
 typedef int socklen_t;
 #endif  // defined(OS_WIN)
 
 namespace {
 
-const int kReadBufSize = 200;
+const int kReadBufSize = 4096;
 
 }  // namespace
 
 #if defined(OS_WIN)
 const SOCKET ListenSocket::kInvalidSocket = INVALID_SOCKET;
 const int ListenSocket::kSocketError = SOCKET_ERROR;
 #elif defined(OS_POSIX)
 const SOCKET ListenSocket::kInvalidSocket = -1;
 const int ListenSocket::kSocketError = -1;
 #endif
@@ skipping 108 matching lines @@
     } else if (len == 0) {
       // In Windows, Close() is called by OnObjectSignaled.  In POSIX, we need
       // to call it here.
 #if defined(OS_POSIX)
       Close();
 #endif
     } else {
       // TODO(ibrar): maybe change DidRead to take a length instead
       DCHECK(len > 0 && len <= kReadBufSize);
       buf[len] = 0;  // already create a buffer with +1 length
-      socket_delegate_->DidRead(this, buf);
+      socket_delegate_->DidRead(this, buf, len);
     }
   } while (len == kReadBufSize);
 }
 
 void ListenSocket::CloseSocket(SOCKET s) {
   if (s && s != kInvalidSocket) {
     UnwatchSocket();
 #if defined(OS_WIN)
     closesocket(s);
 #elif defined(OS_POSIX)
@@ skipping 25 matching lines @@
   watcher_.StartWatching(socket_event_, this);
 #elif defined(OS_POSIX)
   // Implicitly calls StartWatchingFileDescriptor().
   MessageLoopForIO::current()->WatchFileDescriptor(
       socket_, true, MessageLoopForIO::WATCH_READ, &watcher_, this);
   wait_state_ = state;
 #endif
 }
 
 void ListenSocket::SendInternal(const char* bytes, int len) {
-  int sent = HANDLE_EINTR(send(socket_, bytes, len, 0));
-  if (sent == kSocketError) {
+  char* send_buf = const_cast<char *>(bytes);
+  int len_left = len;
+  while (true) {
+    int sent = HANDLE_EINTR(send(socket_, send_buf, len_left, 0));
+    if (sent == len_left) {  // A shortcut to avoid extraneous checks.
+      break;
+    }
+    if (sent == kSocketError) {
 #if defined(OS_WIN)
-  int err = WSAGetLastError();
-  if (err == WSAEWOULDBLOCK) {
+      if (WSAGetLastError() != WSAEWOULDBLOCK) {
+        LOG(ERROR) << "send failed: WSAGetLastError()==" << WSAGetLastError();
 #elif defined(OS_POSIX)
-    if (errno == EWOULDBLOCK || errno == EAGAIN) {
+      if (errno != EWOULDBLOCK && errno != EAGAIN) {
+        LOG(ERROR) << "send failed: errno==" << errno;
 #endif
-    // TODO(ibrar): there should be logic here to handle this because
-    // it is not an error
+        break;
+      }
+      // Otherwise we would block, and now we have to wait for a retry.
+      // Fall through to PlatformThread::YieldCurrentThread()
+    } else {
+      // sent != len_left according to the shortcut above.
+      // Shift the buffer start and send the remainder after a short while.
+      send_buf += sent;
+      len_left -= sent;
     }
-  } else if (sent != len) {
-    LOG(ERROR) << "send failed: ";
+    PlatformThread::YieldCurrentThread();
   }
 }
 
 void ListenSocket::Send(const char* bytes, int len, bool append_linefeed) {
   SendInternal(bytes, len);
   if (append_linefeed) {
     SendInternal("\r\n", 2);
   }
 }
 
@@ skipping 65 matching lines @@
   }
 }
 
 void ListenSocket::OnFileCanWriteWithoutBlocking(int fd) {
   // MessagePumpLibevent callback, we don't listen for write events
   // so we shouldn't ever reach here.
   NOTREACHED();
 }
 
 #endif