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