Remove ShutdownIPCSupportAndWaitForNoChannels.

mojo/edk/system/raw_channel_win.cc

 // Copyright 2013 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/raw_channel.h"
 
 #include <windows.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 106 matching lines @@
   // It manages its own destruction. Destruction happens on the I/O thread when
   // all the following conditions are satisfied:
   //   - |DetachFromOwnerNoLock()| has been called;
   //   - there is no pending read;
   //   - there is no pending write.
   class RawChannelIOHandler {
    public:
     RawChannelIOHandler(RawChannelWin* owner,
                         ScopedPlatformHandle handle)
         : handle_(handle.Pass()),
+          io_task_runner_(internal::g_io_thread_task_runner),
           owner_(owner),
           suppress_self_destruct_(false),
           pending_read_(false),
           pending_write_(false),
           platform_handles_written_(0),
           read_event_(CreateEvent(NULL, FALSE, FALSE, NULL)),
           write_event_(CreateEvent(NULL, FALSE, FALSE, NULL)),
           read_wait_object_(NULL),
           write_wait_object_(NULL),
           read_event_signalled_(false),
@@ skipping 321 matching lines @@
       if (ShouldSelfDestruct())
         delete this;
     }
 
     static void CALLBACK ReadCompleted(void* param, BOOLEAN timed_out) {
       DCHECK(!timed_out);
       // The destructor blocks on any callbacks that are in flight, so we know
       // that that is always a pointer to a valid RawChannelIOHandler.
       RawChannelIOHandler* that = static_cast<RawChannelIOHandler*>(param);
       that->read_event_signalled_ = true;
-      internal::g_io_thread_task_runner->PostTask(
+      that->io_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&RawChannelIOHandler::OnObjectSignaled,
                      that->this_weakptr_, that->read_event_.Get()));
     }
 
     static void CALLBACK WriteCompleted(void* param, BOOLEAN timed_out) {
       DCHECK(!timed_out);
       // The destructor blocks on any callbacks that are in flight, so we know
       // that that is always a pointer to a valid RawChannelIOHandler.
       RawChannelIOHandler* that = static_cast<RawChannelIOHandler*>(param);
       that->write_event_signalled_ = true;
-      internal::g_io_thread_task_runner->PostTask(
+      that->io_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&RawChannelIOHandler::OnObjectSignaled,
                      that->this_weakptr_, that->write_event_.Get()));
     }
 
     ScopedPlatformHandle handle_;
 
+    // We cache this because ReadCompleted and WriteCompleted might get fired
+    // after ShutdownIPCSupport is called.
+    scoped_refptr<base::TaskRunner> io_task_runner_;
+
     // |owner_| is reset on the I/O thread under |owner_->write_lock()|.
     // Therefore, it may be used on any thread under lock; or on the I/O thread
     // without locking.
     RawChannelWin* owner_;
 
     // The following members must be used on the I/O thread.
     scoped_ptr<ReadBuffer> preserved_read_buffer_after_detach_;
     scoped_ptr<WriteBuffer> preserved_write_buffer_after_detach_;
     bool suppress_self_destruct_;
 
@@ skipping 270 matching lines @@
   } else {
     // This is to catch developer errors. Let them be caught on Vista and above,
     // i.e. no point in implementing this on XP since support for it will be
     // removed in early 2016.
     return false;
   }
 }
 
 }  // namespace edk
 }  // namespace mojo