Enable startup profiling by Win x64 stack sampling profiler

components/metrics/call_stack_profile_metrics_provider_unittest.cc

 // 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/call_stack_profile_metrics_provider.h"
 
+#include "base/metrics/field_trial.h"
 #include "base/profiler/stack_sampling_profiler.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
+#include "components/variations/entropy_provider.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StackSamplingProfiler;
 using Frame = StackSamplingProfiler::Frame;
 using Module = StackSamplingProfiler::Module;
 using Profile = StackSamplingProfiler::CallStackProfile;
 using Sample = StackSamplingProfiler::Sample;
 
 namespace metrics {
 
+// This test fixture enables the field trial that
+// CallStackProfileMetricsProvider depends on to report profiles.
+class CallStackProfileMetricsProviderTest : public testing::Test {
+ public:
+  CallStackProfileMetricsProviderTest()
+      : field_trial_list_(new base::FieldTrialList(
+          new metrics::SHA1EntropyProvider("foo"))) {
+    base::FieldTrialList::CreateFieldTrial(
+        FieldTrialState::kFieldTrialName,
+        FieldTrialState::kReportProfilesGroupName);
+  }
+
+  ~CallStackProfileMetricsProviderTest() override {}
+
+ private:
+  // Exposes field trial/group names from the CallStackProfileMetricsProvider.
+  class FieldTrialState : public CallStackProfileMetricsProvider {
+   public:
+    using CallStackProfileMetricsProvider::kFieldTrialName;
+    using CallStackProfileMetricsProvider::kReportProfilesGroupName;
+  };
+
+  const scoped_ptr<base::FieldTrialList> field_trial_list_;
+};
+
 // Checks that all properties from multiple profiles are filled as expected.
-TEST(CallStackProfileMetricsProviderTest, MultipleProfiles) {
+TEST_F(CallStackProfileMetricsProviderTest, MultipleProfiles) {
   const uintptr_t module1_base_address = 0x1000;
   const uintptr_t module2_base_address = 0x2000;
   const uintptr_t module3_base_address = 0x3000;
 
   const Module profile_modules[][2] = {
     {
       Module(
           reinterpret_cast<const void*>(module1_base_address),
           "ABCD",
 #if defined(OS_WIN)
@@ skipping 126 matching lines @@
     }
 
     profile.profile_duration = profile_durations[i];
     profile.sampling_period = profile_sampling_periods[i];
     profile.preserve_sample_ordering = false;
 
     profiles.push_back(profile);
   }
 
   CallStackProfileMetricsProvider provider;
-  provider.SetSourceProfilesForTesting(profiles);
+  provider.AppendSourceProfilesForTesting(profiles);
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   ASSERT_EQ(static_cast<int>(arraysize(profile_sample_frames)),
             uma_proto.sampled_profile().size());
   for (size_t i = 0; i < arraysize(profile_sample_frames); ++i) {
     SCOPED_TRACE("profile " + base::IntToString(i));
     const SampledProfile& sampled_profile = uma_proto.sampled_profile().Get(i);
     ASSERT_TRUE(sampled_profile.has_call_stack_profile());
     const CallStackProfile& call_stack_profile =
@@ skipping 43 matching lines @@
     EXPECT_EQ(profile_durations[i].InMilliseconds(),
               call_stack_profile.profile_duration_ms());
     ASSERT_TRUE(call_stack_profile.has_sampling_period_ms());
     EXPECT_EQ(profile_sampling_periods[i].InMilliseconds(),
               call_stack_profile.sampling_period_ms());
   }
 }
 
 // Checks that all duplicate samples are collapsed with
 // preserve_sample_ordering = false.
-TEST(CallStackProfileMetricsProviderTest, RepeatedStacksUnordered) {
+TEST_F(CallStackProfileMetricsProviderTest, RepeatedStacksUnordered) {
   const uintptr_t module_base_address = 0x1000;
 
   const Module modules[] = {
     Module(
         reinterpret_cast<const void*>(module_base_address),
         "ABCD",
 #if defined(OS_WIN)
         base::FilePath(L"c:\\some\\path\\to\\chrome.exe")
 #else
         base::FilePath("/some/path/to/chrome")
@@ skipping 18 matching lines @@
     Sample& sample = profile.samples.back();
     sample.insert(sample.end(), &sample_frames[i][0],
                   &sample_frames[i][0] + arraysize(sample_frames[i]));
   }
 
   profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
   profile.sampling_period = base::TimeDelta::FromMilliseconds(10);
   profile.preserve_sample_ordering = false;
 
   CallStackProfileMetricsProvider provider;
-  provider.SetSourceProfilesForTesting(std::vector<Profile>(1, profile));
+  provider.AppendSourceProfilesForTesting(std::vector<Profile>(1, profile));
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   ASSERT_EQ(1, uma_proto.sampled_profile().size());
   const SampledProfile& sampled_profile = uma_proto.sampled_profile().Get(0);
   ASSERT_TRUE(sampled_profile.has_call_stack_profile());
   const CallStackProfile& call_stack_profile =
       sampled_profile.call_stack_profile();
 
   ASSERT_EQ(2, call_stack_profile.sample().size());
@@ skipping 17 matching lines @@
                 entry.address());
       ASSERT_TRUE(entry.has_module_id_index());
       EXPECT_EQ(sample_frames[i][j].module_index,
                 static_cast<size_t>(entry.module_id_index()));
     }
   }
 }
 
 // Checks that only contiguous duplicate samples are collapsed with
 // preserve_sample_ordering = true.
-TEST(CallStackProfileMetricsProviderTest, RepeatedStacksOrdered) {
+TEST_F(CallStackProfileMetricsProviderTest, RepeatedStacksOrdered) {
   const uintptr_t module_base_address = 0x1000;
 
   const Module modules[] = {
     Module(
         reinterpret_cast<const void*>(module_base_address),
         "ABCD",
 #if defined(OS_WIN)
         base::FilePath(L"c:\\some\\path\\to\\chrome.exe")
 #else
         base::FilePath("/some/path/to/chrome")
@@ skipping 18 matching lines @@
     Sample& sample = profile.samples.back();
     sample.insert(sample.end(), &sample_frames[i][0],
                   &sample_frames[i][0] + arraysize(sample_frames[i]));
   }
 
   profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
   profile.sampling_period = base::TimeDelta::FromMilliseconds(10);
   profile.preserve_sample_ordering = true;
 
   CallStackProfileMetricsProvider provider;
-  provider.SetSourceProfilesForTesting(std::vector<Profile>(1, profile));
+  provider.AppendSourceProfilesForTesting(std::vector<Profile>(1, profile));
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   ASSERT_EQ(1, uma_proto.sampled_profile().size());
   const SampledProfile& sampled_profile = uma_proto.sampled_profile().Get(0);
   ASSERT_TRUE(sampled_profile.has_call_stack_profile());
   const CallStackProfile& call_stack_profile =
       sampled_profile.call_stack_profile();
 
   ASSERT_EQ(3, call_stack_profile.sample().size());
@@ skipping 15 matching lines @@
           modules[sample_frames[i][j].module_index].base_address);
       EXPECT_EQ(static_cast<uint64>(instruction_pointer - module_base_address),
                 entry.address());
       ASSERT_TRUE(entry.has_module_id_index());
       EXPECT_EQ(sample_frames[i][j].module_index,
                 static_cast<size_t>(entry.module_id_index()));
     }
   }
 }
 
-
 // Checks that unknown modules produce an empty Entry.
-TEST(CallStackProfileMetricsProviderTest, UnknownModule) {
+TEST_F(CallStackProfileMetricsProviderTest, UnknownModule) {
   const Frame frame(reinterpret_cast<const void*>(0x1000),
                     Frame::kUnknownModuleIndex);
 
   Profile profile;
 
   profile.samples.push_back(Sample(1, frame));
 
   profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
   profile.sampling_period = base::TimeDelta::FromMilliseconds(10);
   profile.preserve_sample_ordering = false;
 
   CallStackProfileMetricsProvider provider;
-  provider.SetSourceProfilesForTesting(std::vector<Profile>(1, profile));
+  provider.AppendSourceProfilesForTesting(std::vector<Profile>(1, profile));
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   ASSERT_EQ(1, uma_proto.sampled_profile().size());
   const SampledProfile& sampled_profile = uma_proto.sampled_profile().Get(0);
   ASSERT_TRUE(sampled_profile.has_call_stack_profile());
   const CallStackProfile& call_stack_profile =
       sampled_profile.call_stack_profile();
 
   ASSERT_EQ(1, call_stack_profile.sample().size());
   const CallStackProfile::Sample& proto_sample =
       call_stack_profile.sample().Get(0);
   ASSERT_EQ(1, proto_sample.entry().size());
   ASSERT_TRUE(proto_sample.has_count());
   EXPECT_EQ(1u, proto_sample.count());
   const CallStackProfile::Entry& entry = proto_sample.entry().Get(0);
   EXPECT_FALSE(entry.has_address());
   EXPECT_FALSE(entry.has_module_id_index());
 }
 
+// Checks that pending profiles are only passed back to ProvideGeneralMetrics
+// once.
+TEST_F(CallStackProfileMetricsProviderTest, ProfilesProvidedOnlyOnce) {
+  CallStackProfileMetricsProvider provider;
+  for (int i = 0; i < 2; ++i) {
+    Profile profile;
+    profile.samples.push_back(Sample(1, Frame(
+        reinterpret_cast<const void*>(0x1000), Frame::kUnknownModuleIndex)));
+
+    profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
+    // Use the sampling period to distinguish the two profiles.
+    profile.sampling_period = base::TimeDelta::FromMilliseconds(i);
+    profile.preserve_sample_ordering = false;
+
+    provider.AppendSourceProfilesForTesting(std::vector<Profile>(1, profile));
+    ChromeUserMetricsExtension uma_proto;
+    provider.ProvideGeneralMetrics(&uma_proto);
+
+    ASSERT_EQ(1, uma_proto.sampled_profile().size());
+    const SampledProfile& sampled_profile = uma_proto.sampled_profile().Get(0);
+    ASSERT_TRUE(sampled_profile.has_call_stack_profile());
+    const CallStackProfile& call_stack_profile =
+        sampled_profile.call_stack_profile();
+    ASSERT_TRUE(call_stack_profile.has_sampling_period_ms());
+    EXPECT_EQ(i, call_stack_profile.sampling_period_ms());
+  }
+}
+
 }  // namespace metrics