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 } 242
