chrome/test/base/chrome_process_util.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/test/base/chrome_process_util.h"
   6
   7 #include <set>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/command_line.h"
  12 #include "base/process/kill.h"
  13 #include "base/process/process_iterator.h"
  14 #include "base/time/time.h"
  15 #include "chrome/common/chrome_constants.h"
  16 #include "chrome/test/base/test_switches.h"
  17 #include "content/public/common/result_codes.h"
  18
  19 using base::TimeDelta;
  20 using base::TimeTicks;
  21
  22 namespace {
  23
  24 // Returns the executable name of the current Chrome browser process.
  25 const base::FilePath::CharType* GetRunningBrowserExecutableName() {
  26   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
  27   if (cmd_line->HasSwitch(switches::kEnableChromiumBranding))
  28     return chrome::kBrowserProcessExecutableNameChromium;
  29   return chrome::kBrowserProcessExecutableName;
  30 }
  31
  32 // Returns the executable name of the current Chrome helper process.
  33 std::vector<base::FilePath::StringType> GetRunningHelperExecutableNames() {
  34   base::FilePath::StringType name;
  35   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
  36   if (cmd_line->HasSwitch(switches::kEnableChromiumBranding)) {
  37     name = chrome::kHelperProcessExecutableNameChromium;
  38   } else {
  39     name = chrome::kHelperProcessExecutableName;
  40   }
  41
  42   std::vector<base::FilePath::StringType> names;
  43   names.push_back(name);
  44
  45 #if defined(OS_MACOSX)
  46   // The helper might show up as these different flavors depending on the
  47   // executable flags required.
  48   for (const char* const* suffix = chrome::kHelperFlavorSuffixes;
  49        *suffix;
  50        ++suffix) {
  51     std::string flavor_name(name);
  52     flavor_name.append(1, ' ');
  53     flavor_name.append(*suffix);
  54     names.push_back(flavor_name);
  55   }
  56 #endif
  57
  58   return names;
  59 }
  60
  61 }  // namespace
  62
  63 void TerminateAllChromeProcesses(const ChromeProcessList& process_pids) {
  64   ChromeProcessList::const_iterator it;
  65   for (it = process_pids.begin(); it != process_pids.end(); ++it) {
  66     base::ProcessHandle handle;
  67     if (!base::OpenProcessHandle(*it, &handle)) {
  68       // Ignore processes for which we can't open the handle. We don't
  69       // guarantee that all processes will terminate, only try to do so.
  70       continue;
  71     }
  72
  73     base::KillProcess(handle, content::RESULT_CODE_KILLED, true);
  74     base::CloseProcessHandle(handle);
  75   }
  76 }
  77
  78 class ChildProcessFilter : public base::ProcessFilter {
  79  public:
  80   explicit ChildProcessFilter(base::ProcessId parent_pid)
  81       : parent_pids_(&parent_pid, (&parent_pid) + 1) {}
  82
  83   explicit ChildProcessFilter(const std::vector<base::ProcessId>& parent_pids)
  84       : parent_pids_(parent_pids.begin(), parent_pids.end()) {}
  85
  86   virtual bool Includes(const base::ProcessEntry& entry) const OVERRIDE {
  87     return parent_pids_.find(entry.parent_pid()) != parent_pids_.end();
  88   }
  89
  90  private:
  91   const std::set<base::ProcessId> parent_pids_;
  92
  93   DISALLOW_COPY_AND_ASSIGN(ChildProcessFilter);
  94 };
  95
  96 ChromeProcessList GetRunningChromeProcesses(base::ProcessId browser_pid) {
  97   const base::FilePath::CharType* executable_name =
  98       GetRunningBrowserExecutableName();
  99   ChromeProcessList result;
 100   if (browser_pid == static_cast<base::ProcessId>(-1))
 101     return result;
 102
 103   ChildProcessFilter filter(browser_pid);
 104   base::NamedProcessIterator it(executable_name, &filter);
 105   while (const base::ProcessEntry* process_entry = it.NextProcessEntry()) {
 106     result.push_back(process_entry->pid());
 107   }
 108
 109 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 110   // On Unix we might be running with a zygote process for the renderers.
 111   // Because of that we sweep the list of processes again and pick those which
 112   // are children of one of the processes that we've already seen.
 113   {
 114     ChildProcessFilter filter(result);
 115     base::NamedProcessIterator it(executable_name, &filter);
 116     while (const base::ProcessEntry* process_entry = it.NextProcessEntry())
 117       result.push_back(process_entry->pid());
 118   }
 119 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX)
 120
 121 #if defined(OS_POSIX)
 122   // On Mac OS X we run the subprocesses with a different bundle, and
 123   // on Linux via /proc/self/exe, so they end up with a different
 124   // name.  We must collect them in a second pass.
 125   {
 126     std::vector<base::FilePath::StringType> names =
 127         GetRunningHelperExecutableNames();
 128     for (size_t i = 0; i < names.size(); ++i) {
 129       base::FilePath::StringType name = names[i];
 130       ChildProcessFilter filter(browser_pid);
 131       base::NamedProcessIterator it(name, &filter);
 132       while (const base::ProcessEntry* process_entry = it.NextProcessEntry())
 133         result.push_back(process_entry->pid());
 134     }
 135   }
 136 #endif  // defined(OS_POSIX)
 137
 138   result.push_back(browser_pid);
 139
 140   return result;
 141 }
 142
 143 #if !defined(OS_MACOSX)
 144
 145 size_t ChromeTestProcessMetrics::GetPagefileUsage() {
 146   return process_metrics_->GetPagefileUsage();
 147 }
 148
 149 size_t ChromeTestProcessMetrics::GetWorkingSetSize() {
 150   return process_metrics_->GetWorkingSetSize();
 151 }
 152
 153 #endif  // !defined(OS_MACOSX)
 154
 155 ChromeTestProcessMetrics::~ChromeTestProcessMetrics() {}
 156
 157 ChromeTestProcessMetrics::ChromeTestProcessMetrics(
 158     base::ProcessHandle process) {
 159 #if !defined(OS_MACOSX)
 160   process_metrics_.reset(
 161       base::ProcessMetrics::CreateProcessMetrics(process));
 162 #else
 163   process_metrics_.reset(
 164       base::ProcessMetrics::CreateProcessMetrics(process, NULL));
 165 #endif
 166   process_handle_ = process;
 167 }