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

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 <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 384 matching lines @@
 
 GoogleUpdateMetrics::GoogleUpdateMetrics() : is_system_install(false) {}
 
 GoogleUpdateMetrics::~GoogleUpdateMetrics() {}
 
 static base::LazyInstance<std::string>::Leaky
     g_version_extension = LAZY_INSTANCE_INITIALIZER;
 
 MetricsLog::MetricsLog(const std::string& client_id,
                        int session_id,
-                       LogType log_type)
-    : MetricsLogBase(client_id, session_id, log_type,
+                       LogType log_type,
+                       PrefService* local_state)
+    : MetricsLogBase(client_id,
+                     session_id,
+                     log_type,
                      MetricsLog::GetVersionString()),
       creation_time_(base::TimeTicks::Now()),
-      extension_metrics_(uma_proto()->client_id()) {
+      extension_metrics_(uma_proto()->client_id()),
+      local_state_(local_state) {
   uma_proto()->mutable_system_profile()->set_channel(
       AsProtobufChannel(chrome::VersionInfo::GetChannel()));
 
 #if defined(OS_CHROMEOS)
   metrics_log_chromeos_.reset(new MetricsLogChromeOS(uma_proto()));
 #endif  // OS_CHROMEOS
 }
 
 MetricsLog::~MetricsLog() {}
 
@@ skipping 27 matching lines @@
 const std::string& MetricsLog::version_extension() {
   return g_version_extension.Get();
 }
 
 void MetricsLog::RecordStabilityMetrics(base::TimeDelta incremental_uptime,
                                         base::TimeDelta uptime) {
   DCHECK(!locked());
   DCHECK(HasEnvironment());
   DCHECK(!HasStabilityMetrics());
 
-  PrefService* pref = GetPrefService();
+  PrefService* pref = local_state_;
   DCHECK(pref);
 
   // 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.
 
   WriteRequiredStabilityAttributes(pref);
   WritePluginStabilityElements(pref);
 
   // Record recent delta for critical stability metrics.  We can't wait for a
@@ skipping 28 matching lines @@
       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);
 }
 
-PrefService* MetricsLog::GetPrefService() {
-  return g_browser_process->local_state();
-}
-
 gfx::Size MetricsLog::GetScreenSize() const {
   return gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().GetSizeInPixel();
 }
 
 float MetricsLog::GetScreenDeviceScaleFactor() const {
   return gfx::Screen::GetNativeScreen()->
       GetPrimaryDisplay().device_scale_factor();
 }
 
 int MetricsLog::GetScreenCount() const {
@@ skipping 174 matching lines @@
     const std::vector<chrome_variations::ActiveGroupId>& synthetic_trials) {
   DCHECK(!HasEnvironment());
 
   SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
 
   std::string brand_code;
   if (google_util::GetBrand(&brand_code))
     system_profile->set_brand_code(brand_code);
 
   int enabled_date;
-  bool success = base::StringToInt(GetMetricsEnabledDate(GetPrefService()),
-                                   &enabled_date);
+  bool success =
+      base::StringToInt(GetMetricsEnabledDate(local_state_), &enabled_date);
   DCHECK(success);
 
   // Reduce granularity of the enabled_date field to nearest hour.
   system_profile->set_uma_enabled_date(RoundSecondsToHour(enabled_date));
 
-  int64 install_date = GetPrefService()->GetInt64(prefs::kInstallDate);
+  int64 install_date = local_state_->GetInt64(prefs::kInstallDate);
 
   // Reduce granularity of the install_date field to nearest hour.
   system_profile->set_install_date(RoundSecondsToHour(install_date));
 
   system_profile->set_application_locale(
       g_browser_process->GetApplicationLocale());
 
   SystemProfileProto::Hardware* hardware = system_profile->mutable_hardware();
   hardware->set_cpu_architecture(base::SysInfo::OperatingSystemArchitecture());
   hardware->set_system_ram_mb(base::SysInfo::AmountOfPhysicalMemoryMB());
@@ skipping 70 matching lines @@
   WriteFieldTrials(synthetic_trials, system_profile);
 
 #if defined(OS_CHROMEOS)
   metrics_log_chromeos_->LogChromeOSMetrics();
 #endif  // OS_CHROMEOS
 
   std::string serialied_system_profile;
   std::string base64_system_profile;
   if (system_profile->SerializeToString(&serialied_system_profile)) {
     base::Base64Encode(serialied_system_profile, &base64_system_profile);
-    PrefService* local_state = GetPrefService();
+    PrefService* local_state = local_state_;
     local_state->SetString(prefs::kStabilitySavedSystemProfile,
                            base64_system_profile);
     local_state->SetString(prefs::kStabilitySavedSystemProfileHash,
                            ComputeSHA1(serialied_system_profile));
   }
 }
 
 bool MetricsLog::LoadSavedEnvironmentFromPrefs() {
-  PrefService* local_state = GetPrefService();
+  PrefService* local_state = local_state_;
   const std::string base64_system_profile =
       local_state->GetString(prefs::kStabilitySavedSystemProfile);
   if (base64_system_profile.empty())
     return false;
 
   const std::string system_profile_hash =
       local_state->GetString(prefs::kStabilitySavedSystemProfileHash);
   local_state->ClearPref(prefs::kStabilitySavedSystemProfile);
   local_state->ClearPref(prefs::kStabilitySavedSystemProfileHash);
 
@@ skipping 118 matching lines @@
     ProductDataToProto(google_update_metrics.google_update_data,
                        google_update->mutable_google_update_status());
   }
 
   if (!google_update_metrics.product_data.version.empty()) {
     ProductDataToProto(google_update_metrics.product_data,
                        google_update->mutable_client_status());
   }
 #endif  // defined(GOOGLE_CHROME_BUILD) && defined(OS_WIN)
 }