IPC: Add more debug logic (crash tracking)

ipc/ipc_channel_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 "ipc/ipc_channel_win.h"
 
 #include <windows.h>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 45 matching lines @@
 
 ChannelWin::ChannelWin(const IPC::ChannelHandle &channel_handle,
                        Mode mode, Listener* listener)
     : ChannelReader(listener),
       input_state_(this),
       output_state_(this),
       pipe_(INVALID_HANDLE_VALUE),
       peer_pid_(base::kNullProcessId),
       waiting_connect_(mode & MODE_SERVER_FLAG),
       processing_incoming_(false),
-      weak_factory_(this),
       validate_client_(false),
+      writing_(false),
       debug_flags_(0),
-      client_secret_(0) {
+      client_secret_(0),
+      weak_factory_(this) {
   CreatePipe(channel_handle, mode);
 }
 
 ChannelWin::~ChannelWin() {
   Close();
 }
 
 void ChannelWin::Close() {
   if (thread_check_.get()) {
     DCHECK(thread_check_->CalledOnValidThread());
@@ skipping 339 matching lines @@
   if (output_queue_.empty())
     return true;
 
   if (INVALID_HANDLE_VALUE == pipe_)
     return false;
 
   // Write to pipe...
   Message* m = output_queue_.front();
   DCHECK(m->size() <= INT_MAX);
   debug_flags_ |= WRITE_MSG;
+  CHECK(!writing_);
+  writing_ = true;
   BOOL ok = WriteFile(pipe_,
                       m->data(),
                       static_cast<int>(m->size()),
                       &bytes_written,
                       &output_state_.context.overlapped);
   if (!ok) {
     DWORD err = GetLastError();
     if (err == ERROR_IO_PENDING) {
       output_state_.is_pending = true;
 
       DVLOG(2) << "sent pending message @" << m << " on channel @" << this
                << " with type " << m->type();
 

[cpu_(ooo_6.6-7.5), 2014/07/29 19:47:20]

ERROR_IO_PENDING is the normal case, right?

so writing_ will be true and a second write could come along.. then 430 will
fire.

I am probably not understanding how this works then?

[rvargas (doing something else), 2014/07/29 20:36:21]

Because we are reusing the same overlapped structure, we cannot issue a second
write until the first one completes. When the first one completes, OnIoCompleted
will be called, and line 507 clears the flag for the next write.

       return true;
     }
+    writing_ = false;
     LOG(ERROR) << "pipe error: " << err;
     return false;
   }
 
   DVLOG(2) << "sent message @" << m << " on channel @" << this
            << " with type " << m->type();
 
   output_state_.is_pending = true;
   return true;
 }
@@ skipping 37 matching lines @@
         ok = AsyncReadComplete(bytes_transfered);
     } else {
       DCHECK(!bytes_transfered);
     }
 
     // Request more data.
     if (ok)
       ok = ProcessIncomingMessages();
   } else {
     DCHECK(context == &output_state_.context);
+    CHECK(writing_);
+    CHECK(output_state_.is_pending);
+    writing_ = false;
     debug_flags_ |= WRITE_COMPLETED;
     if (debug_flags_ & WAIT_FOR_WRITE) {
       CHECK(!(debug_flags_ & WAIT_FOR_WRITE_COMPLETE));
       debug_flags_ |= WAIT_FOR_WRITE_COMPLETE;
     }
     ok = ProcessOutgoingMessages(context, bytes_transfered);
   }
   if (!ok && INVALID_HANDLE_VALUE != pipe_) {
     // We don't want to re-enter Close().
     Close();
@@ skipping 30 matching lines @@
   int secret;
   do {  // Guarantee we get a non-zero value.
     secret = base::RandInt(0, std::numeric_limits<int>::max());
   } while (secret == 0);
 
   id.append(GenerateUniqueRandomChannelID());
   return id.append(base::StringPrintf("\\%d", secret));
 }
 
 }  // namespace IPC