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

chrome/browser/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It is
@@ skipping 270 matching lines @@
       return SUCCESS;
     case 400:
       return BAD_REQUEST;
     case net::URLFetcher::RESPONSE_CODE_INVALID:
       return NO_RESPONSE;
     default:
       return UNKNOWN_FAILURE;
   }
 }
 
-void MarkAppCleanShutdownAndCommit() {
-  PrefService* pref = g_browser_process->local_state();
-  pref->SetBoolean(prefs::kStabilityExitedCleanly, true);
-  pref->SetInteger(prefs::kStabilityExecutionPhase,
-                   MetricsService::SHUTDOWN_COMPLETE);
+void MarkAppCleanShutdownAndCommit(PrefService* local_state) {
+  local_state->SetBoolean(prefs::kStabilityExitedCleanly, true);
+  local_state->SetInteger(prefs::kStabilityExecutionPhase,
+                          MetricsService::SHUTDOWN_COMPLETE);
   // Start writing right away (write happens on a different thread).
-  pref->CommitPendingWrite();
+  local_state->CommitPendingWrite();
 }
 
 }  // namespace
 
 
 SyntheticTrialGroup::SyntheticTrialGroup(uint32 trial, uint32 group) {
   id.name = trial;
   id.group = group;
 }
 
@@ skipping 52 matching lines @@
   AndroidMetricsProvider::RegisterPrefs(registry);
 #endif  // defined(OS_ANDROID)
 
 #if defined(ENABLE_PLUGINS)
   // TODO(asvitkine): Move this out of here.
   PluginMetricsProvider::RegisterPrefs(registry);
 #endif
 }
 
 MetricsService::MetricsService(metrics::MetricsStateManager* state_manager,
-                               metrics::MetricsServiceClient* client)
-    : log_manager_(g_browser_process->local_state(),
-                   kUploadLogAvoidRetransmitSize),
+                               metrics::MetricsServiceClient* client,
+                               PrefService* local_state)
+    : log_manager_(local_state, kUploadLogAvoidRetransmitSize),
       histogram_snapshot_manager_(this),
       state_manager_(state_manager),
       client_(client),
+      local_state_(local_state),
       recording_active_(false),
       reporting_active_(false),
       test_mode_active_(false),
       state_(INITIALIZED),
       has_initial_stability_log_(false),
       idle_since_last_transmission_(false),
       session_id_(-1),
       next_window_id_(0),
       self_ptr_factory_(this),
       state_saver_factory_(this),
       waiting_for_asynchronous_reporting_step_(false) {
   DCHECK(IsSingleThreaded());
   DCHECK(state_manager_);
   DCHECK(client_);
+  DCHECK(local_state_);
 
 #if defined(OS_ANDROID)
   // TODO(asvitkine): Move this out of MetricsService.
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new AndroidMetricsProvider(
-          g_browser_process->local_state())));
+          local_state_)));
 #endif  // defined(OS_ANDROID)
 
   // TODO(asvitkine): Move these out of MetricsService.
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new NetworkMetricsProvider));
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider));
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new ChromeStabilityMetricsProvider));
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new GPUMetricsProvider()));
 
 #if defined(OS_WIN)
   google_update_metrics_provider_ = new GoogleUpdateMetricsProviderWin;
   RegisterMetricsProvider(scoped_ptr<metrics::MetricsProvider>(
       google_update_metrics_provider_));
 #endif
 
 #if defined(ENABLE_PLUGINS)
-  plugin_metrics_provider_ = new PluginMetricsProvider(
-      g_browser_process->local_state());
+  plugin_metrics_provider_ = new PluginMetricsProvider(local_state_);
   RegisterMetricsProvider(scoped_ptr<metrics::MetricsProvider>(
       plugin_metrics_provider_));
 #endif
 
 #if defined(OS_CHROMEOS)
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new ChromeOSMetricsProvider));
 #endif
 }
 
@@ skipping 147 matching lines @@
 
 void MetricsService::RecordCompletedSessionEnd() {
   LogCleanShutdown();
   RecordBooleanPrefValue(prefs::kStabilitySessionEndCompleted, true);
 }
 
 #if defined(OS_ANDROID) || defined(OS_IOS)
 void MetricsService::OnAppEnterBackground() {
   scheduler_->Stop();
 
-  MarkAppCleanShutdownAndCommit();
+  MarkAppCleanShutdownAndCommit(local_state_);
 
   // At this point, there's no way of knowing when the process will be
   // killed, so this has to be treated similar to a shutdown, closing and
   // persisting all logs. Unlinke a shutdown, the state is primed to be ready
   // to continue logging and uploading if the process does return.
   if (recording_active() && state_ >= SENDING_INITIAL_STABILITY_LOG) {
     PushPendingLogsToPersistentStorage();
     // Persisting logs closes the current log, so start recording a new log
     // immediately to capture any background work that might be done before the
     // process is killed.
     OpenNewLog();
   }
 }
 
 void MetricsService::OnAppEnterForeground() {
-  PrefService* pref = g_browser_process->local_state();
-  pref->SetBoolean(prefs::kStabilityExitedCleanly, false);
-
+  local_state_->SetBoolean(prefs::kStabilityExitedCleanly, false);
   StartSchedulerIfNecessary();
 }
 #else
-void MetricsService::LogNeedForCleanShutdown() {
-  PrefService* pref = g_browser_process->local_state();
-  pref->SetBoolean(prefs::kStabilityExitedCleanly, false);
+void MetricsService::LogNeedForCleanShutdown(PrefService* local_state) {
+  local_state->SetBoolean(prefs::kStabilityExitedCleanly, false);
   // Redundant setting to be sure we call for a clean shutdown.
   clean_shutdown_status_ = NEED_TO_SHUTDOWN;
 }
 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 
 // static
-void MetricsService::SetExecutionPhase(ExecutionPhase execution_phase) {
+void MetricsService::SetExecutionPhase(ExecutionPhase execution_phase,
+                                       PrefService* local_state) {
   execution_phase_ = execution_phase;
-  PrefService* pref = g_browser_process->local_state();
-  pref->SetInteger(prefs::kStabilityExecutionPhase, execution_phase_);
+  local_state->SetInteger(prefs::kStabilityExecutionPhase, execution_phase_);
 }
 
 void MetricsService::RecordBreakpadRegistration(bool success) {
   if (!success)
     IncrementPrefValue(prefs::kStabilityBreakpadRegistrationFail);
   else
     IncrementPrefValue(prefs::kStabilityBreakpadRegistrationSuccess);
 }
 
 void MetricsService::RecordBreakpadHasDebugger(bool has_debugger) {
   if (!has_debugger)
     IncrementPrefValue(prefs::kStabilityDebuggerNotPresent);
   else
     IncrementPrefValue(prefs::kStabilityDebuggerPresent);
 }
 
 //------------------------------------------------------------------------------
 // private methods
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
 // Initialization methods
 
 void MetricsService::InitializeMetricsState() {
-  PrefService* pref = g_browser_process->local_state();
-  DCHECK(pref);
+  local_state_->SetString(prefs::kStabilityStatsVersion,
+                          client_->GetVersionString());
+  local_state_->SetInt64(prefs::kStabilityStatsBuildTime,
+                         MetricsLog::GetBuildTime());
 
-  pref->SetString(prefs::kStabilityStatsVersion, client_->GetVersionString());
-  pref->SetInt64(prefs::kStabilityStatsBuildTime, MetricsLog::GetBuildTime());
+  session_id_ = local_state_->GetInteger(prefs::kMetricsSessionID);
 
-  session_id_ = pref->GetInteger(prefs::kMetricsSessionID);
-
-  if (!pref->GetBoolean(prefs::kStabilityExitedCleanly)) {
+  if (!local_state_->GetBoolean(prefs::kStabilityExitedCleanly)) {
     IncrementPrefValue(prefs::kStabilityCrashCount);
     // Reset flag, and wait until we call LogNeedForCleanShutdown() before
     // monitoring.
-    pref->SetBoolean(prefs::kStabilityExitedCleanly, true);
+    local_state_->SetBoolean(prefs::kStabilityExitedCleanly, true);
 
     // TODO(rtenneti): On windows, consider saving/getting execution_phase from
     // the registry.
-    int execution_phase = pref->GetInteger(prefs::kStabilityExecutionPhase);
+    int execution_phase =
+        local_state_->GetInteger(prefs::kStabilityExecutionPhase);
     UMA_HISTOGRAM_SPARSE_SLOWLY("Chrome.Browser.CrashedExecutionPhase",
                                 execution_phase);
 
     // If the previous session didn't exit cleanly, then prepare an initial
     // stability log if UMA is enabled.
     if (state_manager_->IsMetricsReportingEnabled())
       PrepareInitialStabilityLog();
   }
 
   // Update session ID.
   ++session_id_;
-  pref->SetInteger(prefs::kMetricsSessionID, session_id_);
+  local_state_->SetInteger(prefs::kMetricsSessionID, session_id_);
 
   // Stability bookkeeping
   IncrementPrefValue(prefs::kStabilityLaunchCount);
 
   DCHECK_EQ(UNINITIALIZED_PHASE, execution_phase_);
-  SetExecutionPhase(START_METRICS_RECORDING);
+  SetExecutionPhase(START_METRICS_RECORDING, local_state_);
 
-  if (!pref->GetBoolean(prefs::kStabilitySessionEndCompleted)) {
+  if (!local_state_->GetBoolean(prefs::kStabilitySessionEndCompleted)) {
     IncrementPrefValue(prefs::kStabilityIncompleteSessionEndCount);
     // This is marked false when we get a WM_ENDSESSION.
-    pref->SetBoolean(prefs::kStabilitySessionEndCompleted, true);
+    local_state_->SetBoolean(prefs::kStabilitySessionEndCompleted, true);
   }
 
   // Call GetUptimes() for the first time, thus allowing all later calls
   // to record incremental uptimes accurately.
   base::TimeDelta ignored_uptime_parameter;
   base::TimeDelta startup_uptime;
-  GetUptimes(pref, &startup_uptime, &ignored_uptime_parameter);
+  GetUptimes(local_state_, &startup_uptime, &ignored_uptime_parameter);
   DCHECK_EQ(0, startup_uptime.InMicroseconds());
   // For backwards compatibility, leave this intact in case Omaha is checking
   // them.  prefs::kStabilityLastTimestampSec may also be useless now.
   // TODO(jar): Delete these if they have no uses.
-  pref->SetInt64(prefs::kStabilityLaunchTimeSec, Time::Now().ToTimeT());
+  local_state_->SetInt64(prefs::kStabilityLaunchTimeSec, Time::Now().ToTimeT());
 
   // Bookkeeping for the uninstall metrics.
   IncrementLongPrefsValue(prefs::kUninstallLaunchCount);
 
   // Kick off the process of saving the state (so the uptime numbers keep
   // getting updated) every n minutes.
   ScheduleNextStateSave();
 }
 
 // static
@@ skipping 127 matching lines @@
 void MetricsService::ScheduleNextStateSave() {
   state_saver_factory_.InvalidateWeakPtrs();
 
   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
       base::Bind(&MetricsService::SaveLocalState,
                  state_saver_factory_.GetWeakPtr()),
       base::TimeDelta::FromMinutes(kSaveStateIntervalMinutes));
 }
 
 void MetricsService::SaveLocalState() {
-  PrefService* pref = g_browser_process->local_state();
-  if (!pref) {
-    NOTREACHED();
-    return;
-  }
-
-  RecordCurrentState(pref);
+  RecordCurrentState(local_state_);
 
   // TODO(jar):110021 Does this run down the batteries????
   ScheduleNextStateSave();
 }
 
 
 //------------------------------------------------------------------------------
 // Recording control methods
 
 void MetricsService::OpenNewLog() {
@@ skipping 44 matching lines @@
   // Put incremental data (histogram deltas, and realtime stats deltas) at the
   // end of all log transmissions (initial log handles this separately).
   // RecordIncrementalStabilityElements only exists on the derived
   // MetricsLog class.
   MetricsLog* current_log =
       static_cast<MetricsLog*>(log_manager_.current_log());
   DCHECK(current_log);
   std::vector<variations::ActiveGroupId> synthetic_trials;
   GetCurrentSyntheticFieldTrials(&synthetic_trials);
   current_log->RecordEnvironment(metrics_providers_.get(), synthetic_trials);
-  PrefService* pref = g_browser_process->local_state();
   base::TimeDelta incremental_uptime;
   base::TimeDelta uptime;
-  GetUptimes(pref, &incremental_uptime, &uptime);
+  GetUptimes(local_state_, &incremental_uptime, &uptime);
   current_log->RecordStabilityMetrics(metrics_providers_.get(),
                                       incremental_uptime, uptime);
 
   RecordCurrentHistograms();
   current_log->RecordGeneralMetrics(metrics_providers_.get());
 
   log_manager_.FinishCurrentLog();
 }
 
 void MetricsService::PushPendingLogsToPersistentStorage() {
@@ skipping 148 matching lines @@
     default:
       NOTREACHED();
       return;
   }
 
   DCHECK(log_manager_.has_staged_log());
 }
 
 void MetricsService::PrepareInitialStabilityLog() {
   DCHECK_EQ(INITIALIZED, state_);
-  PrefService* pref = g_browser_process->local_state();
-  DCHECK_NE(0, pref->GetInteger(prefs::kStabilityCrashCount));
+  DCHECK_NE(0, local_state_->GetInteger(prefs::kStabilityCrashCount));
 
   scoped_ptr<MetricsLog> initial_stability_log(
       CreateLog(MetricsLog::INITIAL_STABILITY_LOG));
 
   // Do not call NotifyOnDidCreateMetricsLog here because the stability
   // log describes stats from the _previous_ session.
 
   if (!initial_stability_log->LoadSavedEnvironmentFromPrefs())
     return;
 
@@ skipping 25 matching lines @@
 }
 
 void MetricsService::PrepareInitialMetricsLog() {
   DCHECK(state_ == INIT_TASK_DONE || state_ == SENDING_INITIAL_STABILITY_LOG);
   initial_metrics_log_->set_hardware_class(hardware_class_);
 
   std::vector<variations::ActiveGroupId> synthetic_trials;
   GetCurrentSyntheticFieldTrials(&synthetic_trials);
   initial_metrics_log_->RecordEnvironment(metrics_providers_.get(),
                                           synthetic_trials);
-  PrefService* pref = g_browser_process->local_state();
   base::TimeDelta incremental_uptime;
   base::TimeDelta uptime;
-  GetUptimes(pref, &incremental_uptime, &uptime);
+  GetUptimes(local_state_, &incremental_uptime, &uptime);
 
   // Histograms only get written to the current log, so make the new log current
   // before writing them.
   log_manager_.PauseCurrentLog();
   log_manager_.BeginLoggingWithLog(
       initial_metrics_log_.PassAs<metrics::MetricsLogBase>());
 
   // Note: Some stability providers may record stability stats via histograms,
   //       so this call has to be after BeginLoggingWithLog().
   MetricsLog* current_log =
@@ skipping 161 matching lines @@
   if (state_ != SENDING_INITIAL_METRICS_LOG) {
     scheduler_->UploadFinished(server_is_healthy,
                                log_manager_.has_unsent_logs());
   }
 
   if (server_is_healthy)
     client_->OnLogUploadComplete();
 }
 
 void MetricsService::IncrementPrefValue(const char* path) {
-  PrefService* pref = g_browser_process->local_state();
-  DCHECK(pref);
-  int value = pref->GetInteger(path);
-  pref->SetInteger(path, value + 1);
+  int value = local_state_->GetInteger(path);
+  local_state_->SetInteger(path, value + 1);
 }
 
 void MetricsService::IncrementLongPrefsValue(const char* path) {
-  PrefService* pref = g_browser_process->local_state();
-  DCHECK(pref);
-  int64 value = pref->GetInt64(path);
-  pref->SetInt64(path, value + 1);
+  int64 value = local_state_->GetInt64(path);
+  local_state_->SetInt64(path, value + 1);
 }
 
 bool MetricsService::UmaMetricsProperlyShutdown() {
   CHECK(clean_shutdown_status_ == CLEANLY_SHUTDOWN ||
         clean_shutdown_status_ == NEED_TO_SHUTDOWN);
   return clean_shutdown_status_ == CLEANLY_SHUTDOWN;
 }
 
 void MetricsService::RegisterSyntheticFieldTrial(
     const SyntheticTrialGroup& trial) {
@@ skipping 29 matching lines @@
   synthetic_trials->clear();
   const MetricsLog* current_log =
       static_cast<const MetricsLog*>(log_manager_.current_log());
   for (size_t i = 0; i < synthetic_trial_groups_.size(); ++i) {
     if (synthetic_trial_groups_[i].start_time <= current_log->creation_time())
       synthetic_trials->push_back(synthetic_trial_groups_[i].id);
   }
 }
 
 scoped_ptr<MetricsLog> MetricsService::CreateLog(MetricsLog::LogType log_type) {
-  return make_scoped_ptr(new MetricsLog(
-      state_manager_->client_id(), session_id_, log_type, client_));
+  return make_scoped_ptr(new MetricsLog(state_manager_->client_id(),
+                                        session_id_,
+                                        log_type,
+                                        client_,
+                                        local_state_));
 }
 
 void MetricsService::RecordCurrentHistograms() {
   DCHECK(log_manager_.current_log());
   histogram_snapshot_manager_.PrepareDeltas(
       base::Histogram::kNoFlags, base::Histogram::kUmaTargetedHistogramFlag);
 }
 
 void MetricsService::RecordCurrentStabilityHistograms() {
   DCHECK(log_manager_.current_log());
   histogram_snapshot_manager_.PrepareDeltas(
       base::Histogram::kNoFlags, base::Histogram::kUmaStabilityHistogramFlag);
 }
 
 void MetricsService::LogCleanShutdown() {
   // Redundant hack to write pref ASAP.
-  MarkAppCleanShutdownAndCommit();
+  MarkAppCleanShutdownAndCommit(local_state_);
 
   // Redundant setting to assure that we always reset this value at shutdown
   // (and that we don't use some alternate path, and not call LogCleanShutdown).
   clean_shutdown_status_ = CLEANLY_SHUTDOWN;
 
   RecordBooleanPrefValue(prefs::kStabilityExitedCleanly, true);
-  PrefService* pref = g_browser_process->local_state();
-  pref->SetInteger(prefs::kStabilityExecutionPhase,
-                   MetricsService::SHUTDOWN_COMPLETE);
+  local_state_->SetInteger(prefs::kStabilityExecutionPhase,
+                           MetricsService::SHUTDOWN_COMPLETE);
 }
 
 void MetricsService::LogPluginLoadingError(const base::FilePath& plugin_path) {
 #if defined(ENABLE_PLUGINS)
   // TODO(asvitkine): Move this out of here.
   plugin_metrics_provider_->LogPluginLoadingError(plugin_path);
 #endif
 }
 
 bool MetricsService::ShouldLogEvents() {
   // We simply don't log events to UMA if there is a single incognito
   // session visible. The problem is that we always notify using the orginal
   // profile in order to simplify notification processing.
   return !client_->IsOffTheRecordSessionActive();
 }
 
 void MetricsService::RecordBooleanPrefValue(const char* path, bool value) {
   DCHECK(IsSingleThreaded());
-
-  PrefService* pref = g_browser_process->local_state();
-  DCHECK(pref);
-
-  pref->SetBoolean(path, value);
-  RecordCurrentState(pref);
+  local_state_->SetBoolean(path, value);
+  RecordCurrentState(local_state_);
 }
 
 void MetricsService::RecordCurrentState(PrefService* pref) {
   pref->SetInt64(prefs::kStabilityLastTimestampSec, Time::Now().ToTimeT());
 
 #if defined(ENABLE_PLUGINS)
   plugin_metrics_provider_->RecordPluginChanges();
 #endif
 }