Introduce AndroidMetricsProvider class.

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 167 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/tracked_objects.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/memory_details.h"
+#include "chrome/browser/metrics/android_metrics_provider_android.h"

[Ilya Sherman, 2014/05/21 09:15:28]

nit: Only for Android builds?

[Alexei Svitkine (slow), 2014/05/21 09:48:47]

Done.

 #include "chrome/browser/metrics/compression_utils.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/metrics_state_manager.h"
 #include "chrome/browser/metrics/time_ticks_experiment_win.h"
 #include "chrome/browser/metrics/tracking_synchronizer.h"
 #include "chrome/browser/net/http_pipelining_compatibility_client.h"
 #include "chrome/browser/net/network_stats.h"
 #include "chrome/browser/omnibox/omnibox_log.h"
 #include "chrome/browser/ui/browser_otr_state.h"
 #include "chrome/common/chrome_constants.h"
@@ skipping 249 matching lines @@
   registry->RegisterListPref(metrics::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);
+  // TODO(asvitkine): Move this out of here.
+  AndroidMetricsProvider::RegisterPrefs(registry);
 #endif  // defined(OS_ANDROID)
 }
 
 MetricsService::MetricsService(metrics::MetricsStateManager* state_manager)
     : MetricsServiceBase(g_browser_process->local_state(),
                          kUploadLogAvoidRetransmitSize),
       state_manager_(state_manager),
       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),
       num_async_histogram_fetches_in_progress_(0) {
   DCHECK(IsSingleThreaded());
   DCHECK(state_manager_);
 
+#if defined(OS_ANDROID)
+  // TODO(asvitkine): Move this out of MetricsService.
+  RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(new AndroidMetricsProvider(
+          g_browser_process->local_state())));
+#endif  // defined(OS_ANDROID)

[Ilya Sherman, 2014/05/21 09:15:28]

Hmm, why did you move this out of InitializeMetricsState()?  Are you sure that
either location is fine?

[Alexei Svitkine (slow), 2014/05/21 09:48:47]

Yes, either location is fine - as long as this happens during start up. The code
that gets run here merely looks at prefs (saved by previous session) and updates
other prefs.

+
   BrowserChildProcessObserver::Add(this);
 }
 
 MetricsService::~MetricsService() {
   DisableRecording();
 
   BrowserChildProcessObserver::Remove(this);
 }
 
 void MetricsService::InitializeMetricsRecordingState() {
@@ skipping 364 matching lines @@
 
   PrefService* pref = g_browser_process->local_state();
   DCHECK(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 563 matching lines @@
 
   log_manager_.PauseCurrentLog();
   log_manager_.BeginLoggingWithLog(initial_stability_log.release());
 
   // Note: Some stability providers may record stability stats via histograms,
   //       so this call has to be after BeginLoggingWithLog().
   MetricsLog* current_log =
       static_cast<MetricsLog*>(log_manager_.current_log());
   current_log->RecordStabilityMetrics(metrics_providers_.get(),
                                       base::TimeDelta(), base::TimeDelta());
-
-#if defined(OS_ANDROID)
-  ConvertAndroidStabilityPrefsToHistograms(pref);
   RecordCurrentStabilityHistograms();
-#endif  // defined(OS_ANDROID)
 
   // Note: RecordGeneralMetrics() intentionally not called since this log is for
   //       stability stats from a previous session only.
 
   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();
@@ skipping 19 matching lines @@
   // before writing them.
   log_manager_.PauseCurrentLog();
   log_manager_.BeginLoggingWithLog(initial_metrics_log_.release());
 
   // Note: Some stability providers may record stability stats via histograms,
   //       so this call has to be after BeginLoggingWithLog().
   MetricsLog* current_log =
       static_cast<MetricsLog*>(log_manager_.current_log());
   current_log->RecordStabilityMetrics(metrics_providers_.get(),
                                       base::TimeDelta(), base::TimeDelta());
-
-#if defined(OS_ANDROID)
-  ConvertAndroidStabilityPrefsToHistograms(pref);
-#endif  // defined(OS_ANDROID)
   RecordCurrentHistograms();
 
   current_log->RecordGeneralMetrics(metrics_providers_.get());
 
   log_manager_.FinishCurrentLog();
   log_manager_.ResumePausedLog();
 
   DCHECK(!log_manager_.has_staged_log());
   log_manager_.StageNextLogForUpload();
 }
@@ skipping 483 matching lines @@
   if (metrics_service)
     metrics_service->AddObserver(observer);
 }
 
 void MetricsServiceHelper::RemoveMetricsServiceObserver(
     MetricsServiceObserver* observer) {
   MetricsService* metrics_service = g_browser_process->metrics_service();
   if (metrics_service)
     metrics_service->RemoveObserver(observer);
 }