Move common code into process_util.cc

base/process_util_win.cc

 // Copyright (c) 2010 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_util.h"
 
 #include <fcntl.h>
 #include <io.h>
 #include <windows.h>
 #include <userenv.h>
@@ skipping 204 matching lines @@
                    start_hidden, process_handle);
 }
 
 // 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)
+  if (!process) {
+    DLOG(ERROR) << "Unable to open process " << process_id << " : "
+                << GetLastError();
     return false;
-
+  }
   bool ret = KillProcess(process, exit_code, wait);
   CloseHandle(process);
   return ret;
 }
 
 bool GetAppOutput(const CommandLine& cl, std::string* output) {
   HANDLE out_read = NULL;
   HANDLE out_write = NULL;
 
   SECURITY_ATTRIBUTES sa_attr;
@@ skipping 139 matching lines @@
     return false;
 
   // Only close the handle on success, to give the caller a chance to forcefully
   // terminate the process if he wants to.
   CloseProcessHandle(handle);
 
   *exit_code = temp_code;
   return true;
 }
 
-NamedProcessIterator::NamedProcessIterator(const std::wstring& executable_name,
-                                           const ProcessFilter* filter)
+ProcessIterator::ProcessIterator(const ProcessFilter* filter)
     : started_iteration_(false),
-      executable_name_(executable_name),
       filter_(filter) {
   snapshot_ = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 }
 
-NamedProcessIterator::~NamedProcessIterator() {
+ProcessIterator::~ProcessIterator() {
   CloseHandle(snapshot_);
 }
 
-
-const ProcessEntry* NamedProcessIterator::NextProcessEntry() {
-  bool result = false;
-  do {
-    result = CheckForNextProcess();
-  } while (result && !IncludeEntry());
-
-  if (result) {
-    return &entry_;
-  }
-
-  return NULL;
-}
-
-bool NamedProcessIterator::CheckForNextProcess() {
+bool ProcessIterator::CheckForNextProcess() {
   InitProcessEntry(&entry_);
 
   if (!started_iteration_) {
     started_iteration_ = true;
     return !!Process32First(snapshot_, &entry_);
   }
 
   return !!Process32Next(snapshot_, &entry_);
 }
 
-bool NamedProcessIterator::IncludeEntry() {
-  return _wcsicmp(executable_name_.c_str(), entry_.szExeFile) == 0 &&
-                  (!filter_ || filter_->Includes(entry_.th32ProcessID,
-                                                 entry_.th32ParentProcessID));
-}
-
-void NamedProcessIterator::InitProcessEntry(ProcessEntry* entry) {
+void ProcessIterator::InitProcessEntry(ProcessEntry* entry) {
   memset(entry, 0, sizeof(*entry));
   entry->dwSize = sizeof(*entry);
 }
 
-int GetProcessCount(const std::wstring& executable_name,
-                    const ProcessFilter* filter) {
-  int count = 0;
-
-  NamedProcessIterator iter(executable_name, filter);
-  while (iter.NextProcessEntry())
-    ++count;
-  return count;
-}
-
-bool KillProcesses(const std::wstring& executable_name, int exit_code,
-                   const ProcessFilter* filter) {
-  bool result = true;
-  const ProcessEntry* entry;
-
-  NamedProcessIterator iter(executable_name, filter);
-  while (entry = iter.NextProcessEntry()) {
-    if (!KillProcessById((*entry).th32ProcessID, exit_code, true))
-      result = false;
-  }
-
-  return result;
+bool NamedProcessIterator::IncludeEntry() {
+  // Case insensitive.
+  return _wcsicmp(executable_name_.c_str(), entry().exe_file()) == 0 &&
+         ProcessIterator::IncludeEntry();
 }
 
 bool WaitForProcessesToExit(const std::wstring& executable_name,
                             int64 wait_milliseconds,
                             const ProcessFilter* filter) {
   const ProcessEntry* entry;
   bool result = true;
   DWORD start_time = GetTickCount();
 
   NamedProcessIterator iter(executable_name, filter);
@@ skipping 248 matching lines @@
   // We add time_delta / 2 so the result is rounded.
   int cpu = static_cast<int>((system_time_delta * 100 + time_delta / 2) /
                              time_delta);
 
   last_system_time_ = system_time;
   last_time_ = time;
 
   return cpu;
 }
 
-bool ProcessMetrics::GetIOCounters(base::IoCounters* io_counters) const {
+bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
   return GetProcessIoCounters(process_, io_counters) != FALSE;
 }
 
 bool ProcessMetrics::CalculateFreeMemory(FreeMBytes* free) const {
   const SIZE_T kTopAdress = 0x7F000000;
   const SIZE_T kMegabyte = 1024 * 1024;
   SIZE_T accumulated = 0;
 
   MEMORY_BASIC_INFORMATION largest = {0};
   UINT_PTR scan = 0;
@@ skipping 101 matching lines @@
 
   PERFORMANCE_INFORMATION info;
   if (!InternalGetPerformanceInfo(&info, sizeof(info))) {
     LOG(ERROR) << "Failed to fetch internal performance info.";
     return 0;
   }
   return (info.CommitTotal * system_info.dwPageSize) / 1024;
 }
 
 }  // namespace base