Make the CancellableSyncSocket non-blocking on Send, and blocking on Receive

base/sync_socket_win.cc

 // Copyright (c) 2012 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 "base/sync_socket.h"
 
 #include "base/logging.h"
 #include "base/win/scoped_handle.h"
 
 namespace base {
@@ skipping 128 matching lines @@
           socket->Close();
           count = 0;
           break;
         } else {
           GetOverlappedResult(file, &ol, &len, TRUE);
         }
       } else {
         return (0 < count) ? count : 0;
       }
     }
+
+    // Quit the operation if we can't write/read anymore.
+    if (len == 0)

[tommi (sloooow) - chröme, 2012/04/13 10:28:10]

do we actually hit this?
I would have thought that ok would be false and GLE would be something other
than ERROR_IO_PENDING.

[no longer working on chromium, 2012/04/13 11:50:50]

Yes, when the buffer is full, the operation returns OK as true but len = 0.

+      break;
+
     count += len;
   }
   return count;
 }
 
 }  // namespace
 
 const SyncSocket::Handle SyncSocket::kInvalidHandle = INVALID_HANDLE_VALUE;
 
 SyncSocket::SyncSocket() : handle_(kInvalidHandle) {}
@@ skipping 68 matching lines @@
   return true;
 }
 
 bool CancelableSyncSocket::Close() {
   bool ret = SyncSocket::Close();
   shutdown_event_.Reset();
   return ret;
 }
 
 size_t CancelableSyncSocket::Send(const void* buffer, size_t length) {
+  DWORD state = 0;
+  if (GetNamedPipeHandleState(handle_, &state, NULL, NULL, NULL, NULL, 0)) {
+    // Set the socket to non-blocking mode if it is blocking on sending.
+    if ((state & PIPE_NOWAIT) == 0) {
+      state = PIPE_NOWAIT;
+      SetNamedPipeHandleState(handle_, &state, NULL, NULL);
+    }
+  }
   return CancelableFileOperation(&WriteFile, handle_,
       reinterpret_cast<const char*>(buffer), length, &file_operation_,
       &shutdown_event_, this);
 }
 
 size_t CancelableSyncSocket::Receive(void* buffer, size_t length) {
+  DWORD state = 0;
+  if (GetNamedPipeHandleState(handle_, &state, NULL, NULL, NULL, NULL, 0)) {

[tommi (sloooow) - chröme, 2012/04/13 10:28:10]

do this inside Send() after the file operation and not here.

[no longer working on chromium, 2012/04/13 11:50:50]

Done.

+    // Set the socket to blocking mode if it is non-blocking on receiving.
+    if ((state & PIPE_WAIT) == 0) {
+      state = PIPE_WAIT;
+      SetNamedPipeHandleState(handle_, &state, NULL, NULL);
+    }
+  }
   return CancelableFileOperation(&ReadFile, handle_,
       reinterpret_cast<char*>(buffer), length, &file_operation_,
       &shutdown_event_, this);
 }
 
 // static
 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a,
                                       CancelableSyncSocket* socket_b) {
   return CreatePairImpl(&socket_a->handle_, &socket_b->handle_, true);
 }
 
 
 }  // namespace base