[UMA] Include field trial tuples in the UMA upload.

chrome/browser/metrics/metrics_log.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/metrics/metrics_log.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 30 matching lines @@
 #define OPEN_ELEMENT_FOR_SCOPE(name) ScopedElement scoped_element(this, name)
 
 // http://blogs.msdn.com/oldnewthing/archive/2004/10/25/247180.aspx
 #if defined(OS_WIN)
 extern "C" IMAGE_DOS_HEADER __ImageBase;
 #endif
 
 using content::GpuDataManager;
 using metrics::OmniboxEventProto;
 using metrics::SystemProfileProto;
+typedef base::FieldTrial::NameGroupId NameGroupId;
 
 namespace {
 
 // Returns the date at which the current metrics client ID was created as
 // a string containing milliseconds since the epoch, or "0" if none was found.
-std::string GetInstallDate() {
-  PrefService* pref = g_browser_process->local_state();
-  if (pref) {
-    return pref->GetString(prefs::kMetricsClientIDTimestamp);
-  } else {
+std::string GetInstallDate(PrefService* pref) {
+  if (!pref) {
     NOTREACHED();
     return "0";
   }
+
+  return pref->GetString(prefs::kMetricsClientIDTimestamp);
 }
 
 OmniboxEventProto::InputType AsOmniboxEventInputType(
     AutocompleteInput::Type type) {
   switch (type) {
     case AutocompleteInput::INVALID:
       return OmniboxEventProto::INVALID;
     case AutocompleteInput::UNKNOWN:
       return OmniboxEventProto::UNKNOWN;
     case AutocompleteInput::REQUESTED_URL:
@@ skipping 90 matching lines @@
 void SetPluginInfo(const webkit::WebPluginInfo& plugin_info,
                    const PluginPrefs* plugin_prefs,
                    SystemProfileProto::Plugin* plugin) {
   plugin->set_name(UTF16ToUTF8(plugin_info.name));
   plugin->set_filename(plugin_info.path.BaseName().AsUTF8Unsafe());
   plugin->set_version(UTF16ToUTF8(plugin_info.version));
   if (plugin_prefs)
     plugin->set_is_disabled(!plugin_prefs->IsPluginEnabled(plugin_info));
 }
 
+void WriteFieldTrials(const std::vector<NameGroupId>& field_trial_ids,
+                      SystemProfileProto* system_profile) {
+  for (std::vector<NameGroupId>::const_iterator it = field_trial_ids.begin();
+       it != field_trial_ids.end(); ++it) {
+    SystemProfileProto::FieldTrial* field_trial =
+        system_profile->add_field_trial();
+    field_trial->set_name_id(it->name);
+    field_trial->set_group_id(it->group);
+  }
+}
+
 }  // namespace
 
 static base::LazyInstance<std::string>::Leaky
   g_version_extension = LAZY_INSTANCE_INITIALIZER;
 
 MetricsLog::MetricsLog(const std::string& client_id, int session_id)
     : MetricsLogBase(client_id, session_id, MetricsLog::GetVersionString()) {}
 
 MetricsLog::~MetricsLog() {}
 
@@ skipping 39 matching lines @@
   g_version_extension.Get() = extension;
 }
 
 // static
 const std::string& MetricsLog::version_extension() {
   return g_version_extension.Get();
 }
 
 void MetricsLog::RecordIncrementalStabilityElements(
     const std::vector<webkit::WebPluginInfo>& plugin_list) {
-  DCHECK(!locked_);
+  DCHECK(!locked());
 
-  PrefService* pref = g_browser_process->local_state();
+  PrefService* pref = GetPrefService();
   DCHECK(pref);
 
   OPEN_ELEMENT_FOR_SCOPE("profile");
   WriteCommonEventAttributes();
 
   WriteInstallElement();
 
   {
     OPEN_ELEMENT_FOR_SCOPE("stability");  // Minimal set of stability elements.
     WriteRequiredStabilityAttributes(pref);
     WriteRealtimeStabilityAttributes(pref);
 
     WritePluginStabilityElements(plugin_list, pref);
   }
 }
 
+PrefService* MetricsLog::GetPrefService() {
+  return g_browser_process->local_state();
+}
+
+gfx::Size MetricsLog::GetScreenSize() const {
+  return gfx::Screen::GetPrimaryMonitorSize();
+}
+
+int MetricsLog::GetScreenCount() const {
+  return gfx::Screen::GetNumMonitors();
+}
+
+
+void MetricsLog::GetFieldTrialIds(
+    std::vector<NameGroupId>* field_trial_ids) const {
+  base::FieldTrialList::GetFieldTrialNameGroupIds(field_trial_ids);
+}
+
 void MetricsLog::WriteStabilityElement(
     const std::vector<webkit::WebPluginInfo>& plugin_list,
     PrefService* pref) {
-  DCHECK(!locked_);
+  DCHECK(!locked());
 
   // Get stability attributes out of Local State, zeroing out stored values.
   // NOTE: This could lead to some data loss if this report isn't successfully
   //       sent, but that's true for all the metrics.
 
   OPEN_ELEMENT_FOR_SCOPE("stability");
   WriteRequiredStabilityAttributes(pref);
   WriteRealtimeStabilityAttributes(pref);
 
   int incomplete_shutdown_count =
@@ skipping 19 matching lines @@
   WriteIntAttribute("incompleteshutdowncount", incomplete_shutdown_count);
   WriteIntAttribute("breakpadregistrationok",
                     breakpad_registration_success_count);
   WriteIntAttribute("breakpadregistrationfail",
                     breakpad_registration_failure_count);
   WriteIntAttribute("debuggerpresent", debugger_present_count);
   WriteIntAttribute("debuggernotpresent", debugger_not_present_count);
 
   // Write the protobuf version.
   SystemProfileProto::Stability* stability =
-      uma_proto_.mutable_system_profile()->mutable_stability();
+      uma_proto()->mutable_system_profile()->mutable_stability();
   stability->set_incomplete_shutdown_count(incomplete_shutdown_count);
   stability->set_breakpad_registration_success_count(
       breakpad_registration_success_count);
   stability->set_breakpad_registration_failure_count(
       breakpad_registration_failure_count);
   stability->set_debugger_present_count(debugger_present_count);
   stability->set_debugger_not_present_count(debugger_not_present_count);
 
   WritePluginStabilityElements(plugin_list, pref);
 }
 
 void MetricsLog::WritePluginStabilityElements(
     const std::vector<webkit::WebPluginInfo>& plugin_list,
     PrefService* pref) {
   // Now log plugin stability info.
   const ListValue* plugin_stats_list = pref->GetList(
       prefs::kStabilityPluginStats);
   if (!plugin_stats_list)
     return;
 
   OPEN_ELEMENT_FOR_SCOPE("plugins");
   SystemProfileProto::Stability* stability =
-      uma_proto_.mutable_system_profile()->mutable_stability();
+      uma_proto()->mutable_system_profile()->mutable_stability();
   PluginPrefs* plugin_prefs = GetPluginPrefs();
   for (ListValue::const_iterator iter = plugin_stats_list->begin();
        iter != plugin_stats_list->end(); ++iter) {
     if (!(*iter)->IsType(Value::TYPE_DICTIONARY)) {
       NOTREACHED();
       continue;
     }
     DictionaryValue* plugin_dict = static_cast<DictionaryValue*>(*iter);
 
     std::string plugin_name;
@@ skipping 64 matching lines @@
   pref->SetInteger(prefs::kStabilityLaunchCount, 0);
   int crash_count = pref->GetInteger(prefs::kStabilityCrashCount);
   pref->SetInteger(prefs::kStabilityCrashCount, 0);
 
   // Write the XML version.
   WriteIntAttribute("launchcount", launch_count);
   WriteIntAttribute("crashcount", crash_count);
 
   // Write the protobuf version.
   SystemProfileProto::Stability* stability =
-      uma_proto_.mutable_system_profile()->mutable_stability();
+      uma_proto()->mutable_system_profile()->mutable_stability();
   stability->set_launch_count(launch_count);
   stability->set_crash_count(crash_count);
 }
 
 void MetricsLog::WriteRealtimeStabilityAttributes(PrefService* pref) {
   // Update the stats which are critical for real-time stability monitoring.
   // Since these are "optional," only list ones that are non-zero, as the counts
   // are aggergated (summed) server side.
 
   SystemProfileProto::Stability* stability =
-      uma_proto_.mutable_system_profile()->mutable_stability();
+      uma_proto()->mutable_system_profile()->mutable_stability();
   int count = pref->GetInteger(prefs::kStabilityPageLoadCount);
   if (count) {
     WriteIntAttribute("pageloadcount", count);
     stability->set_page_load_count(count);
     pref->SetInteger(prefs::kStabilityPageLoadCount, 0);
   }
 
   count = pref->GetInteger(prefs::kStabilityRendererCrashCount);
   if (count) {
     WriteIntAttribute("renderercrashcount", count);
@@ skipping 44 matching lines @@
 
   int64 recent_duration = GetIncrementalUptime(pref);
   if (recent_duration) {
     WriteInt64Attribute("uptimesec", recent_duration);
     stability->set_uptime_sec(recent_duration);
   }
 }
 
 void MetricsLog::WritePluginList(
     const std::vector<webkit::WebPluginInfo>& plugin_list) {
-  DCHECK(!locked_);
+  DCHECK(!locked());
 
   PluginPrefs* plugin_prefs = GetPluginPrefs();
 
   OPEN_ELEMENT_FOR_SCOPE("plugins");
-  SystemProfileProto* system_profile = uma_proto_.mutable_system_profile();
+  SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
   for (std::vector<webkit::WebPluginInfo>::const_iterator iter =
            plugin_list.begin();
        iter != plugin_list.end(); ++iter) {
     std::string base64_name_hash;
     uint64 numeric_name_hash_ignored;
     CreateHashes(UTF16ToUTF8(iter->name),
                  &base64_name_hash,
                  &numeric_name_hash_ignored);
 
     std::string filename_bytes = iter->path.BaseName().AsUTF8Unsafe();
@@ skipping 14 matching lines @@
     if (plugin_prefs)
       WriteIntAttribute("disabled", !plugin_prefs->IsPluginEnabled(*iter));
 
     // Write the protobuf version.
     SystemProfileProto::Plugin* plugin = system_profile->add_plugin();
     SetPluginInfo(*iter, plugin_prefs, plugin);
   }
 }
 
 void MetricsLog::WriteInstallElement() {
-  std::string install_date = GetInstallDate();
+  std::string install_date = GetInstallDate(GetPrefService());
 
   // Write the XML version.
   OPEN_ELEMENT_FOR_SCOPE("install");
   WriteAttribute("installdate", install_date);
   WriteIntAttribute("buildid", 0);  // We're using appversion instead.
 
   // Write the protobuf version.
   int numeric_install_date;
   bool success = base::StringToInt(install_date, &numeric_install_date);
   DCHECK(success);
-  uma_proto_.mutable_system_profile()->set_install_date(numeric_install_date);
+  uma_proto()->mutable_system_profile()->set_install_date(numeric_install_date);
 }
 
 void MetricsLog::RecordEnvironment(
          const std::vector<webkit::WebPluginInfo>& plugin_list,
          const DictionaryValue* profile_metrics) {
-  DCHECK(!locked_);
+  DCHECK(!locked());
 
-  PrefService* pref = g_browser_process->local_state();
+  PrefService* pref = GetPrefService();
 
   OPEN_ELEMENT_FOR_SCOPE("profile");
   WriteCommonEventAttributes();
 
   WriteInstallElement();
 
   WritePluginList(plugin_list);
 
   WriteStabilityElement(plugin_list, pref);
 
-  SystemProfileProto* system_profile = uma_proto_.mutable_system_profile();
+  SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
   system_profile->set_application_locale(
       content::GetContentClient()->browser()->GetApplicationLocale());
 
   SystemProfileProto::Hardware* hardware = system_profile->mutable_hardware();
   {
     std::string cpu_architecture = base::SysInfo::CPUArchitecture();
 
     // Write the XML version.
     OPEN_ELEMENT_FOR_SCOPE("cpu");
     WriteAttribute("arch", cpu_architecture);
@@ skipping 52 matching lines @@
     gpu->set_driver_version(gpu_info.driver_version);
     gpu->set_driver_date(gpu_info.driver_date);
     SystemProfileProto::Hardware::Graphics::PerformanceStatistics*
         gpu_performance = gpu->mutable_performance_statistics();
     gpu_performance->set_graphics_score(gpu_performance_stats.graphics);
     gpu_performance->set_gaming_score(gpu_performance_stats.gaming);
     gpu_performance->set_overall_score(gpu_performance_stats.overall);
   }
 
   {
-    const gfx::Size display_size = gfx::Screen::GetPrimaryMonitorSize();
+    const gfx::Size display_size = GetScreenSize();
     int display_width = display_size.width();
     int display_height = display_size.height();
-    int screen_count = gfx::Screen::GetNumMonitors();
+    int screen_count = GetScreenCount();
 
     // Write the XML version.
     OPEN_ELEMENT_FOR_SCOPE("display");
     WriteIntAttribute("xsize", display_width);
     WriteIntAttribute("ysize", display_height);
     WriteIntAttribute("screens", screen_count);
 
     // Write the protobuf version.
     hardware->set_primary_screen_width(display_width);
     hardware->set_primary_screen_height(display_height);
@@ skipping 27 matching lines @@
     }
   }
 
   {
     OPEN_ELEMENT_FOR_SCOPE("keywords");
     WriteIntAttribute("count", pref->GetInteger(prefs::kNumKeywords));
   }
 
   if (profile_metrics)
     WriteAllProfilesMetrics(*profile_metrics);
+
+  std::vector<NameGroupId> field_trial_ids;
+  GetFieldTrialIds(&field_trial_ids);
+  WriteFieldTrials(field_trial_ids, system_profile);
 }
 
 void MetricsLog::WriteAllProfilesMetrics(
     const DictionaryValue& all_profiles_metrics) {
   const std::string profile_prefix(prefs::kProfilePrefix);
   for (DictionaryValue::key_iterator i = all_profiles_metrics.begin_keys();
        i != all_profiles_metrics.end_keys(); ++i) {
     const std::string& key_name = *i;
     if (key_name.compare(0, profile_prefix.size(), profile_prefix) == 0) {
       DictionaryValue* profile;
@@ skipping 46 matching lines @@
 
         default:
           NOTREACHED();
           break;
       }
     }
   }
 }
 
 void MetricsLog::RecordOmniboxOpenedURL(const AutocompleteLog& log) {
-  DCHECK(!locked_);
+  DCHECK(!locked());
 
   // Write the XML version.
   OPEN_ELEMENT_FOR_SCOPE("uielement");
   WriteAttribute("action", "autocomplete");
   WriteAttribute("targetidhash", "");
   // TODO(kochi): Properly track windows.
   WriteIntAttribute("window", 0);
   if (log.tab_id != -1) {
     // If we know what tab the autocomplete URL was opened in, log it.
     WriteIntAttribute("tab", static_cast<int>(log.tab_id));
@@ skipping 28 matching lines @@
         WriteAttribute("provider", i->provider->name());
       const std::string result_type(AutocompleteMatch::TypeToString(i->type));
       if (!result_type.empty())
         WriteAttribute("resulttype", result_type);
       WriteIntAttribute("relevance", i->relevance);
       WriteIntAttribute("isstarred", i->starred ? 1 : 0);
     }
   }
 
   // Write the protobuf version.
-  OmniboxEventProto* omnibox_event = uma_proto_.add_omnibox_event();
+  OmniboxEventProto* omnibox_event = uma_proto()->add_omnibox_event();
   omnibox_event->set_time(MetricsLogBase::GetCurrentTime());
   if (log.tab_id != -1) {
     // If we know what tab the autocomplete URL was opened in, log it.
     omnibox_event->set_tab_id(log.tab_id);
   }
   omnibox_event->set_typed_length(log.text.length());
   omnibox_event->set_selected_index(log.selected_index);
   omnibox_event->set_completed_length(log.inline_autocompleted_length);
   omnibox_event->set_input_type(AsOmniboxEventInputType(log.input_type));
   for (AutocompleteResult::const_iterator i(log.result.begin());
        i != log.result.end(); ++i) {
     OmniboxEventProto::Suggestion* suggestion = omnibox_event->add_suggestion();
     suggestion->set_provider(AsOmniboxEventProviderType(i->provider));
     suggestion->set_result_type(AsOmniboxEventResultType(i->type));
     suggestion->set_relevance(i->relevance);
     suggestion->set_is_starred(i->starred);
   }
 
   ++num_events_;
 }