Use TaskScheduler in EnsureProcessTerminated().

base/process/kill_win.cc

 // Copyright (c) 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 "base/process/kill.h"
 
 #include <windows.h>
 #include <io.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/process/memory.h"
 #include "base/process/process_iterator.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/win/object_watcher.h"
 
 namespace base {
 
 namespace {
 
 // Exit codes with special meanings on Windows.
 const DWORD kNormalTerminationExitCode = 0;
 const DWORD kDebuggerInactiveExitCode = 0xC0000354;
 const DWORD kKeyboardInterruptExitCode = 0xC000013A;
@@ skipping 158 matching lines @@
   if (WaitForProcessesToExit(executable_name, wait, filter))
     return true;
   KillProcesses(executable_name, exit_code, filter);
   return false;
 }
 
 void EnsureProcessTerminated(Process process) {
   DCHECK(!process.is_current());
 
   // If already signaled, then we are done!
-  if (WaitForSingleObject(process.Handle(), 0) == WAIT_OBJECT_0) {
+  if (WaitForSingleObject(process.Handle(), 0) == WAIT_OBJECT_0)
     return;
-  }
 
-  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, Bind(&TimerExpiredTask::TimedOut,
-                      Owned(new TimerExpiredTask(std::move(process)))),

[gab, 2017/01/09 17:36:38]

TimerExpiredTask::watcher_::task_runner_ is set to
SequencedTaskRunnerHandle::Get() and watcher_ calls things on that.

TimerExpiredTask isn't thread-safe so previously implicitly depended on that
being the same as the ThreadTaskRunnerHandle::Get() this task was posted to in
practice...

The simplest thing is probably to just use SequencedTaskRunnerHandle::Get() to
post this task (i.e. instead of modifying ObjectWatcher to allow specifying a
watch sequence)?

Another option since no one observes the notification anyways is to simplify
TimerExpiredTask into a single inline lambda that does 
[] (Process process) { if (WaitForSingleObject(process.Handle(), 0) ==
WAIT_OBJECT_0) return; process.Terminate(...); }

[fdoray, 2017/01/09 21:16:49]

Done.

+  PostDelayedTaskWithTraits(
+      FROM_HERE,
+      TaskTraits()
+          .WithPriority(TaskPriority::BACKGROUND)
+          .WithShutdownBehavior(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+      Bind(&TimerExpiredTask::TimedOut,
+           Owned(new TimerExpiredTask(std::move(process)))),

[gab, 2017/01/09 17:36:38]

Passed(MakeUnique(...)) instead of Owned(new ...) while you're here.

[fdoray, 2017/01/09 21:16:49]

n/a

       TimeDelta::FromMilliseconds(kWaitInterval));
 }
 
 }  // namespace base