Don't leak the WatcherThreadManager background thread.

mojo/edk/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/edk/system/raw_channel.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 204 matching lines @@
 }
 
 void RawChannel::LazyInitialize() {
   read_lock_.AssertAcquired();
   write_lock_.AssertAcquired();
   DCHECK(internal::g_io_thread_task_runner->RunsTasksOnCurrentThread());
   if (initialized_)
     return;
   initialized_ = true;
   internal::ChannelStarted();
+  base::MessageLoop::current()->AddDestructionObserver(this);
 
   OnInit();
 
   if (read_buffer_->num_valid_bytes_) {
     // We had serialized read buffer data through SetSerializedData call.
     // Make sure we read messages out of it now, otherwise the delegate won't
     // get notified if no other data gets written to the pipe.
     // Although this means that we can call back synchronously into the caller,
     // that's easier than posting a task to do this. That is because if we post
     // a task, a pending read could have started and we wouldn't be able to move
@@ skipping 44 matching lines @@
   // doesn't apply when 1) we don't have a handle (for obvious reasons),
   // 2) we have a read or write error before (doesn't matter which), or 3) when
   // there are no pending messages to be written.
   if (!IsHandleValid() || error_occurred_ || empty) {
     {
       base::AutoLock read_locker(read_lock_);
       base::AutoLock locker(write_lock_);
       OnShutdownNoLock(read_buffer_.Pass(), write_buffer_.Pass());
     }
 
-    if (initialized_)
+    if (initialized_) {
       internal::ChannelShutdown();
+      base::MessageLoop::current()->RemoveDestructionObserver(this);
+    }
     delete this;
     return;
   }
 
   base::AutoLock read_locker(read_lock_);
   base::AutoLock locker(write_lock_);
   DCHECK(read_buffer_->IsEmpty()) <<
       "RawChannel::Shutdown called but there is pending data to be read";
 
   write_stopped_ = true;
@@ skipping 407 matching lines @@
   if (write_buffer_->data_offset_ >= message->total_size()) {
     // Complete write.
     CHECK_EQ(write_buffer_->data_offset_, message->total_size());
     write_buffer_->message_queue_.DiscardMessage();
     write_buffer_->platform_handles_offset_ = 0;
     write_buffer_->data_offset_ = 0;
   }
 }
 
 void RawChannel::CallOnReadCompleted(IOResult io_result, size_t bytes_read) {
-  base::AutoLock locker(read_lock());
+  base::AutoLock locker(read_lock_);
   OnReadCompletedNoLock(io_result, bytes_read);
 }
 
+void RawChannel::WillDestroyCurrentMessageLoop() {
+  base::AutoLock locker(read_lock_);
+  OnReadCompletedNoLock(IO_FAILED_SHUTDOWN, 0);
+}
+
 }  // namespace edk
 }  // namespace mojo