Send metrics with embedded system profiles after system startup.

components/metrics/file_metrics_provider_unittest.cc

 // 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 <functional>
+
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_flattener.h"
 #include "base/metrics/histogram_snapshot_manager.h"
 #include "base/metrics/persistent_histogram_allocator.h"
 #include "base/metrics/persistent_memory_allocator.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/metrics/metrics_pref_names.h"
+#include "components/metrics/persistent_system_profile.h"
+#include "components/metrics/proto/system_profile.pb.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 {
@@ skipping 78 matching lines @@
   }
 
   bool HasInitialStabilityMetrics() {
     return provider()->HasInitialStabilityMetrics();
   }
 
   void MergeHistogramDeltas() {
     provider()->MergeHistogramDeltas();
   }
 
+  bool ProvideIndependentMetrics(
+      SystemProfileProto* profile_proto,
+      base::HistogramSnapshotManager* snapshot_manager) {
+    return provider()->ProvideIndependentMetrics(profile_proto,
+                                                 snapshot_manager);
+  }
+
   void RecordInitialHistogramSnapshots(
       base::HistogramSnapshotManager* snapshot_manager) {
     provider()->RecordInitialHistogramSnapshots(snapshot_manager);
   }
 
   size_t GetSnapshotHistogramCount() {
     // Merge the data from the allocator into the StatisticsRecorder.
     provider()->MergeHistogramDeltas();
 
     // Flatten what is known to see what has changed since the last time.
@@ skipping 38 matching lines @@
   }
 
   void WriteMetricsFileAtTime(const base::FilePath& path,
                               base::PersistentHistogramAllocator* metrics,
                               base::Time write_time) {
     WriteMetricsFile(path, metrics);
     base::TouchFile(path, write_time, write_time);
   }
 
   std::unique_ptr<base::PersistentHistogramAllocator>
-  CreateMetricsFileWithHistograms(int histogram_count) {
+  CreateMetricsFileWithHistograms(
+      int histogram_count,
+      const std::function<void(base::PersistentHistogramAllocator*)>&
+          callback) {
     // Get this first so it isn't created inside the persistent allocator.
     base::GlobalHistogramAllocator::GetCreateHistogramResultHistogram();
 
     base::GlobalHistogramAllocator::CreateWithLocalMemory(
         create_large_files_ ? kLargeFileSize : kSmallFileSize,
         0, kMetricsName);
 
     CreateGlobalHistograms(histogram_count);
 
     std::unique_ptr<base::PersistentHistogramAllocator> histogram_allocator =
         base::GlobalHistogramAllocator::ReleaseForTesting();
+    callback(histogram_allocator.get());
+
     WriteMetricsFile(metrics_file(), histogram_allocator.get());
     return histogram_allocator;
   }
 
+  std::unique_ptr<base::PersistentHistogramAllocator>
+  CreateMetricsFileWithHistograms(int histogram_count) {
+    return CreateMetricsFileWithHistograms(
+        histogram_count, [](base::PersistentHistogramAllocator* allocator) {});
+  }
+
   base::HistogramBase* GetCreatedHistogram(int index) {
     DCHECK_GT(kMaxCreateHistograms, index);
     return created_histograms_[index];
   }
 
   const bool create_large_files_;
 
  private:
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
@@ skipping 199 matching lines @@
   CreateMetricsFileWithHistograms(2);
 
   // Register the file and allow the "checker" task to run.
   ASSERT_TRUE(PathExists(metrics_file()));
   provider()->RegisterSource(metrics_file(),
                              FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_FILE,
                              FileMetricsProvider::ASSOCIATE_PREVIOUS_RUN,
                              kMetricsName);
 
   // Record embedded snapshots via snapshot-manager.
-  HasInitialStabilityMetrics();
+  ASSERT_TRUE(HasInitialStabilityMetrics());
   RunTasks();
   {
     HistogramFlattenerDeltaRecorder flattener;
     base::HistogramSnapshotManager snapshot_manager(&flattener);
     RecordInitialHistogramSnapshots(&snapshot_manager);
     EXPECT_EQ(2U, flattener.GetRecordedDeltaHistogramNames().size());
   }
   EXPECT_TRUE(base::PathExists(metrics_file()));
   OnDidCreateMetricsLog();
   RunTasks();
   EXPECT_FALSE(base::PathExists(metrics_file()));
 
   // A run for normal histograms should produce nothing.
   CreateMetricsFileWithHistograms(2);
   OnDidCreateMetricsLog();
   RunTasks();
   EXPECT_EQ(0U, GetSnapshotHistogramCount());
   EXPECT_TRUE(base::PathExists(metrics_file()));
   OnDidCreateMetricsLog();
   RunTasks();
   EXPECT_TRUE(base::PathExists(metrics_file()));
 }
 
+TEST_P(FileMetricsProviderTest, AccessEmbeddedProfileMetricsWithoutProfile) {
+  ASSERT_FALSE(PathExists(metrics_file()));
+  CreateMetricsFileWithHistograms(2);
+
+  // Register the file and allow the "checker" task to run.
+  ASSERT_TRUE(PathExists(metrics_file()));
+  provider()->RegisterSource(
+      metrics_file(), FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_FILE,
+      FileMetricsProvider::ASSOCIATE_INTERNAL_PROFILE, kMetricsName);
+
+  // Record embedded snapshots via snapshot-manager.
+  OnDidCreateMetricsLog();
+  RunTasks();
+  {
+    HistogramFlattenerDeltaRecorder flattener;
+    base::HistogramSnapshotManager snapshot_manager(&flattener);
+    SystemProfileProto profile;
+
+    // A read of metrics with internal profiles should return nothing.
+    EXPECT_FALSE(ProvideIndependentMetrics(&profile, &snapshot_manager));
+  }
+  EXPECT_TRUE(base::PathExists(metrics_file()));
+  OnDidCreateMetricsLog();
+  RunTasks();
+  EXPECT_FALSE(base::PathExists(metrics_file()));
+}
+
+TEST_P(FileMetricsProviderTest, AccessEmbeddedProfileMetricsWithProfile) {
+  ASSERT_FALSE(PathExists(metrics_file()));
+  CreateMetricsFileWithHistograms(
+      2, [](base::PersistentHistogramAllocator* allocator) {
+        SystemProfileProto profile_proto;
+        SystemProfileProto::FieldTrial* trial = profile_proto.add_field_trial();
+        trial->set_name_id(123);
+        trial->set_group_id(456);
+
+        PersistentSystemProfile persistent_profile;
+        persistent_profile.RegisterPersistentAllocator(
+            allocator->memory_allocator());
+        persistent_profile.SetSystemProfile(profile_proto);
+      });
+
+  // Register the file and allow the "checker" task to run.
+  ASSERT_TRUE(PathExists(metrics_file()));
+  provider()->RegisterSource(
+      metrics_file(), FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_FILE,
+      FileMetricsProvider::ASSOCIATE_INTERNAL_PROFILE, kMetricsName);
+
+  // Record embedded snapshots via snapshot-manager.
+  OnDidCreateMetricsLog();
+  RunTasks();
+  {
+    HistogramFlattenerDeltaRecorder flattener;
+    base::HistogramSnapshotManager snapshot_manager(&flattener);
+    RecordInitialHistogramSnapshots(&snapshot_manager);
+    EXPECT_EQ(0U, flattener.GetRecordedDeltaHistogramNames().size());
+
+    // A read of metrics with internal profiles should return one result.
+    SystemProfileProto profile;
+    EXPECT_TRUE(ProvideIndependentMetrics(&profile, &snapshot_manager));
+    EXPECT_FALSE(ProvideIndependentMetrics(&profile, &snapshot_manager));
+  }
+  EXPECT_TRUE(base::PathExists(metrics_file()));
+  OnDidCreateMetricsLog();
+  RunTasks();
+  EXPECT_FALSE(base::PathExists(metrics_file()));
+}
+
+TEST_P(FileMetricsProviderTest, AccessEmbeddedFallbackMetricsWithoutProfile) {
+  ASSERT_FALSE(PathExists(metrics_file()));
+  CreateMetricsFileWithHistograms(2);
+
+  // Register the file and allow the "checker" task to run.
+  ASSERT_TRUE(PathExists(metrics_file()));
+  provider()->RegisterSource(
+      metrics_file(), FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_FILE,
+      FileMetricsProvider::ASSOCIATE_INTERNAL_PROFILE_OR_PREVIOUS_RUN,
+      kMetricsName);
+
+  // Record embedded snapshots via snapshot-manager.
+  ASSERT_TRUE(HasInitialStabilityMetrics());
+  RunTasks();
+  {
+    HistogramFlattenerDeltaRecorder flattener;
+    base::HistogramSnapshotManager snapshot_manager(&flattener);
+    RecordInitialHistogramSnapshots(&snapshot_manager);
+    EXPECT_EQ(2U, flattener.GetRecordedDeltaHistogramNames().size());
+
+    // A read of metrics with internal profiles should return nothing.
+    SystemProfileProto profile;
+    EXPECT_FALSE(ProvideIndependentMetrics(&profile, &snapshot_manager));
+  }
+  EXPECT_TRUE(base::PathExists(metrics_file()));
+  OnDidCreateMetricsLog();
+  RunTasks();
+  EXPECT_FALSE(base::PathExists(metrics_file()));
+}
+
+TEST_P(FileMetricsProviderTest, AccessEmbeddedFallbackMetricsWithProfile) {
+  ASSERT_FALSE(PathExists(metrics_file()));
+  CreateMetricsFileWithHistograms(
+      2, [](base::PersistentHistogramAllocator* allocator) {
+        SystemProfileProto profile_proto;
+        SystemProfileProto::FieldTrial* trial = profile_proto.add_field_trial();
+        trial->set_name_id(123);
+        trial->set_group_id(456);
+
+        PersistentSystemProfile persistent_profile;
+        persistent_profile.RegisterPersistentAllocator(
+            allocator->memory_allocator());
+        persistent_profile.SetSystemProfile(profile_proto);
+      });
+
+  // Register the file and allow the "checker" task to run.
+  ASSERT_TRUE(PathExists(metrics_file()));
+  provider()->RegisterSource(
+      metrics_file(), FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_FILE,
+      FileMetricsProvider::ASSOCIATE_INTERNAL_PROFILE_OR_PREVIOUS_RUN,
+      kMetricsName);
+
+  // Record embedded snapshots via snapshot-manager.
+  EXPECT_FALSE(HasInitialStabilityMetrics());
+  RunTasks();
+  {
+    HistogramFlattenerDeltaRecorder flattener;
+    base::HistogramSnapshotManager snapshot_manager(&flattener);
+    RecordInitialHistogramSnapshots(&snapshot_manager);
+    EXPECT_EQ(0U, flattener.GetRecordedDeltaHistogramNames().size());
+
+    // A read of metrics with internal profiles should return one result.
+    SystemProfileProto profile;
+    EXPECT_TRUE(ProvideIndependentMetrics(&profile, &snapshot_manager));
+    EXPECT_FALSE(ProvideIndependentMetrics(&profile, &snapshot_manager));
+  }
+  EXPECT_TRUE(base::PathExists(metrics_file()));
+  OnDidCreateMetricsLog();
+  RunTasks();
+  EXPECT_FALSE(base::PathExists(metrics_file()));
+}
+
 }  // namespace metrics