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..5cb2717a5ef666160d3367bf56a5b05d0f42b18c
--- /dev/null
+++ b/components/metrics/file_metrics_provider_unittest.cc
@@ -0,0 +1,158 @@
+// Copyright 2015 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/prefs/pref_registry_simple.h"
+#include "base/prefs/testing_pref_service.h"
+#include "components/metrics/metrics_pref_names.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using namespace base;
+
+namespace {
+const char* kMetricsName = "TestMetrics";
+const char* kMetricsFilename = "file.metrics";
+}  // namespace
+
+namespace metrics {
+
+class HistogramFlattenerDeltaRecorder : public HistogramFlattener {
+ public:
+  HistogramFlattenerDeltaRecorder() {}
+
+  void RecordDelta(const HistogramBase& histogram,
+                   const HistogramSamples& snapshot) override {
+    recorded_delta_histogram_names_.push_back(histogram.histogram_name());
+  }
+
+  void InconsistencyDetected(HistogramBase::Inconsistency problem) override {
+    ASSERT_TRUE(false);
+  }
+
+  void UniqueInconsistencyDetected(
+      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() : prefs_(new TestingPrefServiceSimple) {
+    EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
+    FileMetricsProvider::RegisterPrefs(prefs_->registry(), kMetricsName);
+  }
+
+  TestingPrefServiceSimple* prefs() { return prefs_.get(); }
+  FilePath temp_dir() { return temp_dir_.path(); }
+  FilePath metrics_file() {
+    return temp_dir_.path().AppendASCII(kMetricsFilename);
+  }
+
+  FileMetricsProvider* provider() {
+    if (!provider_)
+      provider_.reset(new FileMetricsProvider(nullptr, prefs()));
+    return provider_.get();
+  }
+
+ private:
+  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.
+    GetCreateHistogramResultHistogram();
+
+    SetPersistentHistogramMemoryAllocator(
+        new LocalPersistentMemoryAllocator(64 << 10, 0, kMetricsName));
+    HistogramBase* foo = Histogram::FactoryGet("foo", 1, 100, 10, 0);
+    HistogramBase* bar = Histogram::FactoryGet("bar", 1, 100, 10, 0);
+    foo->Add(42);
+    bar->Add(84);
+
+    scoped_ptr<PersistentMemoryAllocator> allocator(
+        ReleasePersistentHistogramMemoryAllocator());
+    File writer(metrics_file(), File::FLAG_CREATE | File::FLAG_WRITE);
+    EXPECT_TRUE(writer.IsValid());
+    writer.Write(0, (const char*)allocator->data(), allocator->used());
+  }
+
+  ASSERT_TRUE(PathExists(metrics_file()));
+  EXPECT_EQ(0, provider()->metrics_files_.size());
+  provider()->RegisterFile(metrics_file(),
+                           FileMetricsProvider::FILE_HISTOGRAMS_ATOMIC,
+                           kMetricsName);
+  EXPECT_EQ(1, provider()->metrics_files_.size());
+
+  scoped_ptr<FileMetricsProvider::FileInformationList> check_list(
+      new FileMetricsProvider::FileInformationList());
+  std::swap(provider()->metrics_files_, *check_list);
+  FileMetricsProvider::FileInformation* file = check_list->begin()->get();
+  ASSERT_TRUE(file);
+  base::Time not_seen = file->last_seen;
+
+  // Simulate schedules tasks and callbacks to detect file availability.
+  EXPECT_EQ(0, provider()->metrics_found_.size());
+  ASSERT_TRUE(provider()->CheckAndMapNewMetrics(file));
+  provider()->RecordFileInformation(check_list.get());
+  EXPECT_EQ(1, provider()->metrics_found_.size());
+  EXPECT_EQ(0, provider()->metrics_files_.size());
+  ASSERT_TRUE(file->mapped);
+  ASSERT_FALSE(file->allocator);
+
+  // Management of file-check results is done by OnDidCreateMetricsLog.
+  provider()->OnDidCreateMetricsLog();
+  EXPECT_EQ(1, provider()->metrics_found_.size());
+  EXPECT_EQ(0, provider()->metrics_files_.size());
+
+  // Record embedded snapshots via snapshot-manager.
+  HistogramFlattenerDeltaRecorder flattener;
+  HistogramSnapshotManager snapshot_manager(&flattener);
+  snapshot_manager.StartDeltas();
+  provider()->RecordHistogramSnapshots(&snapshot_manager);
+  snapshot_manager.FinishDeltas();
+  EXPECT_EQ(2, flattener.GetRecordedDeltaHistogramNames().size());
+
+  // Release happens when snapshot is complete.
+  EXPECT_FALSE(file->mapped);
+  EXPECT_FALSE(file->allocator);
+  EXPECT_LT(not_seen, file->last_seen);
+
+  // Next call to OnDidCreateMetricsLog will re-categorize the file.
+  provider()->OnDidCreateMetricsLog();
+  EXPECT_EQ(0, provider()->metrics_found_.size());
+  EXPECT_EQ(1, provider()->metrics_files_.size());
+}
+
+}  // namespace metrics