Clean up UMA 3g experiment and unify metrics enabled pref for Android

chrome/browser/metrics/chrome_metrics_service_client.cc

 // Copyright 2014 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/chrome_metrics_service_client.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 22 matching lines @@
 #include "chrome/browser/metrics/subprocess_metrics_provider.h"
 #include "chrome/browser/metrics/time_ticks_experiment_win.h"
 #include "chrome/browser/sync/chrome_sync_client.h"
 #include "chrome/browser/ui/browser_otr_state.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/features.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/installer/util/util_constants.h"
 #include "components/metrics/call_stack_profile_metrics_provider.h"
 #include "components/metrics/drive_metrics_provider.h"
 #include "components/metrics/file_metrics_provider.h"
 #include "components/metrics/gpu/gpu_metrics_provider.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_reporting_default_state.h"
 #include "components/metrics/metrics_service.h"
 #include "components/metrics/metrics_service_client.h"
 #include "components/metrics/metrics_state_manager.h"
@@ skipping 55 matching lines @@
 namespace {
 
 // This specifies the amount of time to wait for all renderers to send their
 // data.
 const int kMaxHistogramGatheringWaitDuration = 60000;  // 60 seconds.
 
 // Needs to be kept in sync with the writer in
 // third_party/crashpad/crashpad/handler/handler_main.cc.
 const char kCrashpadHistogramAllocatorName[] = "CrashpadMetrics";
 
-// Checks whether it is the first time that cellular uploads logic should be
-// enabled based on whether the the preference for that logic is initialized.
-// This should happen only once as the used preference will be initialized
-// afterwards in |UmaSessionStats.java|.
-bool ShouldClearSavedMetrics() {
-#if BUILDFLAG(ANDROID_JAVA_UI)
-  PrefService* local_state = g_browser_process->local_state();
-  return !local_state->HasPrefPath(metrics::prefs::kMetricsReportingEnabled) &&
-         metrics::IsCellularLogicEnabled();
-#else
-  return false;
-#endif
-}
-
 void RegisterFileMetricsPreferences(PrefRegistrySimple* registry) {
   metrics::FileMetricsProvider::RegisterPrefs(
       registry, ChromeMetricsServiceClient::kBrowserMetricsName);
 
   metrics::FileMetricsProvider::RegisterPrefs(registry,
                                               kCrashpadHistogramAllocatorName);
 
 #if defined(OS_WIN)
   metrics::FileMetricsProvider::RegisterPrefs(
       registry, installer::kSetupHistogramAllocatorName);
@@ skipping 267 matching lines @@
   return IsMetricsReportingPolicyManaged();
 }
 
 metrics::EnableMetricsDefault
 ChromeMetricsServiceClient::GetMetricsReportingDefaultState() {
   return metrics::GetMetricsReportingDefaultState(
       g_browser_process->local_state());
 }
 
 void ChromeMetricsServiceClient::Initialize() {
-  // Clear metrics reports if it is the first time cellular upload logic should
-  // apply to avoid sudden bulk uploads. It needs to be done before initializing
-  // metrics service so that metrics log manager is initialized correctly.
-  if (ShouldClearSavedMetrics()) {
-    PrefService* local_state = g_browser_process->local_state();
-    local_state->ClearPref(metrics::prefs::kMetricsInitialLogs);
-    local_state->ClearPref(metrics::prefs::kMetricsOngoingLogs);
-  }
+  // Clear deprecated metrics preference for Android.
+  PrefService* local_state = g_browser_process->local_state();
+#if BUILDFLAG(ANDROID_JAVA_UI)

[Alexei Svitkine (slow), 2016/09/19 19:38:02]

Add a comment about this explaining what this with a TODO to remove this in some
number of milestones (e.g. M60). Actually, I see the comment is above the
local_state line - move it below and add an empty line after the local state var
- since it's used for other things below too.

[gayane -on leave until 09-2017, 2016/09/19 20:05:58]

Done.

+  local_state->ClearPref(prefs::kCrashReportingEnabled);
+#endif
 
-  metrics_service_.reset(new metrics::MetricsService(
-      metrics_state_manager_, this, g_browser_process->local_state()));
+  metrics_service_.reset(
+      new metrics::MetricsService(metrics_state_manager_, this, local_state));
 
   // Gets access to persistent metrics shared by sub-processes.
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new SubprocessMetricsProvider()));
 
   // Register metrics providers.
 #if defined(ENABLE_EXTENSIONS)
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new ExtensionsMetricsProvider(metrics_state_manager_)));
 #endif
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new metrics::NetworkMetricsProvider(
               content::BrowserThread::GetBlockingPool())));
 
   // Currently, we configure OmniboxMetricsProvider to not log events to UMA
   // if there is a single incognito session visible. In the future, it may
   // be worth revisiting this to still log events from non-incognito sessions.
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider(
           base::Bind(&chrome::IsIncognitoSessionActive))));
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
-          new ChromeStabilityMetricsProvider(
-              g_browser_process->local_state())));
+          new ChromeStabilityMetricsProvider(local_state)));
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new metrics::GPUMetricsProvider));
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new metrics::ScreenInfoMetricsProvider));
 
   metrics_service_->RegisterMetricsProvider(CreateFileMetricsProvider(
       ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled()));
 
   drive_metrics_provider_ = new metrics::DriveMetricsProvider(
       content::BrowserThread::GetTaskRunnerForThread(
           content::BrowserThread::FILE),
       chrome::FILE_LOCAL_STATE);
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(drive_metrics_provider_));
 
-  profiler_metrics_provider_ = new metrics::ProfilerMetricsProvider(
-      base::Bind(&metrics::IsCellularLogicEnabled));
+  profiler_metrics_provider_ = new metrics::ProfilerMetricsProvider();
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(profiler_metrics_provider_));
 
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new metrics::CallStackProfileMetricsProvider));
 
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new metrics::SamplingMetricsProvider));
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
-          new AndroidMetricsProvider(g_browser_process->local_state())));
+          new AndroidMetricsProvider(local_state)));
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(new PageLoadMetricsProvider()));
 #endif  // BUILDFLAG(ANDROID_JAVA_UI)
 
 #if defined(OS_WIN)
   google_update_metrics_provider_ = new GoogleUpdateMetricsProviderWin;
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           google_update_metrics_provider_));
 
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new browser_watcher::WatcherMetricsProviderWin(
               chrome::GetBrowserExitCodesRegistryPath(),
               content::BrowserThread::GetBlockingPool())));
 
   antivirus_metrics_provider_ = new AntiVirusMetricsProvider(
       content::BrowserThread::GetBlockingPool()
           ->GetTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
 
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(antivirus_metrics_provider_));
 #endif  // defined(OS_WIN)
 
 #if defined(ENABLE_PLUGINS)
-  plugin_metrics_provider_ =
-      new PluginMetricsProvider(g_browser_process->local_state());
+  plugin_metrics_provider_ = new PluginMetricsProvider(local_state);
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(plugin_metrics_provider_));
 #endif  // defined(ENABLE_PLUGINS)
 
 #if defined(OS_CHROMEOS)
   ChromeOSMetricsProvider* chromeos_metrics_provider =
       new ChromeOSMetricsProvider;
   chromeos_metrics_provider_ = chromeos_metrics_provider;
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(chromeos_metrics_provider));
 
   SigninStatusMetricsProviderChromeOS* signin_metrics_provider_cros =
       new SigninStatusMetricsProviderChromeOS;
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(signin_metrics_provider_cros));
 
   // Record default UMA state as opt-out for all Chrome OS users, if not
   // recorded yet.
-  PrefService* local_state = g_browser_process->local_state();
   if (metrics::GetMetricsReportingDefaultState(local_state) ==
       metrics::EnableMetricsDefault::DEFAULT_UNKNOWN) {
     metrics::RecordMetricsReportingDefaultState(
         local_state, metrics::EnableMetricsDefault::OPT_OUT);
   }
 #endif  // defined(OS_CHROMEOS)
 
 #if !defined(OS_CHROMEOS)
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           SigninStatusMetricsProvider::CreateInstance(base::WrapUnique(
               new ChromeSigninStatusMetricsProviderDelegate))));
 #endif  // !defined(OS_CHROMEOS)
 
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new sync_driver::DeviceCountMetricsProvider(base::Bind(
               &browser_sync::ChromeSyncClient::GetDeviceInfoTrackers))));
 
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new HttpsEngagementMetricsProvider()));
-
-  // Clear stability metrics if it is the first time cellular upload logic
-  // should apply to avoid sudden bulk uploads. It needs to be done after all
-  // providers are registered.
-  if (ShouldClearSavedMetrics())
-    metrics_service_->ClearSavedStabilityMetrics();
 }
 
 void ChromeMetricsServiceClient::OnInitTaskGotHardwareClass() {
   const base::Closure got_bluetooth_adapter_callback =
       base::Bind(&ChromeMetricsServiceClient::OnInitTaskGotBluetoothAdapter,
                  weak_ptr_factory_.GetWeakPtr());
 #if defined(OS_CHROMEOS)
   chromeos_metrics_provider_->InitTaskGetBluetoothAdapter(
       got_bluetooth_adapter_callback);
 #else
@@ skipping 238 matching lines @@
   }
 }
 
 void ChromeMetricsServiceClient::OnURLOpenedFromOmnibox(OmniboxLog* log) {
   metrics_service_->OnApplicationNotIdle();
 }
 
 bool ChromeMetricsServiceClient::IsUMACellularUploadLogicEnabled() {
   return metrics::IsCellularLogicEnabled();
 }