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.
GetMetricsEnabledDate(PrefService * pref)85 std::string GetMetricsEnabledDate(PrefService* pref) {
86 if (!pref) {
87 NOTREACHED();
88 return "0";
89 }
90
91 return pref->GetString(prefs::kMetricsClientIDTimestamp);
92 }
93
AsOmniboxEventInputType(AutocompleteInput::Type type)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
AsOmniboxEventResultType(AutocompleteMatch::Type type)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
AsOmniboxEventPageClassification(AutocompleteInput::PageClassification page_classification)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
AsProtobufProcessType(int process_type)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.
ComputeSHA1(const std::string & data)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.
GetPluginPrefs()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|.
SetPluginInfo(const content::WebPluginInfo & plugin_info,const PluginPrefs * plugin_prefs,SystemProfileProto::Plugin * plugin)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
WriteFieldTrials(const std::vector<ActiveGroupId> & field_trial_ids,SystemProfileProto * system_profile)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
WriteProfilerData(const ProcessDataSnapshot & profiler_data,int process_type,ProfilerEventProto * performance_profile)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)
ProductDataToProto(const GoogleUpdateSettings::ProductData & product_data,ProductInfo * product_info)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.
GetMonitorDPICallback(HMONITOR,HDC hdc,LPRECT,LPARAM dwData)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
WriteScreenDPIInformationProto(SystemProfileProto::Hardware * hardware)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)
AsBluetoothDeviceType(enum device::BluetoothDevice::DeviceType device_type)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.
RoundSecondsToHour(int64 time_in_seconds)388 int64 RoundSecondsToHour(int64 time_in_seconds) {
389 return 3600 * (time_in_seconds / 3600);
390 }
391
392 } // namespace
393
GoogleUpdateMetrics()394 GoogleUpdateMetrics::GoogleUpdateMetrics() : is_system_install(false) {}
395
~GoogleUpdateMetrics()396 GoogleUpdateMetrics::~GoogleUpdateMetrics() {}
397
398 static base::LazyInstance<std::string>::Leaky
399 g_version_extension = LAZY_INSTANCE_INITIALIZER;
400
MetricsLog(const std::string & client_id,int session_id)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
~MetricsLog()409 MetricsLog::~MetricsLog() {}
410
411 // static
RegisterPrefs(PrefRegistrySimple * registry)412 void MetricsLog::RegisterPrefs(PrefRegistrySimple* registry) {
413 registry->RegisterListPref(prefs::kStabilityPluginStats);
414 }
415
416 // static
GetVersionString()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
set_version_extension(const std::string & extension)433 void MetricsLog::set_version_extension(const std::string& extension) {
434 g_version_extension.Get() = extension;
435 }
436
437 // static
version_extension()438 const std::string& MetricsLog::version_extension() {
439 return g_version_extension.Get();
440 }
441
RecordStabilityMetrics(base::TimeDelta incremental_uptime,LogType log_type)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
GetPrefService()499 PrefService* MetricsLog::GetPrefService() {
500 return g_browser_process->local_state();
501 }
502
GetScreenSize() const503 gfx::Size MetricsLog::GetScreenSize() const {
504 return gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().GetSizeInPixel();
505 }
506
GetScreenDeviceScaleFactor() const507 float MetricsLog::GetScreenDeviceScaleFactor() const {
508 return gfx::Screen::GetNativeScreen()->
509 GetPrimaryDisplay().device_scale_factor();
510 }
511
GetScreenCount() const512 int MetricsLog::GetScreenCount() const {
513 // TODO(scottmg): NativeScreen maybe wrong. http://crbug.com/133312
514 return gfx::Screen::GetNativeScreen()->GetNumDisplays();
515 }
516
GetFieldTrialIds(std::vector<ActiveGroupId> * field_trial_ids) const517 void MetricsLog::GetFieldTrialIds(
518 std::vector<ActiveGroupId>* field_trial_ids) const {
519 chrome_variations::GetFieldTrialActiveGroupIds(field_trial_ids);
520 }
521
HasEnvironment() const522 bool MetricsLog::HasEnvironment() const {
523 return uma_proto()->system_profile().has_uma_enabled_date();
524 }
525
HasStabilityMetrics() const526 bool MetricsLog::HasStabilityMetrics() const {
527 return uma_proto()->system_profile().stability().has_launch_count();
528 }
529
WritePluginStabilityElements(PrefService * pref)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.
WriteRequiredStabilityAttributes(PrefService * pref)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
WriteRealtimeStabilityAttributes(PrefService * pref,base::TimeDelta incremental_uptime)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
WritePluginList(const std::vector<content::WebPluginInfo> & plugin_list)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
RecordEnvironment(const std::vector<content::WebPluginInfo> & plugin_list,const GoogleUpdateMetrics & google_update_metrics,const std::vector<chrome_variations::ActiveGroupId> & synthetic_trials)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
LoadSavedEnvironmentFromPrefs()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
RecordProfilerData(const tracked_objects::ProcessDataSnapshot & process_data,int process_type)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
RecordOmniboxOpenedURL(const OmniboxLog & log)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
WriteGoogleUpdateProto(const GoogleUpdateMetrics & google_update_metrics)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
SetBluetoothAdapter(scoped_refptr<device::BluetoothAdapter> adapter)951 void MetricsLog::SetBluetoothAdapter(
952 scoped_refptr<device::BluetoothAdapter> adapter) {
953 adapter_ = adapter;
954 }
955
WriteBluetoothProto(SystemProfileProto::Hardware * hardware)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)
UpdateMultiProfileUserCount()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