Chromium roll (https://codereview.chromium.org/976353002)

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 <io.h>
 #include <windows.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_iterator.h"
-#include "base/profiler/scoped_tracker.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 38 matching lines @@
 TimerExpiredTask::~TimerExpiredTask() {
   TimedOut();
 }
 
 void TimerExpiredTask::TimedOut() {
   if (process_.IsValid())
     KillProcess();
 }
 
 void TimerExpiredTask::OnObjectSignaled(HANDLE object) {
-  // TODO(vadimt): Remove ScopedTracker below once crbug.com/418183 is fixed.
-  tracked_objects::ScopedTracker tracking_profile(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "418183 TimerExpiredTask::OnObjectSignaled"));
-
   process_.Close();
 }
 
 void TimerExpiredTask::KillProcess() {
   // Stop watching the process handle since we're killing it.
   watcher_.StopWatching();
 
   // OK, time to get frisky.  We don't actually care when the process
   // terminates.  We just care that it eventually terminates, and that's what
   // TerminateProcess should do for us. Don't check for the result code since
@@ skipping 11 matching lines @@
   if (result && wait) {
     // The process may not end immediately due to pending I/O
     if (WAIT_OBJECT_0 != WaitForSingleObject(process, 60 * 1000))
       DPLOG(ERROR) << "Error waiting for process exit";
   } else if (!result) {
     DPLOG(ERROR) << "Unable to terminate process";
   }
   return result;
 }
 
-// Attempts to kill the process identified by the given process
-// entry structure, giving it the specified exit code.
-// Returns true if this is successful, false otherwise.
-bool KillProcessById(ProcessId process_id, int exit_code, bool wait) {
-  HANDLE process = OpenProcess(PROCESS_TERMINATE | SYNCHRONIZE,
-                               FALSE,  // Don't inherit handle
-                               process_id);
-  if (!process) {
-    DPLOG(ERROR) << "Unable to open process " << process_id;
-    return false;
-  }
-  bool ret = KillProcess(process, exit_code, wait);
-  CloseHandle(process);
-  return ret;
-}
-
 TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code) {
   DWORD tmp_exit_code = 0;
 
   if (!::GetExitCodeProcess(handle, &tmp_exit_code)) {
     DPLOG(FATAL) << "GetExitCodeProcess() failed";
     if (exit_code) {
       // This really is a random number.  We haven't received any
       // information about the exit code, presumably because this
       // process doesn't have permission to get the exit code, or
       // because of some other cause for GetExitCodeProcess to fail
@@ skipping 38 matching lines @@
     case kKeyboardInterruptExitCode:  // Control-C/end session.
     case kDebuggerTerminatedExitCode:  // Debugger terminated process.
     case kProcessKilledExitCode:  // Task manager kill.
       return TERMINATION_STATUS_PROCESS_WAS_KILLED;
     default:
       // All other exit codes indicate crashes.
       return TERMINATION_STATUS_PROCESS_CRASHED;
   }
 }
 
-bool WaitForExitCode(ProcessHandle handle, int* exit_code) {
-  // TODO(rvargas) crbug.com/417532: Remove this function.
-  Process process(handle);
-  return process.WaitForExit(exit_code);
-}
-
-bool WaitForExitCodeWithTimeout(ProcessHandle handle,
-                                int* exit_code,
-                                TimeDelta timeout) {
-  if (::WaitForSingleObject(
-      handle, static_cast<DWORD>(timeout.InMilliseconds())) != WAIT_OBJECT_0)
-    return false;
-  DWORD temp_code;  // Don't clobber out-parameters in case of failure.
-  if (!::GetExitCodeProcess(handle, &temp_code))
-    return false;
-
-  *exit_code = temp_code;
-  return true;
-}
-
 bool WaitForProcessesToExit(const FilePath::StringType& executable_name,
                             TimeDelta wait,
                             const ProcessFilter* filter) {
   bool result = true;
   DWORD start_time = GetTickCount();
 
   NamedProcessIterator iter(executable_name, filter);
   for (const ProcessEntry* entry = iter.NextProcessEntry(); entry;
        entry = iter.NextProcessEntry()) {
     DWORD remaining_wait = static_cast<DWORD>(std::max(
@@ skipping 29 matching lines @@
   }
 
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       Bind(&TimerExpiredTask::TimedOut,
            Owned(new TimerExpiredTask(process.Pass()))),
       TimeDelta::FromMilliseconds(kWaitInterval));
 }
 
 }  // namespace base