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 = 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.process_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 base::FilePath bundle_name = 161 base::mac::GetAppBundlePath(base::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.process_type = content::PROCESS_TYPE_BROWSER; 212 else 213 info.process_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.process_type = child_info[child].process_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 } 241
