When asserting that an event object is not signaled,...

net/socket/tcp_client_socket_win.cc

 // Copyright (c) 2010 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/socket/tcp_client_socket_win.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory_debug.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "net/base/address_list_net_log_param.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/base/winsock_init.h"
 
 namespace net {
 
 namespace {
 
+// Assert that the (manual-reset) event object is not signaled.
+void AssertEventNotSignaled(WSAEVENT hEvent) {
+  DWORD wait_rv = WaitForSingleObject(hEvent, 0);
+  if (wait_rv != WAIT_TIMEOUT) {
+    DWORD err = ERROR_SUCCESS;
+    if (wait_rv == WAIT_FAILED)
+      err = GetLastError();
+    CHECK(false);  // Crash.
+    // This LOG statement is unreachable since we have already crashed, but it
+    // should prevent the compiler from optimizing away the |wait_rv| and
+    // |err| variables so they appear nicely on the stack in crash dumps.
+    LOG(INFO) << "wait_rv=" << wait_rv << ", err=" << err;
+  }
+}
+
 // If the (manual-reset) event object is signaled, resets it and returns true.
 // Otherwise, does nothing and returns false.  Called after a Winsock function
 // succeeds synchronously
 //
 // Our testing shows that except in rare cases (when running inside QEMU),
 // the event object is already signaled at this point, so we call this method
 // to avoid a context switch in common cases.  This is just a performance
 // optimization.  The code still works if this function simply returns false.
 bool ResetEventIfSignaled(WSAEVENT hEvent) {
   // TODO(wtc): Remove the CHECKs after enough testing.
@@ skipping 465 matching lines @@
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!waiting_read_);
   DCHECK(!read_callback_);
   DCHECK(!core_->read_iobuffer_);
 
   buf_len = core_->ThrottleReadSize(buf_len);
 
   core_->read_buffer_.len = buf_len;
   core_->read_buffer_.buf = buf->data();
 
-  // TODO(wtc): Remove the CHECK after enough testing.
-  CHECK_EQ(static_cast<DWORD>(WAIT_TIMEOUT),
-           WaitForSingleObject(core_->read_overlapped_.hEvent, 0));
+  // TODO(wtc): Remove the assertion after enough testing.
+  AssertEventNotSignaled(core_->read_overlapped_.hEvent);
   DWORD num, flags = 0;
   int rv = WSARecv(socket_, &core_->read_buffer_, 1, &num, &flags,
                    &core_->read_overlapped_, NULL);
   if (rv == 0) {
     if (ResetEventIfSignaled(core_->read_overlapped_.hEvent)) {
       // 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.
@@ skipping 27 matching lines @@
   DCHECK_GT(buf_len, 0);
   DCHECK(!core_->write_iobuffer_);
 
   static StatsCounter reads("tcp.writes");
   reads.Increment();
 
   core_->write_buffer_.len = buf_len;
   core_->write_buffer_.buf = buf->data();
   core_->write_buffer_length_ = buf_len;
 
-  // TODO(wtc): Remove the CHECK after enough testing.
-  CHECK_EQ(static_cast<DWORD>(WAIT_TIMEOUT),
-           WaitForSingleObject(core_->write_overlapped_.hEvent, 0));
+  // TODO(wtc): Remove the assertion after enough testing.
+  AssertEventNotSignaled(core_->write_overlapped_.hEvent);
   DWORD num;
   int rv = WSASend(socket_, &core_->write_buffer_, 1, &num, 0,
                    &core_->write_overlapped_, NULL);
   if (rv == 0) {
     if (ResetEventIfSignaled(core_->write_overlapped_.hEvent)) {
       rv = static_cast<int>(num);
       if (rv > buf_len || rv < 0) {
         // It seems that some winsock interceptors report that more was written
         // than was available. Treat this as an error.  http://crbug.com/27870
         LOG(ERROR) << "Detected broken LSP: Asked to write " << buf_len
@@ skipping 194 matching lines @@
     } else {
       net_log_.AddEvent(NetLog::TYPE_SOCKET_BYTES_SENT,
                         new NetLogIntegerParameter("num_bytes", rv));
     }
   }
   core_->write_iobuffer_ = NULL;
   DoWriteCallback(rv);
 }
 
 }  // namespace net