Fix shutdown assert in new Mojo EDK.

mojo/edk/system/message_pipe_dispatcher.cc

 // Copyright 2015 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/edk/system/message_pipe_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_handle_utils.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
 #include "mojo/edk/embedder/platform_support.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/options_validation.h"
 #include "mojo/edk/system/transport_data.h"
 
 #if defined(OS_WIN)
 #include "mojo/edk/system/token_serializer_win.h"
 #endif
 
 namespace mojo {
 namespace edk {
 
-// TODO(jam): do more tests on using channel on same thread if it supports it (
-// i.e. with USE_CHROME_EDK and Windows). Also see ipc_channel_mojo.cc
-bool g_use_channel_on_io_thread_only = true;
-
 namespace {
 
 const size_t kInvalidMessagePipeHandleIndex = static_cast<size_t>(-1);
 
 struct MOJO_ALIGNAS(8) SerializedMessagePipeHandleDispatcher {
   // Could be |kInvalidMessagePipeHandleIndex| if the other endpoint of the MP
   // was closed.
   size_t platform_handle_index;
   bool write_error;
 
@@ skipping 87 matching lines @@
     std::vector<int>* serialized_read_fds,
     std::vector<int>* serialized_write_fds) {
   if (message_pipe.get().is_valid()) {
     channel_ = RawChannel::Create(message_pipe.Pass());
 
     // TODO(jam): It's probably cleaner to pass this in Init call.
     channel_->SetSerializedData(
         serialized_read_buffer, serialized_read_buffer_size,
         serialized_write_buffer, serialized_write_buffer_size,
         serialized_read_fds, serialized_write_fds);
-    if (g_use_channel_on_io_thread_only) {
-      internal::g_io_thread_task_runner->PostTask(
-          FROM_HERE, base::Bind(&MessagePipeDispatcher::InitOnIO, this));
-    } else {
-      InitOnIO();
-    }
-    // TODO(jam): optimize for when running on IO thread?
+    internal::g_io_thread_task_runner->PostTask(
+        FROM_HERE, base::Bind(&MessagePipeDispatcher::InitOnIO, this));
   }
 }
 
 void MessagePipeDispatcher::InitOnIO() {
   base::AutoLock locker(lock());
   calling_init_ = true;
   if (channel_)
     channel_->Init(this);
   calling_init_ = false;
 }
@@ skipping 196 matching lines @@
     : channel_(nullptr),
       serialized_(false),
       serialized_read_fds_length_(0u),
       serialized_write_fds_length_(0u),
       serialized_message_fds_length_(0u),
       calling_init_(false),
       write_error_(false) {
 }
 
 MessagePipeDispatcher::~MessagePipeDispatcher() {
-  // |Close()|/|CloseImplNoLock()| should have taken care of the channel.
-  DCHECK(!channel_);
+  // |Close()|/|CloseImplNoLock()| should have taken care of the channel. The
+  // exception is if they posted a task to run CloseOnIO but the IO thread shut
+  // down and so when it was deleting pending tasks it caused the last reference
+  // to destruct this object. In that case, safe to destroy the channel.
+  if (channel_ && internal::g_io_thread_task_runner->RunsTasksOnCurrentThread())
+    channel_->Shutdown();
+  else
+    DCHECK(!channel_);
 #if defined(OS_POSIX)
   ClosePlatformHandles(&serialized_fds_);
 #endif
 }
 
 void MessagePipeDispatcher::CancelAllAwakablesNoLock() {
   lock().AssertAcquired();
   awakable_list_.CancelAll();
 }
 
 void MessagePipeDispatcher::CloseImplNoLock() {
   lock().AssertAcquired();
-  if (g_use_channel_on_io_thread_only) {
-    internal::g_io_thread_task_runner->PostTask(
-        FROM_HERE, base::Bind(&MessagePipeDispatcher::CloseOnIO, this));
-  } else {
-    CloseOnIO();
-  }
+  internal::g_io_thread_task_runner->PostTask(
+      FROM_HERE, base::Bind(&MessagePipeDispatcher::CloseOnIO, this));
 }
 
 void MessagePipeDispatcher::SerializeInternal() {
   // We need to stop watching handle immediately, even though not on IO thread,
   // so that other messages aren't read after this.
   std::vector<int> serialized_read_fds, serialized_write_fds;
   if (channel_) {
     bool write_error = false;
 
     serialized_platform_handle_ = channel_->ReleaseHandle(
@@ skipping 465 matching lines @@
       LOG(WARNING) << "Enqueueing null dispatcher";
       dispatchers->push_back(nullptr);
     }
   }
   message->SetDispatchers(dispatchers.Pass());
   return MOJO_RESULT_OK;
 }
 
 }  // namespace edk
 }  // namespace mojo