Splitting the concept of UMA consent, and should UMA report.

components/metrics/metrics_state_manager.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 "components/metrics/metrics_state_manager.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/metrics/cloned_install_detector.h"
+#include "components/metrics/enabled_state_provider.h"
 #include "components/metrics/machine_id_provider.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_switches.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/caching_permuted_entropy_provider.h"
 
 namespace metrics {
 
 namespace {
@@ skipping 13 matching lines @@
   return base::RandInt(0, kMaxLowEntropySize - 1);
 }
 
 }  // namespace
 
 // static
 bool MetricsStateManager::instance_exists_ = false;
 
 MetricsStateManager::MetricsStateManager(
     PrefService* local_state,
-    const base::Callback<bool(void)>& is_reporting_enabled_callback,
+    EnabledStateProvider* enabled_state_provider,
     const StoreClientInfoCallback& store_client_info,
     const LoadClientInfoCallback& retrieve_client_info)
     : local_state_(local_state),
-      is_reporting_enabled_callback_(is_reporting_enabled_callback),
+      enabled_state_provider_(enabled_state_provider),
       store_client_info_(store_client_info),
       load_client_info_(retrieve_client_info),
       low_entropy_source_(kLowEntropySourceNotSet),
       entropy_source_returned_(ENTROPY_SOURCE_NONE) {
   ResetMetricsIDsIfNecessary();
-  if (IsMetricsReportingEnabled())
+  if (enabled_state_provider_->IsConsentGiven())
     ForceClientIdCreation();
 
   DCHECK(!instance_exists_);
   instance_exists_ = true;
 }
 
 MetricsStateManager::~MetricsStateManager() {
   DCHECK(instance_exists_);
   instance_exists_ = false;
 }
 
 bool MetricsStateManager::IsMetricsReportingEnabled() {
-  return is_reporting_enabled_callback_.Run();
+  return enabled_state_provider_->IsReportingEnabled();
 }
 
 void MetricsStateManager::ForceClientIdCreation() {
   if (!client_id_.empty())
     return;
 
   client_id_ = local_state_->GetString(prefs::kMetricsClientID);
   if (!client_id_.empty()) {
     // It is technically sufficient to only save a backup of the client id when
     // it is initially generated below, but since the backup was only introduced
@@ skipping 65 matching lines @@
   // For metrics reporting-enabled users, we combine the client ID and low
   // entropy source to get the final entropy source. Otherwise, only use the low
   // entropy source.
   // This has two useful properties:
   //  1) It makes the entropy source less identifiable for parties that do not
   //     know the low entropy source.
   //  2) It makes the final entropy source resettable.
   const int low_entropy_source_value = GetLowEntropySource();
   UMA_HISTOGRAM_SPARSE_SLOWLY("UMA.LowEntropySourceValue",
                               low_entropy_source_value);
-  if (IsMetricsReportingEnabled()) {
+  if (enabled_state_provider_->IsConsentGiven()) {
     UpdateEntropySourceReturnedValue(ENTROPY_SOURCE_HIGH);
     const std::string high_entropy_source =
         client_id_ + base::IntToString(low_entropy_source_value);
     return std::unique_ptr<const base::FieldTrial::EntropyProvider>(
         new SHA1EntropyProvider(high_entropy_source));
   }
 
   UpdateEntropySourceReturnedValue(ENTROPY_SOURCE_LOW);
 #if defined(OS_ANDROID) || defined(OS_IOS)
   return std::unique_ptr<const base::FieldTrial::EntropyProvider>(
       new CachingPermutedEntropyProvider(local_state_, low_entropy_source_value,
                                          kMaxLowEntropySize));
 #else
   return std::unique_ptr<const base::FieldTrial::EntropyProvider>(
       new PermutedEntropyProvider(low_entropy_source_value,
                                   kMaxLowEntropySize));
 #endif
 }
 
 // static
 std::unique_ptr<MetricsStateManager> MetricsStateManager::Create(
     PrefService* local_state,
-    const base::Callback<bool(void)>& is_reporting_enabled_callback,
+    EnabledStateProvider* enabled_state_provider,
     const StoreClientInfoCallback& store_client_info,
     const LoadClientInfoCallback& retrieve_client_info) {
   std::unique_ptr<MetricsStateManager> result;
   // Note: |instance_exists_| is updated in the constructor and destructor.
   if (!instance_exists_) {
-    result.reset(new MetricsStateManager(local_state,
-                                         is_reporting_enabled_callback,
+    result.reset(new MetricsStateManager(local_state, enabled_state_provider,
                                          store_client_info,
                                          retrieve_client_info));
   }
   return result;
 }
 
 // static
 void MetricsStateManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(prefs::kMetricsResetIds, false);
   // registry->RegisterIntegerPref(prefs::kMetricsDefaultOptIn,
@@ skipping 103 matching lines @@
 
   local_state_->ClearPref(prefs::kMetricsClientID);
   local_state_->ClearPref(prefs::kMetricsLowEntropySource);
   local_state_->ClearPref(prefs::kMetricsResetIds);
 
   // Also clear the backed up client info.
   store_client_info_.Run(ClientInfo());
 }
 
 }  // namespace metrics