Stay writable after partial socket writes.

webrtc/base/physicalsocketserver.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/base/physicalsocketserver.h"
@@ skipping 253 matching lines @@
     return -1;
   if (opt == OPT_DONTFRAGMENT) {
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
     value = (value) ? IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
 #endif
   }
   return ::setsockopt(s_, slevel, sopt, (SockOptArg)&value, sizeof(value));
 }
 
 int PhysicalSocket::Send(const void* pv, size_t cb) {
-  int sent = ::send(s_, reinterpret_cast<const char *>(pv), (int)cb,
+  int sent = DoSend(s_, reinterpret_cast<const char *>(pv),
+      static_cast<int>(cb),
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
       // Suppress SIGPIPE. Without this, attempting to send on a socket whose
       // other end is closed will result in a SIGPIPE signal being raised to
       // our process, which by default will terminate the process, which we
       // don't want. By specifying this flag, we'll just get the error EPIPE
       // instead and can handle the error gracefully.
       MSG_NOSIGNAL
 #else
       0
 #endif
       );
   UpdateLastError();
   MaybeRemapSendError();
   // We have seen minidumps where this may be false.
   ASSERT(sent <= static_cast<int>(cb));
-  if ((sent < 0) && IsBlockingError(GetError())) {
+  if ((sent > 0 && sent < static_cast<int>(cb)) ||
+      (sent < 0 && IsBlockingError(GetError()))) {
     enabled_events_ |= DE_WRITE;
   }
   return sent;
 }
 
 int PhysicalSocket::SendTo(const void* buffer,
                            size_t length,
                            const SocketAddress& addr) {
   sockaddr_storage saddr;
   size_t len = addr.ToSockAddrStorage(&saddr);
-  int sent = ::sendto(
+  int sent = DoSendTo(
       s_, static_cast<const char *>(buffer), static_cast<int>(length),
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
       // Suppress SIGPIPE. See above for explanation.
       MSG_NOSIGNAL,
 #else
       0,
 #endif
       reinterpret_cast<sockaddr*>(&saddr), static_cast<int>(len));
   UpdateLastError();
   MaybeRemapSendError();
   // We have seen minidumps where this may be false.
   ASSERT(sent <= static_cast<int>(length));
-  if ((sent < 0) && IsBlockingError(GetError())) {
+  if ((sent > 0 && sent < static_cast<int>(length)) ||
+      (sent < 0 && IsBlockingError(GetError()))) {
     enabled_events_ |= DE_WRITE;
   }
   return sent;
 }
 
 int PhysicalSocket::Recv(void* buffer, size_t length) {
   int received = ::recv(s_, static_cast<char*>(buffer),
                         static_cast<int>(length), 0);
   if ((received == 0) && (length != 0)) {
     // Note: on graceful shutdown, recv can return 0.  In this case, we
@@ skipping 142 matching lines @@
   ASSERT((0 <= value) && (value <= 65536));
   *mtu = value;
   return 0;
 #elif defined(__native_client__)
   // Most socket operations, including this, will fail in NaCl's sandbox.
   error_ = EACCES;
   return -1;
 #endif
 }
 
-
 SOCKET PhysicalSocket::DoAccept(SOCKET socket,
                                 sockaddr* addr,
                                 socklen_t* addrlen) {
   return ::accept(socket, addr, addrlen);
 }
 
+int PhysicalSocket::DoSend(SOCKET socket, const char* buf, int len, int flags) {
+  return ::send(socket, buf, len, flags);
+}
+
+int PhysicalSocket::DoSendTo(SOCKET socket,
+                             const char* buf,
+                             int len,
+                             int flags,
+                             const struct sockaddr* dest_addr,
+                             socklen_t addrlen) {
+  return ::sendto(socket, buf, len, flags, dest_addr, addrlen);
+}
+
 void PhysicalSocket::OnResolveResult(AsyncResolverInterface* resolver) {
   if (resolver != resolver_) {
     return;
   }
 
   int error = resolver_->GetError();
   if (error == 0) {
     error = DoConnect(resolver_->address());
   } else {
     Close();
@@ skipping 1114 matching lines @@
        break;
     }
   }
 
   // Done
   return true;
 }
 #endif  // WEBRTC_WIN
 
 }  // namespace rtc