Persist setup metrics and have Chrome report them during UMA upload.

components/metrics/file_metrics_provider_unittest.cc

Index: components/metrics/file_metrics_provider_unittest.cc
diff --git a/components/metrics/file_metrics_provider_unittest.cc b/components/metrics/file_metrics_provider_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3bffb1c44af6beb4d2a15b065b2da586a2a4f588
--- /dev/null
+++ b/components/metrics/file_metrics_provider_unittest.cc
@@ -0,0 +1,190 @@
+// Copyright 2016 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/file_metrics_provider.h"
+
+#include "base/files/file_util.h"
+#include "base/files/memory_mapped_file.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_flattener.h"
+#include "base/metrics/histogram_persistence.h"
+#include "base/metrics/histogram_snapshot_manager.h"
+#include "base/metrics/persistent_memory_allocator.h"
+#include "base/metrics/statistics_recorder.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/thread_task_runner_handle.h"
+#include "components/metrics/metrics_pref_names.h"
+#include "components/prefs/pref_registry_simple.h"
+#include "components/prefs/testing_pref_service.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+const char kMetricsName[] = "TestMetrics";
+const char kMetricsFilename[] = "file.metrics";
+}  // namespace
+
+namespace metrics {
+
+class HistogramFlattenerDeltaRecorder : public base::HistogramFlattener {
+ public:
+  HistogramFlattenerDeltaRecorder() {}
+
+  void RecordDelta(const base::HistogramBase& histogram,
+                   const base::HistogramSamples& snapshot) override {
+    recorded_delta_histogram_names_.push_back(histogram.histogram_name());
+  }
+
+  void InconsistencyDetected(base::HistogramBase::Inconsistency problem)
+      override {
+    ASSERT_TRUE(false);
+  }
+
+  void UniqueInconsistencyDetected(
+      base::HistogramBase::Inconsistency problem) override {
+    ASSERT_TRUE(false);
+  }
+
+  void InconsistencyDetectedInLoggedCount(int amount) override {
+    ASSERT_TRUE(false);
+  }
+
+  std::vector<std::string> GetRecordedDeltaHistogramNames() {
+    return recorded_delta_histogram_names_;
+  }
+
+ private:
+  std::vector<std::string> recorded_delta_histogram_names_;
+
+  DISALLOW_COPY_AND_ASSIGN(HistogramFlattenerDeltaRecorder);
+};
+
+class FileMetricsProviderTest : public testing::Test {
+ protected:
+  FileMetricsProviderTest()
+      : task_runner_(new base::TestSimpleTaskRunner()),
+        thread_task_runner_handle_(task_runner_),
+        prefs_(new TestingPrefServiceSimple) {
+    EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
+    FileMetricsProvider::RegisterPrefs(prefs_->registry(), kMetricsName);
+  }
+
+  TestingPrefServiceSimple* prefs() { return prefs_.get(); }
+  base::FilePath temp_dir() { return temp_dir_.path(); }
+  base::FilePath metrics_file() {
+    return temp_dir_.path().AppendASCII(kMetricsFilename);
+  }
+
+  FileMetricsProvider* provider() {
+    if (!provider_)
+      provider_.reset(new FileMetricsProvider(task_runner_, prefs()));
+    return provider_.get();
+  }
+
+  void RunTasks() {
+    task_runner_->RunUntilIdle();
+  }
+
+ private:
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  base::ThreadTaskRunnerHandle thread_task_runner_handle_;
+
+  base::ScopedTempDir temp_dir_;
+  scoped_ptr<TestingPrefServiceSimple> prefs_;
+  scoped_ptr<FileMetricsProvider> provider_;
+
+  DISALLOW_COPY_AND_ASSIGN(FileMetricsProviderTest);
+};
+
+
+TEST_F(FileMetricsProviderTest, AccessMetrics) {
+  ASSERT_FALSE(PathExists(metrics_file()));
+
+  {
+    // Get this first so it isn't created inside the persistent allocator.
+    base::GetCreateHistogramResultHistogram();
+
+    base::SetPersistentHistogramMemoryAllocator(
+        new base::LocalPersistentMemoryAllocator(64 << 10, 0, kMetricsName));
+    base::HistogramBase* foo =
+        base::Histogram::FactoryGet("foo", 1, 100, 10, 0);
+    base::HistogramBase* bar =
+        base::Histogram::FactoryGet("bar", 1, 100, 10, 0);
+    foo->Add(42);
+    bar->Add(84);
+
+    scoped_ptr<base::PersistentMemoryAllocator> allocator(
+        base::ReleasePersistentHistogramMemoryAllocatorForTesting());
+    base::File writer(metrics_file(),
+                      base::File::FLAG_CREATE | base::File::FLAG_WRITE);
+    ASSERT_TRUE(writer.IsValid());
+    ASSERT_EQ(static_cast<int>(allocator->used()),
+              writer.Write(0, (const char*)allocator->data(),
+                           allocator->used()));
+  }
+
+  // Register the file and allow the "checker" task to run.
+  ASSERT_TRUE(PathExists(metrics_file()));
+  provider()->RegisterFile(metrics_file(),
+                           FileMetricsProvider::FILE_HISTOGRAMS_ATOMIC,
+                           kMetricsName);
+
+  // Record embedded snapshots via snapshot-manager.
+  provider()->OnDidCreateMetricsLog();
+  RunTasks();
+  {
+    HistogramFlattenerDeltaRecorder flattener;
+    base::HistogramSnapshotManager snapshot_manager(&flattener);
+    snapshot_manager.StartDeltas();
+    provider()->RecordHistogramSnapshots(&snapshot_manager);
+    snapshot_manager.FinishDeltas();
+    EXPECT_EQ(2U, flattener.GetRecordedDeltaHistogramNames().size());
+  }
+
+  // Make sure a second call to the snapshot-recorder doesn't break anything.
+  {
+    HistogramFlattenerDeltaRecorder flattener;
+    base::HistogramSnapshotManager snapshot_manager(&flattener);
+    snapshot_manager.StartDeltas();
+    provider()->RecordHistogramSnapshots(&snapshot_manager);
+    snapshot_manager.FinishDeltas();
+    EXPECT_EQ(0U, flattener.GetRecordedDeltaHistogramNames().size());
+  }
+
+  // Second full run on the same file should produce nothing.
+  provider()->OnDidCreateMetricsLog();
+  RunTasks();
+  {
+    HistogramFlattenerDeltaRecorder flattener;
+    base::HistogramSnapshotManager snapshot_manager(&flattener);
+    snapshot_manager.StartDeltas();
+    provider()->RecordHistogramSnapshots(&snapshot_manager);
+    snapshot_manager.FinishDeltas();
+    EXPECT_EQ(0U, flattener.GetRecordedDeltaHistogramNames().size());
+  }
+
+  // Update the time-stamp of the file to indicate that it is "new" and
+  // must be recorded.
+  {
+    base::File touch(metrics_file(),
+                     base::File::FLAG_OPEN | base::File::FLAG_WRITE);
+    ASSERT_TRUE(touch.IsValid());
+    base::Time next = base::Time::Now() + base::TimeDelta::FromSeconds(1);
+    touch.SetTimes(next, next);
+  }
+
+  // This run should again have "new" histograms.
+  provider()->OnDidCreateMetricsLog();
+  RunTasks();
+  {
+    HistogramFlattenerDeltaRecorder flattener;
+    base::HistogramSnapshotManager snapshot_manager(&flattener);
+    snapshot_manager.StartDeltas();
+    provider()->RecordHistogramSnapshots(&snapshot_manager);
+    snapshot_manager.FinishDeltas();
+    EXPECT_EQ(2U, flattener.GetRecordedDeltaHistogramNames().size());
+  }
+}
+
+}  // namespace metrics