Always leak the Mojo parent pipe handle on child process shutdown.

mojo/edk/system/channel_win.cc

 // Copyright 2016 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/channel.h"
 
 #include <stdint.h>
 #include <windows.h>
 
 #include <algorithm>
@@ skipping 98 matching lines @@
         reject_writes_ = write_error = true;
     }
     if (write_error) {
       // Do not synchronously invoke OnError(). Write() may have been called by
       // the delegate and we don't want to re-enter it.
       io_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(&ChannelWin::OnError, this));
     }
   }
 
+  void LeakHandle() override {
+    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+    leak_handle_ = true;
+  }
+
   bool GetReadPlatformHandles(
       size_t num_handles,
       const void* extra_header,
       size_t extra_header_size,
       ScopedPlatformHandleVectorPtr* handles) override {
     if (num_handles > std::numeric_limits<uint16_t>::max())
       return false;
     using HandleEntry = Channel::Message::HandleEntry;
     size_t handles_size = sizeof(HandleEntry) * num_handles;
     if (handles_size > extra_header_size)
@@ skipping 55 matching lines @@
     ReadMore(0);
   }
 
   void ShutDownOnIOThread() {
     base::MessageLoop::current()->RemoveDestructionObserver(this);
 
     // BUG(crbug.com/583525): This function is expected to be called once, and
     // |handle_| should be valid at this point.
     CHECK(handle_.is_valid());
     CancelIo(handle_.get().handle);
+    if (leak_handle_)
+      ignore_result(handle_.release());
     handle_.reset();
 
     // May destroy the |this| if it was the last reference.
     self_ = nullptr;
   }
 
   // base::MessageLoop::DestructionObserver:
   void WillDestroyCurrentMessageLoop() override {
     DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
     if (self_)
@@ skipping 121 matching lines @@
   // Protects |reject_writes_| and |outgoing_messages_|.
   base::Lock write_lock_;
 
   bool delay_writes_ = true;
 
   bool reject_writes_ = false;
   std::deque<MessageView> outgoing_messages_;
 
   bool wait_for_connect_;
 
+  bool leak_handle_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(ChannelWin);
 };
 
 }  // namespace
 
 // static
 scoped_refptr<Channel> Channel::Create(
     Delegate* delegate,
     ScopedPlatformHandle platform_handle,
     scoped_refptr<base::TaskRunner> io_task_runner) {
   return new ChannelWin(delegate, std::move(platform_handle), io_task_runner);
 }
 
 }  // namespace edk
 }  // namespace mojo