Introduce a MetricsDataProvider interface.

chrome/browser/metrics/metrics_log_unittest.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 "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/port.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "base/tracked_objects.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "components/metrics/metrics_hashes.h"
+#include "components/metrics/metrics_provider.h"
 #include "components/metrics/proto/profiler_event.pb.h"
 #include "components/metrics/proto/system_profile.pb.h"
 #include "components/variations/active_field_trials.h"
 #include "components/variations/metrics_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 277 matching lines @@
 TEST_F(MetricsLogTest, RecordEnvironment) {
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
 
   std::vector<content::WebPluginInfo> plugins;
   GoogleUpdateMetrics google_update_metrics;
   std::vector<variations::ActiveGroupId> synthetic_trials;
   // Add two synthetic trials.
   synthetic_trials.push_back(kSyntheticTrials[0]);
   synthetic_trials.push_back(kSyntheticTrials[1]);
 
-  log.RecordEnvironment(plugins, google_update_metrics, synthetic_trials);
+  log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
+                        plugins, google_update_metrics, synthetic_trials);
   // Check that the system profile on the log has the correct values set.
   CheckSystemProfile(log.system_profile());
 
   // Check that the system profile has also been written to prefs.
   PrefService* local_state = log.GetPrefService();
   const std::string base64_system_profile =
       local_state->GetString(prefs::kStabilitySavedSystemProfile);
   EXPECT_FALSE(base64_system_profile.empty());
   std::string serialied_system_profile;
   EXPECT_TRUE(base::Base64Decode(base64_system_profile,
@@ skipping 12 matching lines @@
 
   // The pref value is empty, so loading it from prefs should fail.
   {
     TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
     EXPECT_FALSE(log.LoadSavedEnvironmentFromPrefs());
   }
 
   // Do a RecordEnvironment() call and check whether the pref is recorded.
   {
     TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
-    log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
+    log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
+                          std::vector<content::WebPluginInfo>(),
                           GoogleUpdateMetrics(),
                           std::vector<variations::ActiveGroupId>());
     EXPECT_FALSE(prefs.GetString(kSystemProfilePref).empty());
     EXPECT_FALSE(prefs.GetString(kSystemProfileHashPref).empty());
   }
 
   {
     TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
     EXPECT_TRUE(log.LoadSavedEnvironmentFromPrefs());
     // Check some values in the system profile.
     EXPECT_EQ(kInstallDateExpected, log.system_profile().install_date());
     EXPECT_EQ(kEnabledDateExpected, log.system_profile().uma_enabled_date());
     // Ensure that the call cleared the prefs.
     EXPECT_TRUE(prefs.GetString(kSystemProfilePref).empty());
     EXPECT_TRUE(prefs.GetString(kSystemProfileHashPref).empty());
   }
 
   // Ensure that a non-matching hash results in the pref being invalid.
   {
     TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
     // Call RecordEnvironment() to record the pref again.
-    log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
+    log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
+                          std::vector<content::WebPluginInfo>(),
                           GoogleUpdateMetrics(),
                           std::vector<variations::ActiveGroupId>());
   }
 
   {
     // Set the hash to a bad value.
     prefs.SetString(kSystemProfileHashPref, "deadbeef");
     TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
     EXPECT_FALSE(log.LoadSavedEnvironmentFromPrefs());
     // Ensure that the prefs are cleared, even if the call failed.
     EXPECT_TRUE(prefs.GetString(kSystemProfilePref).empty());
     EXPECT_TRUE(prefs.GetString(kSystemProfileHashPref).empty());
   }
 }
 
 TEST_F(MetricsLogTest, InitialLogStabilityMetrics) {
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::INITIAL_STABILITY_LOG);
-  log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
+  std::vector<metrics::MetricsProvider*> metrics_providers;
+  log.RecordEnvironment(metrics_providers,
+                        std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(),
                         std::vector<variations::ActiveGroupId>());
-  log.RecordStabilityMetrics(base::TimeDelta(), base::TimeDelta());
+  log.RecordStabilityMetrics(metrics_providers, base::TimeDelta(),
+                             base::TimeDelta());
   const metrics::SystemProfileProto_Stability& stability =
       log.system_profile().stability();
   // Required metrics:
   EXPECT_TRUE(stability.has_launch_count());
   EXPECT_TRUE(stability.has_crash_count());
   // Initial log metrics:
   EXPECT_TRUE(stability.has_incomplete_shutdown_count());
   EXPECT_TRUE(stability.has_breakpad_registration_success_count());
   EXPECT_TRUE(stability.has_breakpad_registration_failure_count());
   EXPECT_TRUE(stability.has_debugger_present_count());
   EXPECT_TRUE(stability.has_debugger_not_present_count());
 }
 
 TEST_F(MetricsLogTest, OngoingLogStabilityMetrics) {
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
-  log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
+  std::vector<metrics::MetricsProvider*> metrics_providers;
+  log.RecordEnvironment(metrics_providers,
+                        std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(),
                         std::vector<variations::ActiveGroupId>());
-  log.RecordStabilityMetrics(base::TimeDelta(), base::TimeDelta());
+  log.RecordStabilityMetrics(metrics_providers, base::TimeDelta(),
+                             base::TimeDelta());
   const metrics::SystemProfileProto_Stability& stability =
       log.system_profile().stability();
   // Required metrics:
   EXPECT_TRUE(stability.has_launch_count());
   EXPECT_TRUE(stability.has_crash_count());
   // Initial log metrics:
   EXPECT_FALSE(stability.has_incomplete_shutdown_count());
   EXPECT_FALSE(stability.has_breakpad_registration_success_count());
   EXPECT_FALSE(stability.has_breakpad_registration_failure_count());
   EXPECT_FALSE(stability.has_debugger_present_count());
   EXPECT_FALSE(stability.has_debugger_not_present_count());
 }
 
 #if defined(ENABLE_PLUGINS)
 TEST_F(MetricsLogTest, Plugins) {
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
+  std::vector<metrics::MetricsProvider*> metrics_providers;
 
   std::vector<content::WebPluginInfo> plugins;
   plugins.push_back(CreateFakePluginInfo("p1", FILE_PATH_LITERAL("p1.plugin"),
                                          "1.5", true));
   plugins.push_back(CreateFakePluginInfo("p2", FILE_PATH_LITERAL("p2.plugin"),
                                          "2.0", false));
-  log.RecordEnvironment(plugins, GoogleUpdateMetrics(),
+  log.RecordEnvironment(metrics_providers, plugins, GoogleUpdateMetrics(),
                         std::vector<variations::ActiveGroupId>());
 
   const metrics::SystemProfileProto& system_profile = log.system_profile();
   ASSERT_EQ(2, system_profile.plugin_size());
   EXPECT_EQ("p1", system_profile.plugin(0).name());
   EXPECT_EQ("p1.plugin", system_profile.plugin(0).filename());
   EXPECT_EQ("1.5", system_profile.plugin(0).version());
   EXPECT_TRUE(system_profile.plugin(0).is_pepper());
   EXPECT_EQ("p2", system_profile.plugin(1).name());
   EXPECT_EQ("p2.plugin", system_profile.plugin(1).filename());
   EXPECT_EQ("2.0", system_profile.plugin(1).version());
   EXPECT_FALSE(system_profile.plugin(1).is_pepper());
 
   // Now set some plugin stability stats for p2 and verify they're recorded.
   scoped_ptr<base::DictionaryValue> plugin_dict(new base::DictionaryValue);
   plugin_dict->SetString(prefs::kStabilityPluginName, "p2");
   plugin_dict->SetInteger(prefs::kStabilityPluginLaunches, 1);
   plugin_dict->SetInteger(prefs::kStabilityPluginCrashes, 2);
   plugin_dict->SetInteger(prefs::kStabilityPluginInstances, 3);
   plugin_dict->SetInteger(prefs::kStabilityPluginLoadingErrors, 4);
   {
     ListPrefUpdate update(log.GetPrefService(), prefs::kStabilityPluginStats);
     update.Get()->Append(plugin_dict.release());
   }
 
-  log.RecordStabilityMetrics(base::TimeDelta(), base::TimeDelta());
+  log.RecordStabilityMetrics(metrics_providers, base::TimeDelta(),
+                             base::TimeDelta());
   const metrics::SystemProfileProto_Stability& stability =
       log.system_profile().stability();
   ASSERT_EQ(1, stability.plugin_stability_size());
   EXPECT_EQ("p2", stability.plugin_stability(0).plugin().name());
   EXPECT_EQ("p2.plugin", stability.plugin_stability(0).plugin().filename());
   EXPECT_EQ("2.0", stability.plugin_stability(0).plugin().version());
   EXPECT_FALSE(stability.plugin_stability(0).plugin().is_pepper());
   EXPECT_EQ(1, stability.plugin_stability(0).launch_count());
   EXPECT_EQ(2, stability.plugin_stability(0).crash_count());
   EXPECT_EQ(3, stability.plugin_stability(0).instance_count());
@@ skipping 184 matching lines @@
   chromeos::FakeUserManager* user_manager = new chromeos::FakeUserManager();
   chromeos::ScopedUserManagerEnabler scoped_enabler(user_manager);
   user_manager->AddKioskAppUser(user1);
   user_manager->AddKioskAppUser(user2);
   user_manager->AddKioskAppUser(user3);
 
   user_manager->LoginUser(user1);
   user_manager->LoginUser(user3);
 
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
+  std::vector<metrics::MetricsProvider*> metrics_providers;
   std::vector<content::WebPluginInfo> plugins;
   GoogleUpdateMetrics google_update_metrics;
   std::vector<variations::ActiveGroupId> synthetic_trials;
-  log.RecordEnvironment(plugins, google_update_metrics, synthetic_trials);
+  log.RecordEnvironment(metrics_providers, plugins, google_update_metrics,
+                        synthetic_trials);
   EXPECT_EQ(2u, log.system_profile().multi_profile_user_count());
 }
 
 TEST_F(MetricsLogTest, MultiProfileCountInvalidated) {
   std::string user1("user1@example.com");
   std::string user2("user2@example.com");
   std::string user3("user3@example.com");
 
   // |scoped_enabler| takes over the lifetime of |user_manager|.
   chromeos::FakeUserManager* user_manager = new chromeos::FakeUserManager();
   chromeos::ScopedUserManagerEnabler scoped_enabler(user_manager);
   user_manager->AddKioskAppUser(user1);
   user_manager->AddKioskAppUser(user2);
   user_manager->AddKioskAppUser(user3);
 
   user_manager->LoginUser(user1);
 
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
   EXPECT_EQ(1u, log.system_profile().multi_profile_user_count());
 
   user_manager->LoginUser(user2);
+  std::vector<metrics::MetricsProvider*> metrics_providers;
   std::vector<variations::ActiveGroupId> synthetic_trials;
-  log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
+  log.RecordEnvironment(metrics_providers,
+                        std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(), synthetic_trials);
   EXPECT_EQ(0u, log.system_profile().multi_profile_user_count());
 }
 
 TEST_F(MetricsLogTest, BluetoothHardwareDisabled) {
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
-  log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
+  log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
+                        std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(),
                         std::vector<variations::ActiveGroupId>());
 
   EXPECT_TRUE(log.system_profile().has_hardware());
   EXPECT_TRUE(log.system_profile().hardware().has_bluetooth());
 
   EXPECT_TRUE(log.system_profile().hardware().bluetooth().is_present());
   EXPECT_FALSE(log.system_profile().hardware().bluetooth().is_enabled());
 }
 
 TEST_F(MetricsLogTest, BluetoothHardwareEnabled) {
   FakeBluetoothAdapterClient::Properties* properties =
       fake_bluetooth_adapter_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
   properties->powered.ReplaceValue(true);
 
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
-  log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
+  log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
+                        std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(),
                         std::vector<variations::ActiveGroupId>());
 
   EXPECT_TRUE(log.system_profile().has_hardware());
   EXPECT_TRUE(log.system_profile().hardware().has_bluetooth());
 
   EXPECT_TRUE(log.system_profile().hardware().bluetooth().is_present());
   EXPECT_TRUE(log.system_profile().hardware().bluetooth().is_enabled());
 }
 
 TEST_F(MetricsLogTest, BluetoothPairedDevices) {
   // The fake bluetooth adapter class already claims to be paired with one
   // device when initialized. Add a second and third fake device to it so we
   // can test the cases where a device is not paired (LE device, generally)
   // and a device that does not have Device ID information.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath));
 
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
 
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   properties->paired.ReplaceValue(true);
 
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
-  log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
+  log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
+                        std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(),
                         std::vector<variations::ActiveGroupId>());
 
   ASSERT_TRUE(log.system_profile().has_hardware());
   ASSERT_TRUE(log.system_profile().hardware().has_bluetooth());
 
   // Only two of the devices should appear.
   EXPECT_EQ(2,
             log.system_profile().hardware().bluetooth().paired_device_size());
 
@@ skipping 19 matching lines @@
   PairedDevice device2 =
       log.system_profile().hardware().bluetooth().paired_device(1);
 
   EXPECT_EQ(FakeBluetoothDeviceClient::kConfirmPasskeyClass,
             device2.bluetooth_class());
   EXPECT_EQ(PairedDevice::DEVICE_PHONE, device2.type());
   EXPECT_EQ(0x207D74U, device2.vendor_prefix());
   EXPECT_EQ(PairedDevice::VENDOR_ID_UNKNOWN, device2.vendor_id_source());
 }
 #endif  // OS_CHROMEOS