Mojo: Add RawChannel tests for calling Shutdown() from OnReadMessage()/OnFatalError().

mojo/system/raw_channel.cc

 // Copyright 2014 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 "mojo/system/raw_channel.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 74 matching lines @@
 size_t RawChannel::WriteBuffer::GetTotalBytesToWrite() const {
   if (message_queue_.empty())
     return 0;
 
   MessageInTransit* message = message_queue_.front();
   DCHECK_LT(offset_, message->total_size());
   return message->total_size() - offset_;
 }
 
 RawChannel::RawChannel()
-    : delegate_(NULL),
-      message_loop_for_io_(NULL),
+    : message_loop_for_io_(NULL),
+      delegate_(NULL),
       read_stopped_(false),
       write_stopped_(false),
       weak_ptr_factory_(this) {
 }
 
 RawChannel::~RawChannel() {
   DCHECK(!read_buffer_);
   DCHECK(!write_buffer_);
 
   // No need to take the |write_lock_| here -- if there are still weak pointers
@@ skipping 26 matching lines @@
 }
 
 void RawChannel::Shutdown() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
 
   base::AutoLock locker(write_lock_);
 
   LOG_IF(WARNING, !write_buffer_->message_queue_.empty())
       << "Shutting down RawChannel with write buffer nonempty";
 
-  weak_ptr_factory_.InvalidateWeakPtrs();
-
+  delegate_ = NULL;

[sky, 2014/04/24 19:58:28]

Add a comment as to why it's important to NULL out the delegate here.

   read_stopped_ = true;
   write_stopped_ = true;
+  weak_ptr_factory_.InvalidateWeakPtrs();
 
   OnShutdownNoLock(read_buffer_.Pass(), write_buffer_.Pass());
 }
 
 // Reminder: This must be thread-safe.
 bool RawChannel::WriteMessage(scoped_ptr<MessageInTransit> message) {
   DCHECK(message);
 
   // TODO(vtl)
   if (message->has_platform_handles()) {
@@ skipping 90 matching lines @@
     while (remaining_bytes > 0 &&
            MessageInTransit::GetNextMessageSize(
                &read_buffer_->buffer_[read_buffer_start], remaining_bytes,
                &message_size) &&
            remaining_bytes >= message_size) {
       MessageInTransit::View
           message_view(message_size, &read_buffer_->buffer_[read_buffer_start]);
       DCHECK_EQ(message_view.total_size(), message_size);
 
       // Dispatch the message.
+      DCHECK(delegate_);
       delegate_->OnReadMessage(message_view);
       if (read_stopped_) {
         // |Shutdown()| was called in |OnReadMessage()|.
         // TODO(vtl): Add test for this case.
         return;
       }
       did_dispatch_message = true;
 
       // Update our state.
       read_buffer_start += message_size;
@@ skipping 54 matching lines @@
     did_fail = !OnWriteCompletedNoLock(result, bytes_written);
   }
 
   if (did_fail)
     CallOnFatalError(Delegate::FATAL_ERROR_FAILED_WRITE);
 }
 
 void RawChannel::CallOnFatalError(Delegate::FatalError fatal_error) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
   // TODO(vtl): Add a "write_lock_.AssertNotAcquired()"?
-  delegate_->OnFatalError(fatal_error);
+  if (delegate_)
+    delegate_->OnFatalError(fatal_error);
 }
 
 bool RawChannel::OnWriteCompletedNoLock(bool result, size_t bytes_written) {
   write_lock_.AssertAcquired();
 
   DCHECK(!write_stopped_);
   DCHECK(!write_buffer_->message_queue_.empty());
 
   if (result) {
     if (bytes_written < write_buffer_->GetTotalBytesToWrite()) {
@@ skipping 16 matching lines @@
   }
 
   write_stopped_ = true;
   STLDeleteElements(&write_buffer_->message_queue_);
   write_buffer_->offset_ = 0;
   return false;
 }
 
 }  // namespace system
 }  // namespace mojo