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