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

components/metrics/metrics_service_unittest.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_service.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/metrics_hashes.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/metrics/user_metrics.h"
 #include "base/threading/platform_thread.h"
 #include "components/metrics/client_info.h"
 #include "components/metrics/metrics_log.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_state_manager.h"
+#include "components/metrics/test_enabled_state_provider.h"
 #include "components/metrics/test_metrics_provider.h"
 #include "components/metrics/test_metrics_service_client.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/variations/metrics_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/zlib/google/compression_utils.h"
 
 namespace metrics {
 
 namespace {
@@ skipping 32 matching lines @@
                    local_state) {}
 
   ~TestMetricsLog() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestMetricsLog);
 };
 
 class MetricsServiceTest : public testing::Test {
  public:
-  MetricsServiceTest() : is_metrics_reporting_enabled_(false) {
+  MetricsServiceTest()
+      : enabled_state_provider_(new TestEnabledStateProvider(false, false)) {
     base::SetRecordActionTaskRunner(message_loop.task_runner());
     MetricsService::RegisterPrefs(testing_local_state_.registry());
     metrics_state_manager_ = MetricsStateManager::Create(
-        GetLocalState(),
-        base::Bind(&MetricsServiceTest::is_metrics_reporting_enabled,
-                   base::Unretained(this)),
-        base::Bind(&StoreNoClientInfoBackup),
-        base::Bind(&ReturnNoBackup));
+        GetLocalState(), enabled_state_provider_.get(),
+        base::Bind(&StoreNoClientInfoBackup), base::Bind(&ReturnNoBackup));
   }
 
   ~MetricsServiceTest() override {
     MetricsService::SetExecutionPhase(MetricsService::UNINITIALIZED_PHASE,
                                       GetLocalState());
   }
 
   MetricsStateManager* GetMetricsStateManager() {
     return metrics_state_manager_.get();
   }
 
   PrefService* GetLocalState() { return &testing_local_state_; }
 
   // Sets metrics reporting as enabled for testing.
   void EnableMetricsReporting() {
-    is_metrics_reporting_enabled_ = true;
+    enabled_state_provider_->set_consent(true);
+    enabled_state_provider_->set_enabled(true);
   }
 
   // Waits until base::TimeTicks::Now() no longer equals |value|. This should
   // take between 1-15ms per the documented resolution of base::TimeTicks.
   void WaitUntilTimeChanges(const base::TimeTicks& value) {
     while (base::TimeTicks::Now() == value) {
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
     }
   }
 
@@ skipping 35 matching lines @@
       const uint64_t hash = uma_log.histogram_event(i).name_hash();
 
       const base::HistogramBase* histogram = FindHistogram(histograms, hash);
       EXPECT_TRUE(histogram) << hash;
 
       EXPECT_EQ(kStabilityFlags, histogram->flags() & kStabilityFlags) << hash;
     }
   }
 
  private:
-  bool is_metrics_reporting_enabled() const {
-    return is_metrics_reporting_enabled_;
-  }
-
-  bool is_metrics_reporting_enabled_;
+  std::unique_ptr<TestEnabledStateProvider> enabled_state_provider_;
   TestingPrefServiceSimple testing_local_state_;
   std::unique_ptr<MetricsStateManager> metrics_state_manager_;
   base::MessageLoop message_loop;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsServiceTest);
 };
 
 }  // namespace
 
@@ skipping 238 matching lines @@
   TestMetricsProvider* test_provider = new TestMetricsProvider();
   service.RegisterMetricsProvider(
       std::unique_ptr<MetricsProvider>(test_provider));
 
   service.InitializeMetricsRecordingState();
 
   EXPECT_TRUE(test_provider->init_called());
 }
 
 }  // namespace metrics