Update from https://crrev.com/327068

base/process/process_win.cc

 // Copyright (c) 2011 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/process.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 14 matching lines @@
       process_(handle) {
   CHECK_NE(handle, ::GetCurrentProcess());
 }
 
 Process::Process(RValue other)
     : is_current_process_(other.object->is_current_process_),
       process_(other.object->process_.Take()) {
   other.object->Close();
 }
 
+Process::~Process() {
+}
+
 Process& Process::operator=(RValue other) {
   if (this != other.object) {
     process_.Set(other.object->process_.Take());
     is_current_process_ = other.object->is_current_process_;
     other.object->Close();
   }
   return *this;
 }
 
 // static
@@ skipping 71 matching lines @@
 }
 
 void Process::Close() {
   is_current_process_ = false;
   if (!process_.IsValid())
     return;
 
   process_.Close();
 }
 
-bool Process::Terminate(int result_code, bool wait) const {
+bool Process::Terminate(int exit_code, bool wait) const {
   DCHECK(IsValid());
-  // TODO(rvargas) crbug/417532: Move the implementation here.
-  return KillProcess(Handle(), result_code, wait);
+  bool result = (::TerminateProcess(Handle(), exit_code) != FALSE);
+  if (result && wait) {
+    // The process may not end immediately due to pending I/O
+    if (::WaitForSingleObject(Handle(), 60 * 1000) != WAIT_OBJECT_0)
+      DPLOG(ERROR) << "Error waiting for process exit";
+  } else if (!result) {
+    DPLOG(ERROR) << "Unable to terminate process";
+  }
+  return result;
 }
 
 bool Process::WaitForExit(int* exit_code) {
   return WaitForExitWithTimeout(TimeDelta::FromMilliseconds(INFINITE),
                                 exit_code);
 }
 
 bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) {
   // Limit timeout to INFINITE.
   DWORD timeout_ms = saturated_cast<DWORD>(timeout.InMilliseconds());
@@ skipping 46 matching lines @@
 
   return (::SetPriorityClass(Handle(), priority) != 0);
 }
 
 int Process::GetPriority() const {
   DCHECK(IsValid());
   return ::GetPriorityClass(Handle());
 }
 
 }  // namespace base