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/metrics/metrics_log.h" 6 7 #include <algorithm> 8 #include <string> 9 #include <vector> 10 11 #include "base/base64.h" 12 #include "base/basictypes.h" 13 #include "base/bind.h" 14 #include "base/cpu.h" 15 #include "base/lazy_instance.h" 16 #include "base/memory/scoped_ptr.h" 17 #include "base/prefs/pref_registry_simple.h" 18 #include "base/prefs/pref_service.h" 19 #include "base/profiler/alternate_timer.h" 20 #include "base/sha1.h" 21 #include "base/strings/string_number_conversions.h" 22 #include "base/strings/string_util.h" 23 #include "base/strings/utf_string_conversions.h" 24 #include "base/sys_info.h" 25 #include "base/third_party/nspr/prtime.h" 26 #include "base/time/time.h" 27 #include "base/tracked_objects.h" 28 #include "chrome/browser/autocomplete/autocomplete_input.h" 29 #include "chrome/browser/autocomplete/autocomplete_match.h" 30 #include "chrome/browser/autocomplete/autocomplete_provider.h" 31 #include "chrome/browser/autocomplete/autocomplete_result.h" 32 #include "chrome/browser/browser_process.h" 33 #include "chrome/browser/google/google_util.h" 34 #include "chrome/browser/omnibox/omnibox_log.h" 35 #include "chrome/browser/plugins/plugin_prefs.h" 36 #include "chrome/browser/profiles/profile_manager.h" 37 #include "chrome/common/chrome_version_info.h" 38 #include "chrome/common/logging_chrome.h" 39 #include "chrome/common/metrics/proto/omnibox_event.pb.h" 40 #include "chrome/common/metrics/proto/profiler_event.pb.h" 41 #include "chrome/common/metrics/proto/system_profile.pb.h" 42 #include "chrome/common/metrics/variations/variations_util.h" 43 #include "chrome/common/pref_names.h" 44 #include "chrome/installer/util/google_update_settings.h" 45 #include "components/nacl/common/nacl_process_type.h" 46 #include "content/public/browser/gpu_data_manager.h" 47 #include "content/public/common/content_client.h" 48 #include "content/public/common/webplugininfo.h" 49 #include "device/bluetooth/bluetooth_adapter.h" 50 #include "device/bluetooth/bluetooth_adapter_factory.h" 51 #include "device/bluetooth/bluetooth_device.h" 52 #include "gpu/config/gpu_info.h" 53 #include "ui/gfx/screen.h" 54 #include "url/gurl.h" 55 56 #if defined(OS_ANDROID) 57 #include "base/android/build_info.h" 58 #endif 59 60 #if defined(OS_WIN) 61 #include "base/win/metro.h" 62 63 // http://blogs.msdn.com/oldnewthing/archive/2004/10/25/247180.aspx 64 extern "C" IMAGE_DOS_HEADER __ImageBase; 65 #endif 66 67 #if defined(OS_CHROMEOS) 68 #include "chrome/browser/chromeos/login/user_manager.h" 69 #endif 70 71 using content::GpuDataManager; 72 using metrics::OmniboxEventProto; 73 using metrics::PerfDataProto; 74 using metrics::ProfilerEventProto; 75 using metrics::SystemProfileProto; 76 using tracked_objects::ProcessDataSnapshot; 77 typedef chrome_variations::ActiveGroupId ActiveGroupId; 78 typedef SystemProfileProto::GoogleUpdate::ProductInfo ProductInfo; 79 typedef SystemProfileProto::Hardware::Bluetooth::PairedDevice PairedDevice; 80 81 namespace { 82 83 // Returns the date at which the current metrics client ID was created as 84 // a string containing seconds since the epoch, or "0" if none was found. 85 std::string GetMetricsEnabledDate(PrefService* pref) { 86 if (!pref) { 87 NOTREACHED(); 88 return "0"; 89 } 90 91 return pref->GetString(prefs::kMetricsClientIDTimestamp); 92 } 93 94 OmniboxEventProto::InputType AsOmniboxEventInputType( 95 AutocompleteInput::Type type) { 96 switch (type) { 97 case AutocompleteInput::INVALID: 98 return OmniboxEventProto::INVALID; 99 case AutocompleteInput::UNKNOWN: 100 return OmniboxEventProto::UNKNOWN; 101 case AutocompleteInput::URL: 102 return OmniboxEventProto::URL; 103 case AutocompleteInput::QUERY: 104 return OmniboxEventProto::QUERY; 105 case AutocompleteInput::FORCED_QUERY: 106 return OmniboxEventProto::FORCED_QUERY; 107 default: 108 NOTREACHED(); 109 return OmniboxEventProto::INVALID; 110 } 111 } 112 113 OmniboxEventProto::Suggestion::ResultType AsOmniboxEventResultType( 114 AutocompleteMatch::Type type) { 115 switch (type) { 116 case AutocompleteMatchType::URL_WHAT_YOU_TYPED: 117 return OmniboxEventProto::Suggestion::URL_WHAT_YOU_TYPED; 118 case AutocompleteMatchType::HISTORY_URL: 119 return OmniboxEventProto::Suggestion::HISTORY_URL; 120 case AutocompleteMatchType::HISTORY_TITLE: 121 return OmniboxEventProto::Suggestion::HISTORY_TITLE; 122 case AutocompleteMatchType::HISTORY_BODY: 123 return OmniboxEventProto::Suggestion::HISTORY_BODY; 124 case AutocompleteMatchType::HISTORY_KEYWORD: 125 return OmniboxEventProto::Suggestion::HISTORY_KEYWORD; 126 case AutocompleteMatchType::NAVSUGGEST: 127 return OmniboxEventProto::Suggestion::NAVSUGGEST; 128 case AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED: 129 return OmniboxEventProto::Suggestion::SEARCH_WHAT_YOU_TYPED; 130 case AutocompleteMatchType::SEARCH_HISTORY: 131 return OmniboxEventProto::Suggestion::SEARCH_HISTORY; 132 case AutocompleteMatchType::SEARCH_SUGGEST: 133 return OmniboxEventProto::Suggestion::SEARCH_SUGGEST; 134 case AutocompleteMatchType::SEARCH_SUGGEST_ENTITY: 135 return OmniboxEventProto::Suggestion::SEARCH_SUGGEST_ENTITY; 136 case AutocompleteMatchType::SEARCH_SUGGEST_INFINITE: 137 return OmniboxEventProto::Suggestion::SEARCH_SUGGEST_INFINITE; 138 case AutocompleteMatchType::SEARCH_SUGGEST_PERSONALIZED: 139 return OmniboxEventProto::Suggestion::SEARCH_SUGGEST_PERSONALIZED; 140 case AutocompleteMatchType::SEARCH_SUGGEST_PROFILE: 141 return OmniboxEventProto::Suggestion::SEARCH_SUGGEST_PROFILE; 142 case AutocompleteMatchType::SEARCH_OTHER_ENGINE: 143 return OmniboxEventProto::Suggestion::SEARCH_OTHER_ENGINE; 144 case AutocompleteMatchType::EXTENSION_APP: 145 return OmniboxEventProto::Suggestion::EXTENSION_APP; 146 case AutocompleteMatchType::CONTACT: 147 return OmniboxEventProto::Suggestion::CONTACT; 148 case AutocompleteMatchType::BOOKMARK_TITLE: 149 return OmniboxEventProto::Suggestion::BOOKMARK_TITLE; 150 default: 151 NOTREACHED(); 152 return OmniboxEventProto::Suggestion::UNKNOWN_RESULT_TYPE; 153 } 154 } 155 156 OmniboxEventProto::PageClassification AsOmniboxEventPageClassification( 157 AutocompleteInput::PageClassification page_classification) { 158 switch (page_classification) { 159 case AutocompleteInput::INVALID_SPEC: 160 return OmniboxEventProto::INVALID_SPEC; 161 case AutocompleteInput::NTP: 162 return OmniboxEventProto::NTP; 163 case AutocompleteInput::BLANK: 164 return OmniboxEventProto::BLANK; 165 case AutocompleteInput::HOME_PAGE: 166 return OmniboxEventProto::HOME_PAGE; 167 case AutocompleteInput::OTHER: 168 return OmniboxEventProto::OTHER; 169 case AutocompleteInput::SEARCH_RESULT_PAGE_DOING_SEARCH_TERM_REPLACEMENT: 170 return OmniboxEventProto:: 171 SEARCH_RESULT_PAGE_DOING_SEARCH_TERM_REPLACEMENT; 172 case AutocompleteInput::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS: 173 return OmniboxEventProto::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS; 174 case AutocompleteInput::INSTANT_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS: 175 return OmniboxEventProto::INSTANT_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS; 176 case AutocompleteInput::SEARCH_RESULT_PAGE_NO_SEARCH_TERM_REPLACEMENT: 177 return OmniboxEventProto:: 178 SEARCH_RESULT_PAGE_NO_SEARCH_TERM_REPLACEMENT; 179 } 180 return OmniboxEventProto::INVALID_SPEC; 181 } 182 183 ProfilerEventProto::TrackedObject::ProcessType AsProtobufProcessType( 184 int process_type) { 185 switch (process_type) { 186 case content::PROCESS_TYPE_BROWSER: 187 return ProfilerEventProto::TrackedObject::BROWSER; 188 case content::PROCESS_TYPE_RENDERER: 189 return ProfilerEventProto::TrackedObject::RENDERER; 190 case content::PROCESS_TYPE_PLUGIN: 191 return ProfilerEventProto::TrackedObject::PLUGIN; 192 case content::PROCESS_TYPE_WORKER: 193 return ProfilerEventProto::TrackedObject::WORKER; 194 case content::PROCESS_TYPE_UTILITY: 195 return ProfilerEventProto::TrackedObject::UTILITY; 196 case content::PROCESS_TYPE_ZYGOTE: 197 return ProfilerEventProto::TrackedObject::ZYGOTE; 198 case content::PROCESS_TYPE_SANDBOX_HELPER: 199 return ProfilerEventProto::TrackedObject::SANDBOX_HELPER; 200 case content::PROCESS_TYPE_GPU: 201 return ProfilerEventProto::TrackedObject::GPU; 202 case content::PROCESS_TYPE_PPAPI_PLUGIN: 203 return ProfilerEventProto::TrackedObject::PPAPI_PLUGIN; 204 case content::PROCESS_TYPE_PPAPI_BROKER: 205 return ProfilerEventProto::TrackedObject::PPAPI_BROKER; 206 case PROCESS_TYPE_NACL_LOADER: 207 return ProfilerEventProto::TrackedObject::NACL_LOADER; 208 case PROCESS_TYPE_NACL_BROKER: 209 return ProfilerEventProto::TrackedObject::NACL_BROKER; 210 default: 211 NOTREACHED(); 212 return ProfilerEventProto::TrackedObject::UNKNOWN; 213 } 214 } 215 216 // Computes a SHA-1 hash of |data| and returns it as a hex string. 217 std::string ComputeSHA1(const std::string& data) { 218 const std::string sha1 = base::SHA1HashString(data); 219 return base::HexEncode(sha1.data(), sha1.size()); 220 } 221 222 #if defined(ENABLE_PLUGINS) 223 // Returns the plugin preferences corresponding for this user, if available. 224 // If multiple user profiles are loaded, returns the preferences corresponding 225 // to an arbitrary one of the profiles. 226 PluginPrefs* GetPluginPrefs() { 227 ProfileManager* profile_manager = g_browser_process->profile_manager(); 228 229 if (!profile_manager) { 230 // The profile manager can be NULL when testing. 231 return NULL; 232 } 233 234 std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles(); 235 if (profiles.empty()) 236 return NULL; 237 238 return PluginPrefs::GetForProfile(profiles.front()).get(); 239 } 240 241 // Fills |plugin| with the info contained in |plugin_info| and |plugin_prefs|. 242 void SetPluginInfo(const content::WebPluginInfo& plugin_info, 243 const PluginPrefs* plugin_prefs, 244 SystemProfileProto::Plugin* plugin) { 245 plugin->set_name(UTF16ToUTF8(plugin_info.name)); 246 plugin->set_filename(plugin_info.path.BaseName().AsUTF8Unsafe()); 247 plugin->set_version(UTF16ToUTF8(plugin_info.version)); 248 plugin->set_is_pepper(plugin_info.is_pepper_plugin()); 249 if (plugin_prefs) 250 plugin->set_is_disabled(!plugin_prefs->IsPluginEnabled(plugin_info)); 251 } 252 #endif // defined(ENABLE_PLUGINS) 253 254 void WriteFieldTrials(const std::vector<ActiveGroupId>& field_trial_ids, 255 SystemProfileProto* system_profile) { 256 for (std::vector<ActiveGroupId>::const_iterator it = 257 field_trial_ids.begin(); it != field_trial_ids.end(); ++it) { 258 SystemProfileProto::FieldTrial* field_trial = 259 system_profile->add_field_trial(); 260 field_trial->set_name_id(it->name); 261 field_trial->set_group_id(it->group); 262 } 263 } 264 265 void WriteProfilerData(const ProcessDataSnapshot& profiler_data, 266 int process_type, 267 ProfilerEventProto* performance_profile) { 268 for (std::vector<tracked_objects::TaskSnapshot>::const_iterator it = 269 profiler_data.tasks.begin(); 270 it != profiler_data.tasks.end(); ++it) { 271 const tracked_objects::DeathDataSnapshot& death_data = it->death_data; 272 ProfilerEventProto::TrackedObject* tracked_object = 273 performance_profile->add_tracked_object(); 274 tracked_object->set_birth_thread_name_hash( 275 MetricsLogBase::Hash(it->birth.thread_name)); 276 tracked_object->set_exec_thread_name_hash( 277 MetricsLogBase::Hash(it->death_thread_name)); 278 tracked_object->set_source_file_name_hash( 279 MetricsLogBase::Hash(it->birth.location.file_name)); 280 tracked_object->set_source_function_name_hash( 281 MetricsLogBase::Hash(it->birth.location.function_name)); 282 tracked_object->set_source_line_number(it->birth.location.line_number); 283 tracked_object->set_exec_count(death_data.count); 284 tracked_object->set_exec_time_total(death_data.run_duration_sum); 285 tracked_object->set_exec_time_sampled(death_data.run_duration_sample); 286 tracked_object->set_queue_time_total(death_data.queue_duration_sum); 287 tracked_object->set_queue_time_sampled(death_data.queue_duration_sample); 288 tracked_object->set_process_type(AsProtobufProcessType(process_type)); 289 tracked_object->set_process_id(profiler_data.process_id); 290 } 291 } 292 293 #if defined(GOOGLE_CHROME_BUILD) && defined(OS_WIN) 294 void ProductDataToProto(const GoogleUpdateSettings::ProductData& product_data, 295 ProductInfo* product_info) { 296 product_info->set_version(product_data.version); 297 product_info->set_last_update_success_timestamp( 298 product_data.last_success.ToTimeT()); 299 product_info->set_last_error(product_data.last_error_code); 300 product_info->set_last_extra_error(product_data.last_extra_code); 301 if (ProductInfo::InstallResult_IsValid(product_data.last_result)) { 302 product_info->set_last_result( 303 static_cast<ProductInfo::InstallResult>(product_data.last_result)); 304 } 305 } 306 #endif 307 308 #if defined(OS_WIN) 309 struct ScreenDPIInformation { 310 double max_dpi_x; 311 double max_dpi_y; 312 }; 313 314 // Called once for each connected monitor. 315 BOOL CALLBACK GetMonitorDPICallback(HMONITOR, HDC hdc, LPRECT, LPARAM dwData) { 316 const double kMillimetersPerInch = 25.4; 317 ScreenDPIInformation* screen_info = 318 reinterpret_cast<ScreenDPIInformation*>(dwData); 319 // Size of screen, in mm. 320 DWORD size_x = GetDeviceCaps(hdc, HORZSIZE); 321 DWORD size_y = GetDeviceCaps(hdc, VERTSIZE); 322 double dpi_x = (size_x > 0) ? 323 GetDeviceCaps(hdc, HORZRES) / (size_x / kMillimetersPerInch) : 0; 324 double dpi_y = (size_y > 0) ? 325 GetDeviceCaps(hdc, VERTRES) / (size_y / kMillimetersPerInch) : 0; 326 screen_info->max_dpi_x = std::max(dpi_x, screen_info->max_dpi_x); 327 screen_info->max_dpi_y = std::max(dpi_y, screen_info->max_dpi_y); 328 return TRUE; 329 } 330 331 void WriteScreenDPIInformationProto(SystemProfileProto::Hardware* hardware) { 332 HDC desktop_dc = GetDC(NULL); 333 if (desktop_dc) { 334 ScreenDPIInformation si = {0, 0}; 335 if (EnumDisplayMonitors(desktop_dc, NULL, GetMonitorDPICallback, 336 reinterpret_cast<LPARAM>(&si))) { 337 hardware->set_max_dpi_x(si.max_dpi_x); 338 hardware->set_max_dpi_y(si.max_dpi_y); 339 } 340 ReleaseDC(GetDesktopWindow(), desktop_dc); 341 } 342 } 343 344 #endif // defined(OS_WIN) 345 346 #if defined(OS_CHROMEOS) 347 PairedDevice::Type AsBluetoothDeviceType( 348 enum device::BluetoothDevice::DeviceType device_type) { 349 switch (device_type) { 350 case device::BluetoothDevice::DEVICE_UNKNOWN: 351 return PairedDevice::DEVICE_UNKNOWN; 352 case device::BluetoothDevice::DEVICE_COMPUTER: 353 return PairedDevice::DEVICE_COMPUTER; 354 case device::BluetoothDevice::DEVICE_PHONE: 355 return PairedDevice::DEVICE_PHONE; 356 case device::BluetoothDevice::DEVICE_MODEM: 357 return PairedDevice::DEVICE_MODEM; 358 case device::BluetoothDevice::DEVICE_AUDIO: 359 return PairedDevice::DEVICE_AUDIO; 360 case device::BluetoothDevice::DEVICE_CAR_AUDIO: 361 return PairedDevice::DEVICE_CAR_AUDIO; 362 case device::BluetoothDevice::DEVICE_VIDEO: 363 return PairedDevice::DEVICE_VIDEO; 364 case device::BluetoothDevice::DEVICE_PERIPHERAL: 365 return PairedDevice::DEVICE_PERIPHERAL; 366 case device::BluetoothDevice::DEVICE_JOYSTICK: 367 return PairedDevice::DEVICE_JOYSTICK; 368 case device::BluetoothDevice::DEVICE_GAMEPAD: 369 return PairedDevice::DEVICE_GAMEPAD; 370 case device::BluetoothDevice::DEVICE_KEYBOARD: 371 return PairedDevice::DEVICE_KEYBOARD; 372 case device::BluetoothDevice::DEVICE_MOUSE: 373 return PairedDevice::DEVICE_MOUSE; 374 case device::BluetoothDevice::DEVICE_TABLET: 375 return PairedDevice::DEVICE_TABLET; 376 case device::BluetoothDevice::DEVICE_KEYBOARD_MOUSE_COMBO: 377 return PairedDevice::DEVICE_KEYBOARD_MOUSE_COMBO; 378 } 379 380 NOTREACHED(); 381 return PairedDevice::DEVICE_UNKNOWN; 382 } 383 #endif // defined(OS_CHROMEOS) 384 385 // Round a timestamp measured in seconds since epoch to one with a granularity 386 // of an hour. This can be used before uploaded potentially sensitive 387 // timestamps. 388 int64 RoundSecondsToHour(int64 time_in_seconds) { 389 return 3600 * (time_in_seconds / 3600); 390 } 391 392 } // namespace 393 394 GoogleUpdateMetrics::GoogleUpdateMetrics() : is_system_install(false) {} 395 396 GoogleUpdateMetrics::~GoogleUpdateMetrics() {} 397 398 static base::LazyInstance<std::string>::Leaky 399 g_version_extension = LAZY_INSTANCE_INITIALIZER; 400 401 MetricsLog::MetricsLog(const std::string& client_id, int session_id) 402 : MetricsLogBase(client_id, session_id, MetricsLog::GetVersionString()), 403 creation_time_(base::TimeTicks::Now()) { 404 #if defined(OS_CHROMEOS) 405 UpdateMultiProfileUserCount(); 406 #endif 407 } 408 409 MetricsLog::~MetricsLog() {} 410 411 // static 412 void MetricsLog::RegisterPrefs(PrefRegistrySimple* registry) { 413 registry->RegisterListPref(prefs::kStabilityPluginStats); 414 } 415 416 // static 417 std::string MetricsLog::GetVersionString() { 418 chrome::VersionInfo version_info; 419 if (!version_info.is_valid()) { 420 NOTREACHED() << "Unable to retrieve version info."; 421 return std::string(); 422 } 423 424 std::string version = version_info.Version(); 425 if (!version_extension().empty()) 426 version += version_extension(); 427 if (!version_info.IsOfficialBuild()) 428 version.append("-devel"); 429 return version; 430 } 431 432 // static 433 void MetricsLog::set_version_extension(const std::string& extension) { 434 g_version_extension.Get() = extension; 435 } 436 437 // static 438 const std::string& MetricsLog::version_extension() { 439 return g_version_extension.Get(); 440 } 441 442 void MetricsLog::RecordStabilityMetrics( 443 base::TimeDelta incremental_uptime, 444 LogType log_type) { 445 DCHECK_NE(NO_LOG, log_type); 446 DCHECK(!locked()); 447 DCHECK(HasEnvironment()); 448 DCHECK(!HasStabilityMetrics()); 449 450 PrefService* pref = GetPrefService(); 451 DCHECK(pref); 452 453 // Get stability attributes out of Local State, zeroing out stored values. 454 // NOTE: This could lead to some data loss if this report isn't successfully 455 // sent, but that's true for all the metrics. 456 457 WriteRequiredStabilityAttributes(pref); 458 WritePluginStabilityElements(pref); 459 460 // Record recent delta for critical stability metrics. We can't wait for a 461 // restart to gather these, as that delay biases our observation away from 462 // users that run happily for a looooong time. We send increments with each 463 // uma log upload, just as we send histogram data. 464 WriteRealtimeStabilityAttributes(pref, incremental_uptime); 465 466 // Omit some stats unless this is the initial stability log. 467 if (log_type != INITIAL_LOG) 468 return; 469 470 int incomplete_shutdown_count = 471 pref->GetInteger(prefs::kStabilityIncompleteSessionEndCount); 472 pref->SetInteger(prefs::kStabilityIncompleteSessionEndCount, 0); 473 int breakpad_registration_success_count = 474 pref->GetInteger(prefs::kStabilityBreakpadRegistrationSuccess); 475 pref->SetInteger(prefs::kStabilityBreakpadRegistrationSuccess, 0); 476 int breakpad_registration_failure_count = 477 pref->GetInteger(prefs::kStabilityBreakpadRegistrationFail); 478 pref->SetInteger(prefs::kStabilityBreakpadRegistrationFail, 0); 479 int debugger_present_count = 480 pref->GetInteger(prefs::kStabilityDebuggerPresent); 481 pref->SetInteger(prefs::kStabilityDebuggerPresent, 0); 482 int debugger_not_present_count = 483 pref->GetInteger(prefs::kStabilityDebuggerNotPresent); 484 pref->SetInteger(prefs::kStabilityDebuggerNotPresent, 0); 485 486 // TODO(jar): The following are all optional, so we *could* optimize them for 487 // values of zero (and not include them). 488 SystemProfileProto::Stability* stability = 489 uma_proto()->mutable_system_profile()->mutable_stability(); 490 stability->set_incomplete_shutdown_count(incomplete_shutdown_count); 491 stability->set_breakpad_registration_success_count( 492 breakpad_registration_success_count); 493 stability->set_breakpad_registration_failure_count( 494 breakpad_registration_failure_count); 495 stability->set_debugger_present_count(debugger_present_count); 496 stability->set_debugger_not_present_count(debugger_not_present_count); 497 } 498 499 PrefService* MetricsLog::GetPrefService() { 500 return g_browser_process->local_state(); 501 } 502 503 gfx::Size MetricsLog::GetScreenSize() const { 504 return gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().GetSizeInPixel(); 505 } 506 507 float MetricsLog::GetScreenDeviceScaleFactor() const { 508 return gfx::Screen::GetNativeScreen()-> 509 GetPrimaryDisplay().device_scale_factor(); 510 } 511 512 int MetricsLog::GetScreenCount() const { 513 // TODO(scottmg): NativeScreen maybe wrong. http://crbug.com/133312 514 return gfx::Screen::GetNativeScreen()->GetNumDisplays(); 515 } 516 517 void MetricsLog::GetFieldTrialIds( 518 std::vector<ActiveGroupId>* field_trial_ids) const { 519 chrome_variations::GetFieldTrialActiveGroupIds(field_trial_ids); 520 } 521 522 bool MetricsLog::HasEnvironment() const { 523 return uma_proto()->system_profile().has_uma_enabled_date(); 524 } 525 526 bool MetricsLog::HasStabilityMetrics() const { 527 return uma_proto()->system_profile().stability().has_launch_count(); 528 } 529 530 void MetricsLog::WritePluginStabilityElements(PrefService* pref) { 531 // Now log plugin stability info. 532 const ListValue* plugin_stats_list = pref->GetList( 533 prefs::kStabilityPluginStats); 534 if (!plugin_stats_list) 535 return; 536 537 #if defined(ENABLE_PLUGINS) 538 SystemProfileProto::Stability* stability = 539 uma_proto()->mutable_system_profile()->mutable_stability(); 540 for (ListValue::const_iterator iter = plugin_stats_list->begin(); 541 iter != plugin_stats_list->end(); ++iter) { 542 if (!(*iter)->IsType(Value::TYPE_DICTIONARY)) { 543 NOTREACHED(); 544 continue; 545 } 546 DictionaryValue* plugin_dict = static_cast<DictionaryValue*>(*iter); 547 548 // Note that this search is potentially a quadratic operation, but given the 549 // low number of plugins installed on a "reasonable" setup, this should be 550 // fine. 551 // TODO(isherman): Verify that this does not show up as a hotspot in 552 // profiler runs. 553 const SystemProfileProto::Plugin* system_profile_plugin = NULL; 554 std::string plugin_name; 555 plugin_dict->GetString(prefs::kStabilityPluginName, &plugin_name); 556 const SystemProfileProto& system_profile = uma_proto()->system_profile(); 557 for (int i = 0; i < system_profile.plugin_size(); ++i) { 558 if (system_profile.plugin(i).name() == plugin_name) { 559 system_profile_plugin = &system_profile.plugin(i); 560 break; 561 } 562 } 563 564 if (!system_profile_plugin) { 565 NOTREACHED(); 566 continue; 567 } 568 569 SystemProfileProto::Stability::PluginStability* plugin_stability = 570 stability->add_plugin_stability(); 571 *plugin_stability->mutable_plugin() = *system_profile_plugin; 572 573 int launches = 0; 574 plugin_dict->GetInteger(prefs::kStabilityPluginLaunches, &launches); 575 if (launches > 0) 576 plugin_stability->set_launch_count(launches); 577 578 int instances = 0; 579 plugin_dict->GetInteger(prefs::kStabilityPluginInstances, &instances); 580 if (instances > 0) 581 plugin_stability->set_instance_count(instances); 582 583 int crashes = 0; 584 plugin_dict->GetInteger(prefs::kStabilityPluginCrashes, &crashes); 585 if (crashes > 0) 586 plugin_stability->set_crash_count(crashes); 587 588 int loading_errors = 0; 589 plugin_dict->GetInteger(prefs::kStabilityPluginLoadingErrors, 590 &loading_errors); 591 if (loading_errors > 0) 592 plugin_stability->set_loading_error_count(loading_errors); 593 } 594 #endif // defined(ENABLE_PLUGINS) 595 596 pref->ClearPref(prefs::kStabilityPluginStats); 597 } 598 599 // The server refuses data that doesn't have certain values. crashcount and 600 // launchcount are currently "required" in the "stability" group. 601 // TODO(isherman): Stop writing these attributes specially once the migration to 602 // protobufs is complete. 603 void MetricsLog::WriteRequiredStabilityAttributes(PrefService* pref) { 604 int launch_count = pref->GetInteger(prefs::kStabilityLaunchCount); 605 pref->SetInteger(prefs::kStabilityLaunchCount, 0); 606 int crash_count = pref->GetInteger(prefs::kStabilityCrashCount); 607 pref->SetInteger(prefs::kStabilityCrashCount, 0); 608 609 SystemProfileProto::Stability* stability = 610 uma_proto()->mutable_system_profile()->mutable_stability(); 611 stability->set_launch_count(launch_count); 612 stability->set_crash_count(crash_count); 613 } 614 615 void MetricsLog::WriteRealtimeStabilityAttributes( 616 PrefService* pref, 617 base::TimeDelta incremental_uptime) { 618 // Update the stats which are critical for real-time stability monitoring. 619 // Since these are "optional," only list ones that are non-zero, as the counts 620 // are aggregated (summed) server side. 621 622 SystemProfileProto::Stability* stability = 623 uma_proto()->mutable_system_profile()->mutable_stability(); 624 int count = pref->GetInteger(prefs::kStabilityPageLoadCount); 625 if (count) { 626 stability->set_page_load_count(count); 627 pref->SetInteger(prefs::kStabilityPageLoadCount, 0); 628 } 629 630 count = pref->GetInteger(prefs::kStabilityRendererCrashCount); 631 if (count) { 632 stability->set_renderer_crash_count(count); 633 pref->SetInteger(prefs::kStabilityRendererCrashCount, 0); 634 } 635 636 count = pref->GetInteger(prefs::kStabilityExtensionRendererCrashCount); 637 if (count) { 638 stability->set_extension_renderer_crash_count(count); 639 pref->SetInteger(prefs::kStabilityExtensionRendererCrashCount, 0); 640 } 641 642 count = pref->GetInteger(prefs::kStabilityRendererHangCount); 643 if (count) { 644 stability->set_renderer_hang_count(count); 645 pref->SetInteger(prefs::kStabilityRendererHangCount, 0); 646 } 647 648 count = pref->GetInteger(prefs::kStabilityChildProcessCrashCount); 649 if (count) { 650 stability->set_child_process_crash_count(count); 651 pref->SetInteger(prefs::kStabilityChildProcessCrashCount, 0); 652 } 653 654 #if defined(OS_CHROMEOS) 655 count = pref->GetInteger(prefs::kStabilityOtherUserCrashCount); 656 if (count) { 657 stability->set_other_user_crash_count(count); 658 pref->SetInteger(prefs::kStabilityOtherUserCrashCount, 0); 659 } 660 661 count = pref->GetInteger(prefs::kStabilityKernelCrashCount); 662 if (count) { 663 stability->set_kernel_crash_count(count); 664 pref->SetInteger(prefs::kStabilityKernelCrashCount, 0); 665 } 666 667 count = pref->GetInteger(prefs::kStabilitySystemUncleanShutdownCount); 668 if (count) { 669 stability->set_unclean_system_shutdown_count(count); 670 pref->SetInteger(prefs::kStabilitySystemUncleanShutdownCount, 0); 671 } 672 #endif // OS_CHROMEOS 673 674 const uint64 uptime_sec = incremental_uptime.InSeconds(); 675 if (uptime_sec) 676 stability->set_uptime_sec(uptime_sec); 677 } 678 679 void MetricsLog::WritePluginList( 680 const std::vector<content::WebPluginInfo>& plugin_list) { 681 DCHECK(!locked()); 682 683 #if defined(ENABLE_PLUGINS) 684 PluginPrefs* plugin_prefs = GetPluginPrefs(); 685 SystemProfileProto* system_profile = uma_proto()->mutable_system_profile(); 686 for (std::vector<content::WebPluginInfo>::const_iterator iter = 687 plugin_list.begin(); 688 iter != plugin_list.end(); ++iter) { 689 SystemProfileProto::Plugin* plugin = system_profile->add_plugin(); 690 SetPluginInfo(*iter, plugin_prefs, plugin); 691 } 692 #endif // defined(ENABLE_PLUGINS) 693 } 694 695 void MetricsLog::RecordEnvironment( 696 const std::vector<content::WebPluginInfo>& plugin_list, 697 const GoogleUpdateMetrics& google_update_metrics, 698 const std::vector<chrome_variations::ActiveGroupId>& synthetic_trials) { 699 DCHECK(!HasEnvironment()); 700 701 SystemProfileProto* system_profile = uma_proto()->mutable_system_profile(); 702 703 std::string brand_code; 704 if (google_util::GetBrand(&brand_code)) 705 system_profile->set_brand_code(brand_code); 706 707 int enabled_date; 708 bool success = base::StringToInt(GetMetricsEnabledDate(GetPrefService()), 709 &enabled_date); 710 DCHECK(success); 711 712 // Reduce granularity of the enabled_date field to nearest hour. 713 system_profile->set_uma_enabled_date(RoundSecondsToHour(enabled_date)); 714 715 int64 install_date = GetPrefService()->GetInt64(prefs::kInstallDate); 716 717 // Reduce granularity of the install_date field to nearest hour. 718 system_profile->set_install_date(RoundSecondsToHour(install_date)); 719 720 system_profile->set_application_locale( 721 g_browser_process->GetApplicationLocale()); 722 723 SystemProfileProto::Hardware* hardware = system_profile->mutable_hardware(); 724 hardware->set_cpu_architecture(base::SysInfo::OperatingSystemArchitecture()); 725 hardware->set_system_ram_mb(base::SysInfo::AmountOfPhysicalMemoryMB()); 726 #if defined(OS_WIN) 727 hardware->set_dll_base(reinterpret_cast<uint64>(&__ImageBase)); 728 #endif 729 730 SystemProfileProto::Network* network = system_profile->mutable_network(); 731 network->set_connection_type_is_ambiguous( 732 network_observer_.connection_type_is_ambiguous()); 733 network->set_connection_type(network_observer_.connection_type()); 734 network->set_wifi_phy_layer_protocol_is_ambiguous( 735 network_observer_.wifi_phy_layer_protocol_is_ambiguous()); 736 network->set_wifi_phy_layer_protocol( 737 network_observer_.wifi_phy_layer_protocol()); 738 network_observer_.Reset(); 739 740 SystemProfileProto::OS* os = system_profile->mutable_os(); 741 std::string os_name = base::SysInfo::OperatingSystemName(); 742 #if defined(OS_WIN) 743 // TODO(mad): This only checks whether the main process is a Metro process at 744 // upload time; not whether the collected metrics were all gathered from 745 // Metro. This is ok as an approximation for now, since users will rarely be 746 // switching from Metro to Desktop mode; but we should re-evaluate whether we 747 // can distinguish metrics more cleanly in the future: http://crbug.com/140568 748 if (base::win::IsMetroProcess()) 749 os_name += " (Metro)"; 750 #endif 751 os->set_name(os_name); 752 os->set_version(base::SysInfo::OperatingSystemVersion()); 753 #if defined(OS_ANDROID) 754 os->set_fingerprint( 755 base::android::BuildInfo::GetInstance()->android_build_fp()); 756 #endif 757 758 base::CPU cpu_info; 759 SystemProfileProto::Hardware::CPU* cpu = hardware->mutable_cpu(); 760 cpu->set_vendor_name(cpu_info.vendor_name()); 761 cpu->set_signature(cpu_info.signature()); 762 763 const gpu::GPUInfo& gpu_info = 764 GpuDataManager::GetInstance()->GetGPUInfo(); 765 SystemProfileProto::Hardware::Graphics* gpu = hardware->mutable_gpu(); 766 gpu->set_vendor_id(gpu_info.gpu.vendor_id); 767 gpu->set_device_id(gpu_info.gpu.device_id); 768 gpu->set_driver_version(gpu_info.driver_version); 769 gpu->set_driver_date(gpu_info.driver_date); 770 SystemProfileProto::Hardware::Graphics::PerformanceStatistics* 771 gpu_performance = gpu->mutable_performance_statistics(); 772 gpu_performance->set_graphics_score(gpu_info.performance_stats.graphics); 773 gpu_performance->set_gaming_score(gpu_info.performance_stats.gaming); 774 gpu_performance->set_overall_score(gpu_info.performance_stats.overall); 775 gpu->set_gl_vendor(gpu_info.gl_vendor); 776 gpu->set_gl_renderer(gpu_info.gl_renderer); 777 778 const gfx::Size display_size = GetScreenSize(); 779 hardware->set_primary_screen_width(display_size.width()); 780 hardware->set_primary_screen_height(display_size.height()); 781 hardware->set_primary_screen_scale_factor(GetScreenDeviceScaleFactor()); 782 hardware->set_screen_count(GetScreenCount()); 783 784 #if defined(OS_WIN) 785 WriteScreenDPIInformationProto(hardware); 786 #endif 787 788 WriteGoogleUpdateProto(google_update_metrics); 789 790 WritePluginList(plugin_list); 791 792 std::vector<ActiveGroupId> field_trial_ids; 793 GetFieldTrialIds(&field_trial_ids); 794 WriteFieldTrials(field_trial_ids, system_profile); 795 WriteFieldTrials(synthetic_trials, system_profile); 796 797 #if defined(OS_CHROMEOS) 798 PerfDataProto perf_data_proto; 799 if (perf_provider_.GetPerfData(&perf_data_proto)) 800 uma_proto()->add_perf_data()->Swap(&perf_data_proto); 801 802 // BluetoothAdapterFactory::GetAdapter is synchronous on Chrome OS; if that 803 // changes this will fail at the DCHECK(). 804 device::BluetoothAdapterFactory::GetAdapter( 805 base::Bind(&MetricsLog::SetBluetoothAdapter, 806 base::Unretained(this))); 807 DCHECK(adapter_.get()); 808 WriteBluetoothProto(hardware); 809 UpdateMultiProfileUserCount(); 810 #endif 811 812 std::string serialied_system_profile; 813 std::string base64_system_profile; 814 if (system_profile->SerializeToString(&serialied_system_profile)) { 815 base::Base64Encode(serialied_system_profile, &base64_system_profile); 816 PrefService* local_state = GetPrefService(); 817 local_state->SetString(prefs::kStabilitySavedSystemProfile, 818 base64_system_profile); 819 local_state->SetString(prefs::kStabilitySavedSystemProfileHash, 820 ComputeSHA1(serialied_system_profile)); 821 } 822 } 823 824 bool MetricsLog::LoadSavedEnvironmentFromPrefs() { 825 PrefService* local_state = GetPrefService(); 826 const std::string base64_system_profile = 827 local_state->GetString(prefs::kStabilitySavedSystemProfile); 828 if (base64_system_profile.empty()) 829 return false; 830 831 const std::string system_profile_hash = 832 local_state->GetString(prefs::kStabilitySavedSystemProfileHash); 833 local_state->ClearPref(prefs::kStabilitySavedSystemProfile); 834 local_state->ClearPref(prefs::kStabilitySavedSystemProfileHash); 835 836 SystemProfileProto* system_profile = uma_proto()->mutable_system_profile(); 837 std::string serialied_system_profile; 838 return base::Base64Decode(base64_system_profile, &serialied_system_profile) && 839 ComputeSHA1(serialied_system_profile) == system_profile_hash && 840 system_profile->ParseFromString(serialied_system_profile); 841 } 842 843 void MetricsLog::RecordProfilerData( 844 const tracked_objects::ProcessDataSnapshot& process_data, 845 int process_type) { 846 DCHECK(!locked()); 847 848 if (tracked_objects::GetTimeSourceType() != 849 tracked_objects::TIME_SOURCE_TYPE_WALL_TIME) { 850 // We currently only support the default time source, wall clock time. 851 return; 852 } 853 854 ProfilerEventProto* profile; 855 if (!uma_proto()->profiler_event_size()) { 856 // For the first process's data, add a new field to the protocol buffer. 857 profile = uma_proto()->add_profiler_event(); 858 profile->set_profile_type(ProfilerEventProto::STARTUP_PROFILE); 859 profile->set_time_source(ProfilerEventProto::WALL_CLOCK_TIME); 860 } else { 861 // For the remaining calls, re-use the existing field. 862 profile = uma_proto()->mutable_profiler_event(0); 863 } 864 865 WriteProfilerData(process_data, process_type, profile); 866 } 867 868 void MetricsLog::RecordOmniboxOpenedURL(const OmniboxLog& log) { 869 DCHECK(!locked()); 870 871 std::vector<base::string16> terms; 872 const int num_terms = 873 static_cast<int>(Tokenize(log.text, base::kWhitespaceUTF16, &terms)); 874 875 OmniboxEventProto* omnibox_event = uma_proto()->add_omnibox_event(); 876 omnibox_event->set_time(MetricsLogBase::GetCurrentTime()); 877 if (log.tab_id != -1) { 878 // If we know what tab the autocomplete URL was opened in, log it. 879 omnibox_event->set_tab_id(log.tab_id); 880 } 881 omnibox_event->set_typed_length(log.text.length()); 882 omnibox_event->set_just_deleted_text(log.just_deleted_text); 883 omnibox_event->set_num_typed_terms(num_terms); 884 omnibox_event->set_selected_index(log.selected_index); 885 if (log.completed_length != base::string16::npos) 886 omnibox_event->set_completed_length(log.completed_length); 887 if (log.elapsed_time_since_user_first_modified_omnibox != 888 base::TimeDelta::FromMilliseconds(-1)) { 889 // Only upload the typing duration if it is set/valid. 890 omnibox_event->set_typing_duration_ms( 891 log.elapsed_time_since_user_first_modified_omnibox.InMilliseconds()); 892 } 893 omnibox_event->set_duration_since_last_default_match_update_ms( 894 log.elapsed_time_since_last_change_to_default_match.InMilliseconds()); 895 omnibox_event->set_current_page_classification( 896 AsOmniboxEventPageClassification(log.current_page_classification)); 897 omnibox_event->set_input_type(AsOmniboxEventInputType(log.input_type)); 898 omnibox_event->set_is_top_result_hidden_in_dropdown( 899 log.result.ShouldHideTopMatch()); 900 901 for (AutocompleteResult::const_iterator i(log.result.begin()); 902 i != log.result.end(); ++i) { 903 OmniboxEventProto::Suggestion* suggestion = omnibox_event->add_suggestion(); 904 suggestion->set_provider(i->provider->AsOmniboxEventProviderType()); 905 suggestion->set_result_type(AsOmniboxEventResultType(i->type)); 906 suggestion->set_relevance(i->relevance); 907 if (i->typed_count != -1) 908 suggestion->set_typed_count(i->typed_count); 909 suggestion->set_is_starred(i->starred); 910 } 911 for (ProvidersInfo::const_iterator i(log.providers_info.begin()); 912 i != log.providers_info.end(); ++i) { 913 OmniboxEventProto::ProviderInfo* provider_info = 914 omnibox_event->add_provider_info(); 915 provider_info->CopyFrom(*i); 916 } 917 918 ++num_events_; 919 } 920 921 void MetricsLog::WriteGoogleUpdateProto( 922 const GoogleUpdateMetrics& google_update_metrics) { 923 #if defined(GOOGLE_CHROME_BUILD) && defined(OS_WIN) 924 SystemProfileProto::GoogleUpdate* google_update = 925 uma_proto()->mutable_system_profile()->mutable_google_update(); 926 927 google_update->set_is_system_install(google_update_metrics.is_system_install); 928 929 if (!google_update_metrics.last_started_au.is_null()) { 930 google_update->set_last_automatic_start_timestamp( 931 google_update_metrics.last_started_au.ToTimeT()); 932 } 933 934 if (!google_update_metrics.last_checked.is_null()) { 935 google_update->set_last_update_check_timestamp( 936 google_update_metrics.last_checked.ToTimeT()); 937 } 938 939 if (!google_update_metrics.google_update_data.version.empty()) { 940 ProductDataToProto(google_update_metrics.google_update_data, 941 google_update->mutable_google_update_status()); 942 } 943 944 if (!google_update_metrics.product_data.version.empty()) { 945 ProductDataToProto(google_update_metrics.product_data, 946 google_update->mutable_client_status()); 947 } 948 #endif // defined(GOOGLE_CHROME_BUILD) && defined(OS_WIN) 949 } 950 951 void MetricsLog::SetBluetoothAdapter( 952 scoped_refptr<device::BluetoothAdapter> adapter) { 953 adapter_ = adapter; 954 } 955 956 void MetricsLog::WriteBluetoothProto( 957 SystemProfileProto::Hardware* hardware) { 958 #if defined(OS_CHROMEOS) 959 SystemProfileProto::Hardware::Bluetooth* bluetooth = 960 hardware->mutable_bluetooth(); 961 962 bluetooth->set_is_present(adapter_->IsPresent()); 963 bluetooth->set_is_enabled(adapter_->IsPowered()); 964 965 device::BluetoothAdapter::DeviceList devices = adapter_->GetDevices(); 966 for (device::BluetoothAdapter::DeviceList::iterator iter = 967 devices.begin(); iter != devices.end(); ++iter) { 968 PairedDevice* paired_device = bluetooth->add_paired_device(); 969 970 device::BluetoothDevice* device = *iter; 971 paired_device->set_bluetooth_class(device->GetBluetoothClass()); 972 paired_device->set_type(AsBluetoothDeviceType(device->GetDeviceType())); 973 974 // address is xx:xx:xx:xx:xx:xx, extract the first three components and 975 // pack into a uint32 976 std::string address = device->GetAddress(); 977 if (address.size() > 9 && 978 address[2] == ':' && address[5] == ':' && address[8] == ':') { 979 std::string vendor_prefix_str; 980 uint64 vendor_prefix; 981 982 base::RemoveChars(address.substr(0, 9), ":", &vendor_prefix_str); 983 DCHECK_EQ(6U, vendor_prefix_str.size()); 984 base::HexStringToUInt64(vendor_prefix_str, &vendor_prefix); 985 986 paired_device->set_vendor_prefix(vendor_prefix); 987 } 988 989 paired_device->set_vendor_id(device->GetVendorID()); 990 paired_device->set_product_id(device->GetProductID()); 991 paired_device->set_device_id(device->GetDeviceID()); 992 } 993 #endif // defined(OS_CHROMEOS) 994 } 995 996 #if defined(OS_CHROMEOS) 997 void MetricsLog::UpdateMultiProfileUserCount() { 998 if (chromeos::UserManager::IsInitialized() && 999 chromeos::UserManager::Get()->IsMultipleProfilesAllowed()) { 1000 uint32 user_count = chromeos::UserManager::Get() 1001 ->GetLoggedInUsers().size(); 1002 SystemProfileProto* system_profile = uma_proto()->mutable_system_profile(); 1003 1004 // We invalidate the user count if it changed while the log was open. 1005 if (system_profile->has_multi_profile_user_count() && 1006 user_count != system_profile->multi_profile_user_count()) 1007 user_count = 0; 1008 1009 system_profile->set_multi_profile_user_count(user_count); 1010 } 1011 } 1012 #endif 1013
