Fixing a hang in the native messaging hosts on Windows

remoting/host/native_messaging/native_messaging_reader.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 "remoting/host/native_messaging/native_messaging_reader.h"
 
-#include <stdint.h>
-
+#include <cstdint>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
-#include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+
+#include "base/threading/platform_thread.h"
+#include "base/win/scoped_handle.h"
+#endif  // defined(OS_WIN)
 
 namespace {
 
 // uint32_t is specified in the protocol as the type for the message header.
 typedef uint32_t MessageLengthType;
 
 const int kMessageHeaderSize = sizeof(MessageLengthType);
 
 // Limit the size of received messages, to avoid excessive memory-allocation in
 // this process, and potential overflow issues when casting to a signed 32-bit
@@ skipping 97 matching lines @@
 void NativeMessagingReader::Core::NotifyEof() {
   DCHECK(read_task_runner_->RunsTasksOnCurrentThread());
   caller_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&NativeMessagingReader::InvokeEofCallback, reader_));
 }
 
 NativeMessagingReader::NativeMessagingReader(base::File file)
     : reader_thread_("Reader"),
       weak_factory_(this) {
-  reader_thread_.Start();
+  reader_thread_.StartWithOptions(
+      base::Thread::Options(base::MessageLoop::TYPE_IO, /*size=*/0));
+
   read_task_runner_ = reader_thread_.task_runner();
   core_.reset(new Core(std::move(file), base::ThreadTaskRunnerHandle::Get(),
                        read_task_runner_, weak_factory_.GetWeakPtr()));
 }
 
 NativeMessagingReader::~NativeMessagingReader() {
   read_task_runner_->DeleteSoon(FROM_HERE, core_.release());
+
+#if defined(OS_WIN)
+  // The ReadMessage() method uses a blocking read (on all platforms) which
+  // cause a deadlock if the owning thread attempts to destroy this object
+  // while there is a read operation pending.
+  // On POSIX platforms, closing the write end of the pipe causes the Chrome
+  // process to close the read end so that this class can be cleaned up.
+  // On Windows, closing the write end of the pipe does nothing as the parent
+  // process is cmd.exe which doesn't care.  Thus, the read end of the pipe
+  // remains open, the read operation is blocked, and we hang in the d'tor.
+  // Canceling the pending I/O here prevents the hang on Windows and isn't
+  // needed for POSIX since it works correctly.
+  base::PlatformThreadId thread_id = reader_thread_.GetThreadId();
+  base::win::ScopedHandle thread_handle(
+      OpenThread(THREAD_TERMINATE, /*bInheritHandle=*/false, thread_id));
+  if (!CancelSynchronousIo(thread_handle.Get())) {
+    // ERROR_NOT_FOUND means there were no pending IO requests so don't treat
+    // that result as an error.
+    if (GetLastError() != ERROR_NOT_FOUND) {
+      PLOG(ERROR) << "CancelSynchronousIo() failed";
+    }
+  }
+#endif  // defined(OS_WIN)
 }
 
 void NativeMessagingReader::Start(MessageCallback message_callback,
                                   base::Closure eof_callback) {
   message_callback_ = message_callback;
   eof_callback_ = eof_callback;
 
   // base::Unretained is safe since |core_| is only deleted via the
   // DeleteSoon task which is posted from this class's dtor.
   read_task_runner_->PostTask(
       FROM_HERE, base::Bind(&NativeMessagingReader::Core::ReadMessage,
                             base::Unretained(core_.get())));
 }
 
 void NativeMessagingReader::InvokeMessageCallback(
     std::unique_ptr<base::Value> message) {
   message_callback_.Run(std::move(message));
 }
 
 void NativeMessagingReader::InvokeEofCallback() {
   eof_callback_.Run();
 }
 
 }  // namespace remoting