chrome/browser/memory_details_mac.cc

   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
  28 using 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.
  39 enum 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
  51 MemoryDetails::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
  82 ProcessData* MemoryDetails::ChromeBrowser() {
  83   return &process_data_[CHROME_BROWSER];
  84 }
  85
  86 void 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
 205 void 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 }