In rare cases (when running inside QEMU), the event...

net/base/tcp_client_socket_win.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.h"
 
 #include "base/memory_debug.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "net/base/net_errors.h"
@@ skipping 70 matching lines @@
     return rv;
 
   // WSACreateEvent creates a manual-reset event object.
   overlapped_.hEvent = WSACreateEvent();
   // WSAEventSelect sets the socket to non-blocking mode as a side effect.
   // Our connect() and recv() calls require that the socket be non-blocking.
   WSAEventSelect(socket_, overlapped_.hEvent, FD_CONNECT);
 
   if (!connect(socket_, ai->ai_addr, static_cast<int>(ai->ai_addrlen))) {
     // Connected without waiting!
-    CHECK(WaitForSingleObject(overlapped_.hEvent, 0) == WAIT_OBJECT_0);
-    BOOL ok = WSAResetEvent(overlapped_.hEvent);
-    CHECK(ok);
+    WaitForAndResetEvent();
     TRACE_EVENT_END("socket.connect", this, "");
     return OK;
   }
 
   DWORD err = WSAGetLastError();
   if (err != WSAEWOULDBLOCK) {
     LOG(ERROR) << "connect failed: " << err;
     return MapWinsockError(err);
   }
 
@@ skipping 59 matching lines @@
                           int buf_len,
                           CompletionCallback* callback) {
   DCHECK(socket_ != INVALID_SOCKET);
   DCHECK(wait_state_ == NOT_WAITING);
   DCHECK(!callback_);
 
   buffer_.len = buf_len;
   buffer_.buf = buf;
 
   TRACE_EVENT_BEGIN("socket.read", this, "");
-  // TODO(wtc): Remove the CHECKs after enough testing.
+  // TODO(wtc): Remove the CHECK after enough testing.
   CHECK(WaitForSingleObject(overlapped_.hEvent, 0) == WAIT_TIMEOUT);
   DWORD num, flags = 0;
   int rv = WSARecv(socket_, &buffer_, 1, &num, &flags, &overlapped_, NULL);
   if (rv == 0) {
-    CHECK(WaitForSingleObject(overlapped_.hEvent, 0) == WAIT_OBJECT_0);
-    BOOL ok = WSAResetEvent(overlapped_.hEvent);
-    CHECK(ok);
+    WaitForAndResetEvent();
     TRACE_EVENT_END("socket.read", this, StringPrintf("%d bytes", num));
 
     // Because of how WSARecv fills memory when used asynchronously, Purify
     // isn't able to detect that it's been initialized, so it scans for 0xcd
     // in the buffer and reports UMRs (uninitialized memory reads) for those
     // individual bytes. We override that in PURIFY builds to avoid the false
     // error reports.
     // See bug 5297.
     base::MemoryDebug::MarkAsInitialized(buffer_.buf, num);
     return static_cast<int>(num);
   }
   int err = WSAGetLastError();
   if (err == WSA_IO_PENDING) {
     watcher_.StartWatching(overlapped_.hEvent, this);
     wait_state_ = WAITING_READ;
     callback_ = callback;
     return ERR_IO_PENDING;
   }
   return MapWinsockError(err);
 }
 
-// TODO(wtc): This temporary function is intended to determine the return
-// value and error code of the WaitForSingleObject call in
-// TCPClientSocket::Write if it doesn't return the expected WAIT_OBJECT_0.
-// See http://crbug.com/6500.
-static void CrashBug6500(DWORD wait_rv, DWORD wait_error) {
-  // wait_error is meaningful only if wait_rv is WAIT_FAILED.
-  CHECK(false) << wait_rv << wait_error;
-}
-
 int TCPClientSocket::Write(const char* buf,
                            int buf_len,
                            CompletionCallback* callback) {
   DCHECK(socket_ != INVALID_SOCKET);
   DCHECK(wait_state_ == NOT_WAITING);
   DCHECK(!callback_);
 
   buffer_.len = buf_len;
   buffer_.buf = const_cast<char*>(buf);
 
   TRACE_EVENT_BEGIN("socket.write", this, "");
-  // TODO(wtc): Remove the CHECKs after enough testing.
+  // TODO(wtc): Remove the CHECK after enough testing.
   CHECK(WaitForSingleObject(overlapped_.hEvent, 0) == WAIT_TIMEOUT);
   DWORD num;
   int rv = WSASend(socket_, &buffer_, 1, &num, 0, &overlapped_, NULL);
   if (rv == 0) {
-    DWORD wait_rv = WaitForSingleObject(overlapped_.hEvent, 0);
-    if (wait_rv != WAIT_OBJECT_0) {
-      DWORD wait_error = GetLastError();
-      CrashBug6500(wait_rv, wait_error);
-    }
-    BOOL ok = WSAResetEvent(overlapped_.hEvent);
-    CHECK(ok);
+    WaitForAndResetEvent();
     TRACE_EVENT_END("socket.write", this, StringPrintf("%d bytes", num));
     return static_cast<int>(num);
   }
   int err = WSAGetLastError();
   if (err == WSA_IO_PENDING) {
     watcher_.StartWatching(overlapped_.hEvent, this);
     wait_state_ = WAITING_WRITE;
     callback_ = callback;
     return ERR_IO_PENDING;
   }
@@ skipping 128 matching lines @@
     case WAITING_READ:
     case WAITING_WRITE:
       DidCompleteIO();
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
+void TCPClientSocket::WaitForAndResetEvent() {
+  // TODO(wtc): Remove the CHECKs after enough testing.
+  DWORD wait_rv = WaitForSingleObject(overlapped_.hEvent, INFINITE);
+  CHECK(wait_rv == WAIT_OBJECT_0);
+  BOOL ok = WSAResetEvent(overlapped_.hEvent);
+  CHECK(ok);
+}
+
 }  // namespace net