Make Ash unittests clean up zombie viewer processes between test runs. These zombie viewer proce…

chrome_frame/test_utils.cc

 // Copyright (c) 2012 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 "chrome_frame/test_utils.h"
 
 #include <atlbase.h>
 #include <atlwin.h>
 #include <shellapi.h>
-#include <winternl.h>
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
-#include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_handle.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const wchar_t kChromeFrameDllName[] = L"npchrome_frame.dll";
 const wchar_t kChromeLauncherExeName[] = L"chrome_launcher.exe";
@@ skipping 231 matching lines @@
 }
 
 void ScopedChromeFrameRegistrar::RegisterReferenceChromeFrameBuild() {
   RegisterChromeFrameAtPath(GetReferenceChromeFrameDllPath().value());
 }
 
 std::wstring ScopedChromeFrameRegistrar::GetChromeFrameDllPath() const {
   return new_chrome_frame_dll_path_;
 }
 
-// TODO(robertshield): The following could be factored out into its own file.
-namespace {
-
-typedef LONG WINAPI
-NtQueryInformationProcess(
-  IN HANDLE ProcessHandle,
-  IN PROCESSINFOCLASS ProcessInformationClass,
-  OUT PVOID ProcessInformation,
-  IN ULONG ProcessInformationLength,
-  OUT PULONG ReturnLength OPTIONAL
-);
-
-// Get the function pointer to NtQueryInformationProcess in NTDLL.DLL
-static bool GetQIP(NtQueryInformationProcess** qip_func_ptr) {
-  static NtQueryInformationProcess* qip_func =
-      reinterpret_cast<NtQueryInformationProcess*>(
-          GetProcAddress(GetModuleHandle(L"ntdll.dll"),
-          "NtQueryInformationProcess"));
-  DCHECK(qip_func) << "Could not get pointer to NtQueryInformationProcess.";
-  *qip_func_ptr = qip_func;
-  return qip_func != NULL;
-}
-
-// Get the command line of a process
-bool GetCommandLineForProcess(uint32 process_id, std::wstring* cmd_line) {
-  DCHECK(process_id != 0);
-  DCHECK(cmd_line);
-
-  // Open the process
-  base::win::ScopedHandle process_handle(::OpenProcess(
-      PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
-      false,
-      process_id));
-  if (!process_handle) {
-    DLOG(ERROR) << "Failed to open process " << process_id << ", last error = "
-                << GetLastError();
-  }
-
-  // Obtain Process Environment Block
-  NtQueryInformationProcess* qip_func = NULL;
-  if (process_handle) {
-    GetQIP(&qip_func);
-  }
-
-  // Read the address of the process params from the peb.
-  DWORD process_params_address = 0;
-  if (qip_func) {
-    PROCESS_BASIC_INFORMATION info = { 0 };
-    // NtQueryInformationProcess returns an NTSTATUS for whom negative values
-    // are negative. Just check for that instead of pulling in DDK macros.
-    if ((qip_func(process_handle.Get(),
-                  ProcessBasicInformation,
-                  &info,
-                  sizeof(info),
-                  NULL)) < 0) {
-      DLOG(ERROR) << "Failed to invoke NtQueryProcessInformation, last error = "
-                  << GetLastError();
-    } else {
-      BYTE* peb = reinterpret_cast<BYTE*>(info.PebBaseAddress);
-
-      // The process command line parameters are (or were once) located at
-      // the base address of the PEB + 0x10 for 32 bit processes. 64 bit
-      // processes have a different PEB struct as per
-      // http://msdn.microsoft.com/en-us/library/aa813706(VS.85).aspx.
-      // TODO(robertshield): See about doing something about this.
-      SIZE_T bytes_read = 0;
-      if (!::ReadProcessMemory(process_handle.Get(),
-                               peb + 0x10,
-                               &process_params_address,
-                               sizeof(process_params_address),
-                               &bytes_read)) {
-        DLOG(ERROR) << "Failed to read process params address, last error = "
-                    << GetLastError();
-      }
-    }
-  }
-
-  // Copy all the process parameters into a buffer.
-  bool success = false;
-  std::wstring buffer;
-  if (process_params_address) {
-    SIZE_T bytes_read;
-    RTL_USER_PROCESS_PARAMETERS params = { 0 };
-    if (!::ReadProcessMemory(process_handle.Get(),
-                             reinterpret_cast<void*>(process_params_address),
-                             &params,
-                             sizeof(params),
-                             &bytes_read)) {
-      DLOG(ERROR) << "Failed to read RTL_USER_PROCESS_PARAMETERS, "
-                  << "last error = " << GetLastError();
-    } else {
-      // Read the command line parameter
-      const int max_cmd_line_len = std::min(
-          static_cast<int>(params.CommandLine.MaximumLength),
-          4096);
-      buffer.resize(max_cmd_line_len + 1);
-      if (!::ReadProcessMemory(process_handle.Get(),
-                               params.CommandLine.Buffer,
-                               &buffer[0],
-                               max_cmd_line_len,
-                               &bytes_read)) {
-        DLOG(ERROR) << "Failed to copy process command line, "
-                    << "last error = " << GetLastError();
-      } else {
-        *cmd_line = buffer;
-        success = true;
-      }
-    }
-  }
-
-  return success;
-}
-
-// Used to filter processes by process ID.
-class ArgumentFilter : public base::ProcessFilter {
- public:
-  explicit ArgumentFilter(const std::wstring& argument)
-      : argument_to_find_(argument) {}
-
-  // Returns true to indicate set-inclusion and false otherwise.  This method
-  // should not have side-effects and should be idempotent.
-  virtual bool Includes(const base::ProcessEntry& entry) const {
-    bool found = false;
-    std::wstring command_line;
-    if (GetCommandLineForProcess(entry.pid(), &command_line)) {
-      std::wstring::const_iterator it =
-          std::search(command_line.begin(),
-                      command_line.end(),
-                      argument_to_find_.begin(),
-                      argument_to_find_.end(),
-          base::CaseInsensitiveCompareASCII<wchar_t>());
-      found = (it != command_line.end());
-    }
-    return found;
-  }
-
- protected:
-  std::wstring argument_to_find_;
-};
-
-}  // namespace
-
-bool KillAllNamedProcessesWithArgument(const std::wstring& process_name,
-                                       const std::wstring& argument) {
-  return base::KillProcesses(process_name, 0, &ArgumentFilter(argument));
-}
-
 bool IsWorkstationLocked() {
   bool is_locked = true;
   HDESK input_desk = ::OpenInputDesktop(0, 0, GENERIC_READ);
   if (input_desk)  {
     wchar_t name[256] = {0};
     DWORD needed = 0;
     if (::GetUserObjectInformation(input_desk,
       UOI_NAME,
       name,
       sizeof(name),
       &needed)) {
         is_locked = lstrcmpi(name, L"default") != 0;
     }
     ::CloseDesktop(input_desk);
   }
   return is_locked;
 }