1// Copyright (c) 2012 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/browser/memory_details.h"
6
7#include <set>
8#include <string>
9
10#include "base/basictypes.h"
11#include "base/bind.h"
12#include "base/file_version_info.h"
13#include "base/files/file_path.h"
14#include "base/mac/mac_util.h"
15#include "base/process/process_iterator.h"
16#include "base/strings/string_util.h"
17#include "base/strings/utf_string_conversions.h"
18#include "base/threading/thread.h"
19#include "chrome/browser/process_info_snapshot.h"
20#include "chrome/common/chrome_constants.h"
21#include "chrome/common/chrome_version_info.h"
22#include "chrome/common/url_constants.h"
23#include "content/public/browser/browser_thread.h"
24#include "content/public/common/process_type.h"
25#include "grit/chromium_strings.h"
26#include "ui/base/l10n/l10n_util.h"
27
28using content::BrowserThread;
29
30// TODO(viettrungluu): Many of the TODOs below are subsumed by a general need to
31// refactor the about:memory code (not just on Mac, but probably on other
32// platforms as well). I've filed crbug.com/25456.
33
34// Known browsers which we collect details for. |CHROME_BROWSER| *must* be the
35// first browser listed. The order here must match those in |process_template|
36// (in |MemoryDetails::MemoryDetails()| below).
37// TODO(viettrungluu): In the big refactoring (see above), get rid of this order
38// dependence.
39enum BrowserType {
40  // TODO(viettrungluu): possibly add more?
41  CHROME_BROWSER = 0,
42  SAFARI_BROWSER,
43  FIREFOX_BROWSER,
44  CAMINO_BROWSER,
45  OPERA_BROWSER,
46  OMNIWEB_BROWSER,
47  MAX_BROWSERS
48} BrowserProcess;
49
50
51MemoryDetails::MemoryDetails()
52    : user_metrics_mode_(UPDATE_USER_METRICS) {
53  const std::string google_browser_name =
54      l10n_util::GetStringUTF8(IDS_PRODUCT_NAME);
55  // (Human and process) names of browsers; should match the ordering for
56  // |BrowserProcess| (i.e., |BrowserType|).
57  // TODO(viettrungluu): The current setup means that we can't detect both
58  // Chrome and Chromium at the same time!
59  // TODO(viettrungluu): Get localized browser names for other browsers
60  // (crbug.com/25779).
61  struct {
62    const char* name;
63    const char* process_name;
64  } process_template[MAX_BROWSERS] = {
65    { google_browser_name.c_str(), chrome::kBrowserProcessExecutableName, },
66    { "Safari", "Safari", },
67    { "Firefox", "firefox-bin", },
68    { "Camino", "Camino", },
69    { "Opera", "Opera", },
70    { "OmniWeb", "OmniWeb", },
71  };
72
73  for (size_t index = 0; index < MAX_BROWSERS; ++index) {
74    ProcessData process;
75    process.name = base::UTF8ToUTF16(process_template[index].name);
76    process.process_name =
77        base::UTF8ToUTF16(process_template[index].process_name);
78    process_data_.push_back(process);
79  }
80}
81
82ProcessData* MemoryDetails::ChromeBrowser() {
83  return &process_data_[CHROME_BROWSER];
84}
85
86void MemoryDetails::CollectProcessData(
87    const std::vector<ProcessMemoryInformation>& child_info) {
88  // This must be run on the file thread to avoid jank (|ProcessInfoSnapshot|
89  // runs /bin/ps, which isn't instantaneous).
90  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
91
92  // Clear old data.
93  for (size_t index = 0; index < MAX_BROWSERS; index++)
94    process_data_[index].processes.clear();
95
96  // First, we use |NamedProcessIterator| to get the PIDs of the processes we're
97  // interested in; we save our results to avoid extra calls to
98  // |NamedProcessIterator| (for performance reasons) and to avoid additional
99  // inconsistencies caused by racing. Then we run |/bin/ps| *once* to get
100  // information on those PIDs. Then we used our saved information to iterate
101  // over browsers, then over PIDs.
102
103  // Get PIDs of main browser processes.
104  std::vector<base::ProcessId> pids_by_browser[MAX_BROWSERS];
105  std::vector<base::ProcessId> all_pids;
106  for (size_t index = CHROME_BROWSER; index < MAX_BROWSERS; index++) {
107    base::NamedProcessIterator process_it(
108        base::UTF16ToUTF8(process_data_[index].process_name), NULL);
109
110    while (const base::ProcessEntry* entry = process_it.NextProcessEntry()) {
111      pids_by_browser[index].push_back(entry->pid());
112      all_pids.push_back(entry->pid());
113    }
114  }
115
116  // The helper might show up as these different flavors depending on the
117  // executable flags required.
118  std::vector<std::string> helper_names;
119  helper_names.push_back(chrome::kHelperProcessExecutableName);
120  for (const char* const* suffix = chrome::kHelperFlavorSuffixes;
121       *suffix;
122       ++suffix) {
123    std::string helper_name = chrome::kHelperProcessExecutableName;
124    helper_name.append(1, ' ');
125    helper_name.append(*suffix);
126    helper_names.push_back(helper_name);
127  }
128
129  // Get PIDs of helpers.
130  std::vector<base::ProcessId> helper_pids;
131  for (size_t i = 0; i < helper_names.size(); ++i) {
132    std::string helper_name = helper_names[i];
133    base::NamedProcessIterator helper_it(helper_name, NULL);
134    while (const base::ProcessEntry* entry = helper_it.NextProcessEntry()) {
135      helper_pids.push_back(entry->pid());
136      all_pids.push_back(entry->pid());
137    }
138  }
139
140  // Capture information about the processes we're interested in.
141  ProcessInfoSnapshot process_info;
142  process_info.Sample(all_pids);
143
144  // Handle the other processes first.
145  for (size_t index = CHROME_BROWSER + 1; index < MAX_BROWSERS; index++) {
146    for (std::vector<base::ProcessId>::const_iterator it =
147         pids_by_browser[index].begin();
148         it != pids_by_browser[index].end(); ++it) {
149      ProcessMemoryInformation info;
150      info.pid = *it;
151      info.process_type = content::PROCESS_TYPE_UNKNOWN;
152
153      // Try to get version information. To do this, we need first to get the
154      // executable's name (we can only believe |proc_info.command| if it looks
155      // like an absolute path). Then we need strip the executable's name back
156      // to the bundle's name. And only then can we try to get the version.
157      scoped_ptr<FileVersionInfo> version_info;
158      ProcessInfoSnapshot::ProcInfoEntry proc_info;
159      if (process_info.GetProcInfo(info.pid, &proc_info)) {
160        if (proc_info.command.length() > 1 && proc_info.command[0] == '/') {
161          base::FilePath bundle_name =
162              base::mac::GetAppBundlePath(base::FilePath(proc_info.command));
163          if (!bundle_name.empty()) {
164            version_info.reset(FileVersionInfo::CreateFileVersionInfo(
165                bundle_name));
166          }
167        }
168      }
169      if (version_info.get()) {
170        info.product_name = version_info->product_name();
171        info.version = version_info->product_version();
172      } else {
173        info.product_name = process_data_[index].name;
174        info.version = base::string16();
175      }
176
177      // Memory info.
178      process_info.GetCommittedKBytesOfPID(info.pid, &info.committed);
179      process_info.GetWorkingSetKBytesOfPID(info.pid, &info.working_set);
180
181      // Add the process info to our list.
182      process_data_[index].processes.push_back(info);
183    }
184  }
185
186  // Collect data about Chrome/Chromium.
187  for (std::vector<base::ProcessId>::const_iterator it =
188       pids_by_browser[CHROME_BROWSER].begin();
189       it != pids_by_browser[CHROME_BROWSER].end(); ++it) {
190    CollectProcessDataChrome(child_info, *it, process_info);
191  }
192
193  // And collect data about the helpers.
194  for (std::vector<base::ProcessId>::const_iterator it = helper_pids.begin();
195       it != helper_pids.end(); ++it) {
196    CollectProcessDataChrome(child_info, *it, process_info);
197  }
198
199  // Finally return to the browser thread.
200  BrowserThread::PostTask(
201      BrowserThread::UI, FROM_HERE,
202      base::Bind(&MemoryDetails::CollectChildInfoOnUIThread, this));
203}
204
205void MemoryDetails::CollectProcessDataChrome(
206    const std::vector<ProcessMemoryInformation>& child_info,
207    base::ProcessId pid,
208    const ProcessInfoSnapshot& process_info) {
209  ProcessMemoryInformation info;
210  info.pid = pid;
211  if (info.pid == base::GetCurrentProcId())
212    info.process_type = content::PROCESS_TYPE_BROWSER;
213  else
214    info.process_type = content::PROCESS_TYPE_UNKNOWN;
215
216  chrome::VersionInfo version_info;
217  if (version_info.is_valid()) {
218    info.product_name = base::ASCIIToUTF16(version_info.Name());
219    info.version = base::ASCIIToUTF16(version_info.Version());
220  } else {
221    info.product_name = process_data_[CHROME_BROWSER].name;
222    info.version = base::string16();
223  }
224
225  // Check if this is one of the child processes whose data we collected
226  // on the IO thread, and if so copy over that data.
227  for (size_t child = 0; child < child_info.size(); child++) {
228    if (child_info[child].pid == info.pid) {
229      info.titles = child_info[child].titles;
230      info.process_type = child_info[child].process_type;
231      break;
232    }
233  }
234
235  // Memory info.
236  process_info.GetCommittedKBytesOfPID(info.pid, &info.committed);
237  process_info.GetWorkingSetKBytesOfPID(info.pid, &info.working_set);
238
239  // Add the process info to our list.
240  process_data_[CHROME_BROWSER].processes.push_back(info);
241}
242