[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 35 matching lines @@
 #endif
 
 using content::GpuDataManager;
 using metrics::OmniboxEventProto;
 using metrics::SystemProfileProto;
 
 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<base::FieldTrial::NameGroupId>& field_trial_ids,
+    SystemProfileProto* system_profile) {
+  for (std::vector<base::FieldTrial::NameGroupId>::const_iterator it =
+           field_trial_ids.begin(); it != field_trial_ids.end(); ++it) {
+    SystemProfileProto::FieldTrial* field_trial =
+        system_profile->add_field_trial();

[jar (doing other things), 2012/03/01 05:32:42]

personal style nit: This API seems strange to me.  In general, it is nicer to
form the object (in this case the SystemProfileProto::FieldTrial) and flesh it
out, before inserting it into the container.  In this way, the contain contains
only valid instances, and can even "check" on insertion for some elements of
correctness.  

[Ilya Sherman, 2012/03/01 06:41:50]

Alas, this is just how the C++ protocol buffer API works.

+    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();
+}
+
+void MetricsLog::GetFieldTrialIds(
+    std::vector<base::FieldTrial::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 103 matching lines @@
     }
   }
 
   {
     OPEN_ELEMENT_FOR_SCOPE("keywords");
     WriteIntAttribute("count", pref->GetInteger(prefs::kNumKeywords));
   }
 
   if (profile_metrics)
     WriteAllProfilesMetrics(*profile_metrics);
+
+  std::vector<base::FieldTrial::NameGroupId> field_trial_ids;
+  GetFieldTrialIds(&field_trial_ids);
+  WriteFieldTrials(field_trial_ids, system_profile);

[jar (doing other things), 2012/03/01 05:32:42]

This is tempting to make a method on system_profile, rather than a static
method, that takes a pointer.

[Ilya Sherman, 2012/03/01 06:41:50]

Again, system_profile is a protocol buffer, so I have no control over the
methods defined on it.  I could add a wrapper class, but that just doesn't seem
worth it.

 }
 
 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());

[jar (doing other things), 2012/03/01 05:32:42]

I think this is the same pattern that had me wondering earlier.  Is there a
reason to have mutable instances in the protobuf, rather than completing their
construction before inserting?

   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_;
 }