Let MetricsService know about some Android Activities

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 464 matching lines @@
 
   registry->RegisterListPref(prefs::kMetricsInitialLogs);
   registry->RegisterListPref(prefs::kMetricsOngoingLogs);
 
   registry->RegisterInt64Pref(prefs::kInstallDate, 0);
   registry->RegisterInt64Pref(prefs::kUninstallMetricsPageLoadCount, 0);
   registry->RegisterInt64Pref(prefs::kUninstallLaunchCount, 0);
   registry->RegisterInt64Pref(prefs::kUninstallMetricsUptimeSec, 0);
   registry->RegisterInt64Pref(prefs::kUninstallLastLaunchTimeSec, 0);
   registry->RegisterInt64Pref(prefs::kUninstallLastObservedRunTimeSec, 0);
+
+#if defined(OS_ANDROID)
+  RegisterPrefsAndroid(registry);
+#endif  // defined(OS_ANDROID)
 }
 
 // static
 void MetricsService::DiscardOldStabilityStats(PrefService* local_state) {
   local_state->SetBoolean(prefs::kStabilityExitedCleanly, true);
   local_state->SetInteger(prefs::kStabilityExecutionPhase, UNINITIALIZED_PHASE);
   local_state->SetBoolean(prefs::kStabilitySessionEndCompleted, true);
 
   local_state->SetInteger(prefs::kStabilityIncompleteSessionEndCount, 0);
   local_state->SetInteger(prefs::kStabilityBreakpadRegistrationSuccess, 0);
   local_state->SetInteger(prefs::kStabilityBreakpadRegistrationFail, 0);
   local_state->SetInteger(prefs::kStabilityDebuggerPresent, 0);
   local_state->SetInteger(prefs::kStabilityDebuggerNotPresent, 0);
 
   local_state->SetInteger(prefs::kStabilityLaunchCount, 0);
   local_state->SetInteger(prefs::kStabilityCrashCount, 0);
 
   local_state->SetInteger(prefs::kStabilityPageLoadCount, 0);
   local_state->SetInteger(prefs::kStabilityRendererCrashCount, 0);
   local_state->SetInteger(prefs::kStabilityRendererHangCount, 0);
 
   local_state->SetInt64(prefs::kStabilityLaunchTimeSec, 0);
   local_state->SetInt64(prefs::kStabilityLastTimestampSec, 0);
 
   local_state->ClearPref(prefs::kStabilityPluginStats);
 
   local_state->ClearPref(prefs::kMetricsInitialLogs);
   local_state->ClearPref(prefs::kMetricsOngoingLogs);
+
+#if defined(OS_ANDROID)
+  DiscardOldStabilityStatsAndroid(local_state);
+#endif  // defined(OS_ANDROID)
 }
 
 MetricsService::MetricsService()
     : recording_active_(false),
       reporting_active_(false),
       test_mode_active_(false),
       state_(INITIALIZED),
       has_initial_stability_log_(false),
       low_entropy_source_(kLowEntropySourceNotSet),
       idle_since_last_transmission_(false),
@@ skipping 416 matching lines @@
     // old version with info that we upload.
     DiscardOldStabilityStats(pref);
     pref->SetString(prefs::kStabilityStatsVersion,
                     MetricsLog::GetVersionString());
     pref->SetInt64(prefs::kStabilityStatsBuildTime,
                    MetricsLog::GetBuildTime());
   }
 
   session_id_ = pref->GetInteger(prefs::kMetricsSessionID);
 
+#if defined(OS_ANDROID)
+  LogAndroidStabilityToPrefs(pref);
+#endif  // defined(OS_ANDROID)
+
   if (!pref->GetBoolean(prefs::kStabilityExitedCleanly)) {
     IncrementPrefValue(prefs::kStabilityCrashCount);
     // Reset flag, and wait until we call LogNeedForCleanShutdown() before
     // monitoring.
     pref->SetBoolean(prefs::kStabilityExitedCleanly, true);
 
     // TODO(rtenneti): On windows, consider saving/getting execution_phase from
     // the registry.
     int execution_phase = pref->GetInteger(prefs::kStabilityExecutionPhase);
     UMA_HISTOGRAM_SPARSE_SLOWLY("Chrome.Browser.CrashedExecutionPhase",
@@ skipping 308 matching lines @@
       static_cast<MetricsLog*>(log_manager_.current_log());
   DCHECK(current_log);
   std::vector<chrome_variations::ActiveGroupId> synthetic_trials;
   GetCurrentSyntheticFieldTrials(&synthetic_trials);
   current_log->RecordEnvironment(plugins_, google_update_metrics_,
                                  synthetic_trials);
   PrefService* pref = g_browser_process->local_state();
   current_log->RecordStabilityMetrics(GetIncrementalUptime(pref),
                                       MetricsLog::ONGOING_LOG);
 
+#if defined(OS_ANDROID)
+  ConvertAndroidStabilityPrefsToHistograms(pref);

[Kibeom Kim (inactive), 2014/01/24 19:45:09]

dfalcantara@ -- Q : This was in your last patch set, but we're only updating
prefs in MetricsService::InitializeMetricsState(...), so I think this line can
be removed. Could you confirm it? Just to make sure.

[gone, 2014/01/24 20:03:07]

Yeah, I think it should be fine.  I think you moved it down to where it actually
needs to happen...

[Kibeom Kim (inactive), 2014/01/24 23:21:34]

Done.

+#endif  // defined(OS_ANDROID)
   RecordCurrentHistograms();
 
   log_manager_.FinishCurrentLog();
 }
 
 void MetricsService::PushPendingLogsToPersistentStorage() {
   if (state_ < SENDING_INITIAL_STABILITY_LOG)
     return;  // We didn't and still don't have time to get plugin list etc.
 
   if (log_manager_.has_staged_log()) {
@@ skipping 240 matching lines @@
       new MetricsLog(client_id_, session_id_));
   if (!initial_stability_log->LoadSavedEnvironmentFromPrefs())
     return;
   initial_stability_log->RecordStabilityMetrics(base::TimeDelta(),
                                                 MetricsLog::INITIAL_LOG);
   log_manager_.LoadPersistedUnsentLogs();
 
   log_manager_.PauseCurrentLog();
   log_manager_.BeginLoggingWithLog(initial_stability_log.release(),
                                    MetricsLog::INITIAL_LOG);
+#if defined(OS_ANDROID)
+  ConvertAndroidStabilityPrefsToHistograms(pref);
+  RecordCurrentStabilityHistograms();
+#endif  // defined(OS_ANDROID)
   log_manager_.FinishCurrentLog();
   log_manager_.ResumePausedLog();
 
   // Store unsent logs, including the stability log that was just saved, so
   // that they're not lost in case of a crash before upload time.
   log_manager_.PersistUnsentLogs();
 
   has_initial_stability_log_ = true;
 }
 
 void MetricsService::PrepareInitialMetricsLog(MetricsLog::LogType log_type) {
   DCHECK(state_ == INIT_TASK_DONE || state_ == SENDING_INITIAL_STABILITY_LOG);
   initial_metrics_log_->set_hardware_class(hardware_class_);
 
   std::vector<chrome_variations::ActiveGroupId> synthetic_trials;
   GetCurrentSyntheticFieldTrials(&synthetic_trials);
   initial_metrics_log_->RecordEnvironment(plugins_, google_update_metrics_,
                                           synthetic_trials);
   PrefService* pref = g_browser_process->local_state();
   initial_metrics_log_->RecordStabilityMetrics(GetIncrementalUptime(pref),
                                                log_type);
 
   // 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_.release(), log_type);
+#if defined(OS_ANDROID)
+  ConvertAndroidStabilityPrefsToHistograms(pref);
+#endif  // defined(OS_ANDROID)
   RecordCurrentHistograms();
   log_manager_.FinishCurrentLog();
   log_manager_.ResumePausedLog();
 
   DCHECK(!log_manager_.has_staged_log());
   log_manager_.StageNextLogForUpload();
 }
 
 void MetricsService::SendStagedLog() {
   DCHECK(log_manager_.has_staged_log());
@@ skipping 443 matching lines @@
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }