Remove dependencies of Metrics{Service,Log} on g_browser_process->local_state()

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"
@@ skipping 111 matching lines @@
  public:
   explicit TestMetricsLogChromeOS(
       metrics::ChromeUserMetricsExtension* uma_proto)
       : MetricsLogChromeOS(uma_proto) {
   }
 };
 #endif  // OS_CHROMEOS
 
 class TestMetricsLog : public MetricsLog {
  public:
-  TestMetricsLog(const std::string& client_id, int session_id, LogType log_type)
-      : MetricsLog(client_id, session_id, log_type),
-        prefs_(&scoped_prefs_),
-        brand_for_testing_(kBrandForTesting) {
-#if defined(OS_CHROMEOS)
-    metrics_log_chromeos_.reset(new TestMetricsLogChromeOS(
-        MetricsLog::uma_proto()));
-#endif  // OS_CHROMEOS
-    chrome::RegisterLocalState(scoped_prefs_.registry());
-    InitPrefs();
-  }
-  // Creates a TestMetricsLog that will use |prefs| as the fake local state.
-  // Useful for tests that need to re-use the local state prefs between logs.
   TestMetricsLog(const std::string& client_id,
                  int session_id,
                  LogType log_type,
                  TestingPrefServiceSimple* prefs)
-      : MetricsLog(client_id, session_id, log_type),
+      : MetricsLog(client_id, session_id, log_type, prefs),
         prefs_(prefs),
         brand_for_testing_(kBrandForTesting) {
 #if defined(OS_CHROMEOS)
     metrics_log_chromeos_.reset(new TestMetricsLogChromeOS(
         MetricsLog::uma_proto()));
 #endif  // OS_CHROMEOS
     InitPrefs();
   }
   virtual ~TestMetricsLog() {}
 
-  virtual PrefService* GetPrefService() OVERRIDE {
-    return prefs_;
-  }
-
   const metrics::ChromeUserMetricsExtension& uma_proto() const {
     return *MetricsLog::uma_proto();
   }
 
   const metrics::SystemProfileProto& system_profile() const {
     return uma_proto().system_profile();
   }
 
  private:
   void InitPrefs() {
@@ skipping 41 matching lines @@
 };
 
 }  // namespace
 
 class MetricsLogTest : public testing::Test {
  public:
   MetricsLogTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE {
+    chrome::RegisterLocalState(prefs_.registry());
+
 #if defined(OS_CHROMEOS)
     // Enable multi-profiles.
     CommandLine::ForCurrentProcess()->AppendSwitch(switches::kMultiProfiles);
 
     // Set up the fake Bluetooth environment,
     scoped_ptr<FakeDBusThreadManager> fake_dbus_thread_manager(
         new FakeDBusThreadManager);
     fake_dbus_thread_manager->SetBluetoothAdapterClient(
         scoped_ptr<BluetoothAdapterClient>(new FakeBluetoothAdapterClient));
     fake_dbus_thread_manager->SetBluetoothDeviceClient(
@@ skipping 61 matching lines @@
 
     EXPECT_TRUE(hardware.has_cpu());
     EXPECT_TRUE(hardware.cpu().has_vendor_name());
     EXPECT_TRUE(hardware.cpu().has_signature());
 
     // TODO(isherman): Verify other data written into the protobuf as a result
     // of this call.
   }
 
  protected:
+  TestingPrefServiceSimple prefs_;
 #if defined(OS_CHROMEOS)
   FakeBluetoothAdapterClient* fake_bluetooth_adapter_client_;
   FakeBluetoothDeviceClient* fake_bluetooth_device_client_;
 #endif  // OS_CHROMEOS
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsLogTest);
 };
 
 TEST_F(MetricsLogTest, RecordEnvironment) {
-  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
+  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
 
   std::vector<content::WebPluginInfo> plugins;
   GoogleUpdateMetrics google_update_metrics;
   std::vector<chrome_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);
   // 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);
+      prefs_.GetString(prefs::kStabilitySavedSystemProfile);
   EXPECT_FALSE(base64_system_profile.empty());
   std::string serialied_system_profile;
   EXPECT_TRUE(base::Base64Decode(base64_system_profile,
                                  &serialied_system_profile));
   SystemProfileProto decoded_system_profile;
   EXPECT_TRUE(decoded_system_profile.ParseFromString(serialied_system_profile));
   CheckSystemProfile(decoded_system_profile);
 }
 
 TEST_F(MetricsLogTest, LoadSavedEnvironmentFromPrefs) {
   const char* kSystemProfilePref = prefs::kStabilitySavedSystemProfile;
   const char* kSystemProfileHashPref = prefs::kStabilitySavedSystemProfileHash;
 
-  TestingPrefServiceSimple prefs;
-  chrome::RegisterLocalState(prefs.registry());
-
   // The pref value is empty, so loading it from prefs should fail.
   {
-    TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
+    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);
+    TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
     log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
                           GoogleUpdateMetrics(),
                           std::vector<chrome_variations::ActiveGroupId>());
-    EXPECT_FALSE(prefs.GetString(kSystemProfilePref).empty());
-    EXPECT_FALSE(prefs.GetString(kSystemProfileHashPref).empty());
+    EXPECT_FALSE(prefs_.GetString(kSystemProfilePref).empty());
+    EXPECT_FALSE(prefs_.GetString(kSystemProfileHashPref).empty());
   }
 
   {
-    TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
+    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());
+    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);
+    TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
     // Call RecordEnvironment() to record the pref again.
     log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
                           GoogleUpdateMetrics(),
                           std::vector<chrome_variations::ActiveGroupId>());
   }
 
   {
     // Set the hash to a bad value.
-    prefs.SetString(kSystemProfileHashPref, "deadbeef");
-    TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
+    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());
+    EXPECT_TRUE(prefs_.GetString(kSystemProfilePref).empty());
+    EXPECT_TRUE(prefs_.GetString(kSystemProfileHashPref).empty());
   }
 }
 
 TEST_F(MetricsLogTest, InitialLogStabilityMetrics) {
-  TestMetricsLog log(kClientId, kSessionId, MetricsLog::INITIAL_STABILITY_LOG);
+  TestMetricsLog log(
+      kClientId, kSessionId, MetricsLog::INITIAL_STABILITY_LOG, &prefs_);
   log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(),
                         std::vector<chrome_variations::ActiveGroupId>());
   log.RecordStabilityMetrics(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);
+  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
   log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(),
                         std::vector<chrome_variations::ActiveGroupId>());
   log.RecordStabilityMetrics(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);
+  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
 
   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(),
                         std::vector<chrome_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);
+    ListPrefUpdate update(&prefs_, prefs::kStabilityPluginStats);
     update.Get()->Append(plugin_dict.release());
   }
 
   log.RecordStabilityMetrics(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());
   EXPECT_EQ(4, stability.plugin_stability(0).loading_error_count());
 }
 #endif  // defined(ENABLE_PLUGINS)
 
 // Test that we properly write profiler data to the log.
 TEST_F(MetricsLogTest, RecordProfilerData) {
   // WARNING: If you broke the below check, you've modified how
   // metrics::HashMetricName works. Please also modify all server-side code that
   // relies on the existing way of hashing.
   EXPECT_EQ(GG_UINT64_C(1518842999910132863),
             metrics::HashMetricName("birth_thread*"));
 
-  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
+  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
   EXPECT_EQ(0, log.uma_proto().profiler_event_size());
 
   {
     ProcessDataSnapshot process_data;
     process_data.process_id = 177;
     process_data.tasks.push_back(TaskSnapshot());
     process_data.tasks.back().birth.location.file_name = "a/b/file.h";
     process_data.tasks.back().birth.location.function_name = "function";
     process_data.tasks.back().birth.location.line_number = 1337;
     process_data.tasks.back().birth.thread_name = "birth_thread";
@@ skipping 140 matching lines @@
     EXPECT_EQ(109, tracked_object->queue_time_total());
     EXPECT_EQ(104, tracked_object->queue_time_sampled());
     EXPECT_EQ(metrics::HashMetricName(""),
               tracked_object->exec_thread_name_hash());
     EXPECT_EQ(ProfilerEventProto::TrackedObject::RENDERER,
               tracked_object->process_type());
   }
 }
 
 TEST_F(MetricsLogTest, ChromeChannelWrittenToProtobuf) {
-  TestMetricsLog log("user@test.com", kSessionId, MetricsLog::ONGOING_LOG);
+  TestMetricsLog log(
+      "user@test.com", kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
   EXPECT_TRUE(log.uma_proto().system_profile().has_channel());
 }
 
 #if defined(OS_CHROMEOS)
 TEST_F(MetricsLogTest, MultiProfileUserCount) {
   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);
   user_manager->LoginUser(user3);
 
-  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
+  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
   std::vector<content::WebPluginInfo> plugins;
   GoogleUpdateMetrics google_update_metrics;
   std::vector<chrome_variations::ActiveGroupId> synthetic_trials;
   log.RecordEnvironment(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);
+  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
   EXPECT_EQ(1u, log.system_profile().multi_profile_user_count());
 
   user_manager->LoginUser(user2);
   std::vector<chrome_variations::ActiveGroupId> synthetic_trials;
   log.RecordEnvironment(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);
+  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
   log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(),
                         std::vector<chrome_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);
+  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
   log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(),
                         std::vector<chrome_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);
+  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs_);
   log.RecordEnvironment(std::vector<content::WebPluginInfo>(),
                         GoogleUpdateMetrics(),
                         std::vector<chrome_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 20 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