Make stack sampling profiler sample beyond startup.

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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/macros.h"
-#include "base/metrics/field_trial.h"
 #include "base/profiler/stack_sampling_profiler.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/test/scoped_feature_list.h"
 #include "build/build_config.h"
 #include "components/metrics/call_stack_profile_params.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;
@@ skipping 83 matching lines @@
 }
 
 Profiles ProfilesFactory::Build() {
   return std::move(profiles_);
 }
 
 }  // namespace
 
 namespace metrics {
 
-// This test fixture enables the field trial that
+// This test fixture enables the feature that
 // CallStackProfileMetricsProvider depends on to report profiles.
 class CallStackProfileMetricsProviderTest : public testing::Test {
  public:
-  CallStackProfileMetricsProviderTest()
-      : field_trial_list_(nullptr) {
-    base::FieldTrialList::CreateFieldTrial(
-        TestState::kFieldTrialName,
-        TestState::kReportProfilesGroupName);
+  CallStackProfileMetricsProviderTest() {
+    scoped_feature_list_.InitAndEnableFeature(TestState::kEnableReporting);
     TestState::ResetStaticStateForTesting();
   }
 
   ~CallStackProfileMetricsProviderTest() override {}
 
   // Utility function to append profiles to the metrics provider.
-  void AppendProfiles(const CallStackProfileParams& params, Profiles profiles) {
+  void AppendProfiles(CallStackProfileParams* params, Profiles profiles) {
     CallStackProfileMetricsProvider::GetProfilerCallback(params).Run(
-        std::move(profiles));
+        std::move(profiles), nullptr);
   }
 
   void VerifyProfileProto(const ExpectedProtoProfile& expected,
                           const SampledProfile& proto);
 
  private:
-  // Exposes field trial/group names from the CallStackProfileMetricsProvider.
+  // Exposes the feature from the CallStackProfileMetricsProvider.
   class TestState : public CallStackProfileMetricsProvider {
    public:
-    using CallStackProfileMetricsProvider::kFieldTrialName;
-    using CallStackProfileMetricsProvider::kReportProfilesGroupName;
+    using CallStackProfileMetricsProvider::kEnableReporting;
     using CallStackProfileMetricsProvider::ResetStaticStateForTesting;
   };
 
-  base::FieldTrialList field_trial_list_;
+  base::test::ScopedFeatureList scoped_feature_list_;
 
   DISALLOW_COPY_AND_ASSIGN(CallStackProfileMetricsProviderTest);
 };
 
 void CallStackProfileMetricsProviderTest::VerifyProfileProto(
     const ExpectedProtoProfile& expected,
     const SampledProfile& proto) {
   ASSERT_TRUE(proto.has_call_stack_profile());
   const CallStackProfile& stack = proto.call_stack_profile();
 
@@ skipping 173 matching lines @@
           200, 20,
           expected_proto_modules2, arraysize(expected_proto_modules2),
           expected_proto_samples2, arraysize(expected_proto_samples2),
       },
   };
 
   ASSERT_EQ(arraysize(expected_proto_profiles), profiles.size());
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
-  AppendProfiles(
-      CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
-                             CallStackProfileParams::UI_THREAD,
-                             CallStackProfileParams::PROCESS_STARTUP,
-                             CallStackProfileParams::MAY_SHUFFLE),
-      std::move(profiles));
+  CallStackProfileParams params(CallStackProfileParams::BROWSER_PROCESS,
+                                CallStackProfileParams::UI_THREAD,
+                                CallStackProfileParams::PROCESS_STARTUP,
+                                CallStackProfileParams::MAY_SHUFFLE);
+  AppendProfiles(&params, std::move(profiles));
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   ASSERT_EQ(static_cast<int>(arraysize(expected_proto_profiles)),
             uma_proto.sampled_profile().size());
   for (size_t p = 0; p < arraysize(expected_proto_profiles); ++p) {
     SCOPED_TRACE("profile " + base::SizeTToString(p));
     VerifyProfileProto(expected_proto_profiles[p],
                        uma_proto.sampled_profile().Get(p));
   }
@@ skipping 59 matching lines @@
           100, 10,
           expected_proto_modules, arraysize(expected_proto_modules),
           expected_proto_samples, arraysize(expected_proto_samples),
       },
   };
 
   ASSERT_EQ(arraysize(expected_proto_profiles), profiles.size());
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
-  AppendProfiles(
-      CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
-                             CallStackProfileParams::UI_THREAD,
-                             CallStackProfileParams::PROCESS_STARTUP,
-                             CallStackProfileParams::MAY_SHUFFLE),
-      std::move(profiles));
+  CallStackProfileParams params(CallStackProfileParams::BROWSER_PROCESS,
+                                CallStackProfileParams::UI_THREAD,
+                                CallStackProfileParams::PROCESS_STARTUP,
+                                CallStackProfileParams::MAY_SHUFFLE);
+  AppendProfiles(&params, std::move(profiles));
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   ASSERT_EQ(static_cast<int>(arraysize(expected_proto_profiles)),
             uma_proto.sampled_profile().size());
   for (size_t p = 0; p < arraysize(expected_proto_profiles); ++p) {
     SCOPED_TRACE("profile " + base::SizeTToString(p));
     VerifyProfileProto(expected_proto_profiles[p],
                        uma_proto.sampled_profile().Get(p));
   }
@@ skipping 61 matching lines @@
           100, 10,
           expected_proto_modules, arraysize(expected_proto_modules),
           expected_proto_samples, arraysize(expected_proto_samples),
       },
   };
 
   ASSERT_EQ(arraysize(expected_proto_profiles), profiles.size());
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
-  AppendProfiles(CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
-                                        CallStackProfileParams::UI_THREAD,
-                                        CallStackProfileParams::PROCESS_STARTUP,
-                                        CallStackProfileParams::PRESERVE_ORDER),
-                 std::move(profiles));
+  CallStackProfileParams params(CallStackProfileParams::BROWSER_PROCESS,
+                                CallStackProfileParams::UI_THREAD,
+                                CallStackProfileParams::PROCESS_STARTUP,
+                                CallStackProfileParams::PRESERVE_ORDER);
+  AppendProfiles(&params, std::move(profiles));
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   ASSERT_EQ(static_cast<int>(arraysize(expected_proto_profiles)),
             uma_proto.sampled_profile().size());
   for (size_t p = 0; p < arraysize(expected_proto_profiles); ++p) {
     SCOPED_TRACE("profile " + base::SizeTToString(p));
     VerifyProfileProto(expected_proto_profiles[p],
                        uma_proto.sampled_profile().Get(p));
   }
@@ skipping 19 matching lines @@
           100, 10,
           nullptr, 0,
           expected_proto_samples, arraysize(expected_proto_samples),
       },
   };
 
   ASSERT_EQ(arraysize(expected_proto_profiles), profiles.size());
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
-  AppendProfiles(
-      CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
-                             CallStackProfileParams::UI_THREAD,
-                             CallStackProfileParams::PROCESS_STARTUP,
-                             CallStackProfileParams::MAY_SHUFFLE),
-      std::move(profiles));
+  CallStackProfileParams params(CallStackProfileParams::BROWSER_PROCESS,
+                                CallStackProfileParams::UI_THREAD,
+                                CallStackProfileParams::PROCESS_STARTUP,
+                                CallStackProfileParams::MAY_SHUFFLE);
+  AppendProfiles(&params, std::move(profiles));
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   ASSERT_EQ(static_cast<int>(arraysize(expected_proto_profiles)),
             uma_proto.sampled_profile().size());
   for (size_t p = 0; p < arraysize(expected_proto_profiles); ++p) {
     SCOPED_TRACE("profile " + base::SizeTToString(p));
     VerifyProfileProto(expected_proto_profiles[p],
                        uma_proto.sampled_profile().Get(p));
   }
 }
 
 // Checks that pending profiles are only passed back to ProvideGeneralMetrics
 // once.
 TEST_F(CallStackProfileMetricsProviderTest, ProfilesProvidedOnlyOnce) {
   CallStackProfileMetricsProvider provider;
   for (int r = 0; r < 2; ++r) {
     Profiles profiles = ProfilesFactory()
         // Use the sampling period to distinguish the two profiles.
         .NewProfile(100, r)
         .NewSample()
         .AddFrame(Frame::kUnknownModuleIndex, 0x1234)
         .Build();
 
     ASSERT_EQ(1U, profiles.size());
 
     CallStackProfileMetricsProvider provider;
     provider.OnRecordingEnabled();
-    AppendProfiles(
-        CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
-                               CallStackProfileParams::UI_THREAD,
-                               CallStackProfileParams::PROCESS_STARTUP,
-                               CallStackProfileParams::MAY_SHUFFLE),
-        std::move(profiles));
+    CallStackProfileParams params(CallStackProfileParams::BROWSER_PROCESS,
+                                  CallStackProfileParams::UI_THREAD,
+                                  CallStackProfileParams::PROCESS_STARTUP,
+                                  CallStackProfileParams::MAY_SHUFFLE);
+    AppendProfiles(&params, std::move(profiles));
     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(r, call_stack_profile.sampling_period_ms());
   }
 }
 
 // Checks that pending profiles are provided to ProvideGeneralMetrics
 // when collected before CallStackProfileMetricsProvider is instantiated.
 TEST_F(CallStackProfileMetricsProviderTest,
        ProfilesProvidedWhenCollectedBeforeInstantiation) {
   Profiles profiles = ProfilesFactory()
       .NewProfile(100, 10)
       .NewSample()
       .AddFrame(Frame::kUnknownModuleIndex, 0x1234)
       .Build();
 
   ASSERT_EQ(1U, profiles.size());
 
-  AppendProfiles(
-      CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
-                             CallStackProfileParams::UI_THREAD,
-                             CallStackProfileParams::PROCESS_STARTUP,
-                             CallStackProfileParams::MAY_SHUFFLE),
-      std::move(profiles));
+  CallStackProfileParams params(CallStackProfileParams::BROWSER_PROCESS,
+                                CallStackProfileParams::UI_THREAD,
+                                CallStackProfileParams::PROCESS_STARTUP,
+                                CallStackProfileParams::MAY_SHUFFLE);
+  AppendProfiles(&params, std::move(profiles));
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   EXPECT_EQ(1, uma_proto.sampled_profile_size());
 }
 
 // Checks that pending profiles are not provided to ProvideGeneralMetrics
 // while recording is disabled.
 TEST_F(CallStackProfileMetricsProviderTest, ProfilesNotProvidedWhileDisabled) {
   Profiles profiles = ProfilesFactory()
       .NewProfile(100, 10)
       .NewSample()
       .AddFrame(Frame::kUnknownModuleIndex, 0x1234)
       .Build();
 
   ASSERT_EQ(1U, profiles.size());
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingDisabled();
-  AppendProfiles(
-      CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
-                             CallStackProfileParams::UI_THREAD,
-                             CallStackProfileParams::PROCESS_STARTUP,
-                             CallStackProfileParams::MAY_SHUFFLE),
-      std::move(profiles));
+  CallStackProfileParams params(CallStackProfileParams::BROWSER_PROCESS,
+                                CallStackProfileParams::UI_THREAD,
+                                CallStackProfileParams::PROCESS_STARTUP,
+                                CallStackProfileParams::MAY_SHUFFLE);
+  AppendProfiles(&params, std::move(profiles));
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   EXPECT_EQ(0, uma_proto.sampled_profile_size());
 }
 
 // Checks that pending profiles are not provided to ProvideGeneralMetrics
 // if recording is disabled while profiling.
 TEST_F(CallStackProfileMetricsProviderTest,
        ProfilesNotProvidedAfterChangeToDisabled) {
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
+  CallStackProfileParams params(CallStackProfileParams::BROWSER_PROCESS,
+                                CallStackProfileParams::UI_THREAD,
+                                CallStackProfileParams::PROCESS_STARTUP,
+                                CallStackProfileParams::MAY_SHUFFLE);
   base::StackSamplingProfiler::CompletedCallback callback =
-      CallStackProfileMetricsProvider::GetProfilerCallback(
-          CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
-                                 CallStackProfileParams::UI_THREAD,
-                                 CallStackProfileParams::PROCESS_STARTUP,
-                                 CallStackProfileParams::MAY_SHUFFLE));
+      CallStackProfileMetricsProvider::GetProfilerCallback(&params);
   provider.OnRecordingDisabled();
 
   Profiles profiles = ProfilesFactory()
       .NewProfile(100, 10)
       .NewSample()
       .AddFrame(Frame::kUnknownModuleIndex, 0x1234)
       .Build();
-  callback.Run(std::move(profiles));
+  base::StackSamplingProfiler::SamplingParams sampling_params;
+  callback.Run(std::move(profiles), &sampling_params);
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   EXPECT_EQ(0, uma_proto.sampled_profile_size());
 }
 
 // Checks that pending profiles are not provided to ProvideGeneralMetrics if
 // recording is enabled, but then disabled and reenabled while profiling.
 TEST_F(CallStackProfileMetricsProviderTest,
        ProfilesNotProvidedAfterChangeToDisabledThenEnabled) {
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
+  CallStackProfileParams params(CallStackProfileParams::BROWSER_PROCESS,
+                                CallStackProfileParams::UI_THREAD,
+                                CallStackProfileParams::PROCESS_STARTUP,
+                                CallStackProfileParams::MAY_SHUFFLE);
   base::StackSamplingProfiler::CompletedCallback callback =
-      CallStackProfileMetricsProvider::GetProfilerCallback(
-          CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
-                                 CallStackProfileParams::UI_THREAD,
-                                 CallStackProfileParams::PROCESS_STARTUP,
-                                 CallStackProfileParams::MAY_SHUFFLE));
+      CallStackProfileMetricsProvider::GetProfilerCallback(&params);
   provider.OnRecordingDisabled();
   provider.OnRecordingEnabled();
 
   Profiles profiles = ProfilesFactory()
       .NewProfile(100, 10)
       .NewSample()
       .AddFrame(Frame::kUnknownModuleIndex, 0x1234)
       .Build();
-  callback.Run(std::move(profiles));
+  base::StackSamplingProfiler::SamplingParams sampling_params;
+  callback.Run(std::move(profiles), &sampling_params);
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   EXPECT_EQ(0, uma_proto.sampled_profile_size());
 }
 
 // Checks that pending profiles are not provided to ProvideGeneralMetrics
 // if recording is disabled, but then enabled while profiling.
 TEST_F(CallStackProfileMetricsProviderTest,
        ProfilesNotProvidedAfterChangeFromDisabled) {
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingDisabled();
+  CallStackProfileParams params(CallStackProfileParams::BROWSER_PROCESS,
+                                CallStackProfileParams::UI_THREAD,
+                                CallStackProfileParams::PROCESS_STARTUP,
+                                CallStackProfileParams::MAY_SHUFFLE);
   base::StackSamplingProfiler::CompletedCallback callback =
-      CallStackProfileMetricsProvider::GetProfilerCallback(
-          CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
-                                 CallStackProfileParams::UI_THREAD,
-                                 CallStackProfileParams::PROCESS_STARTUP,
-                                 CallStackProfileParams::MAY_SHUFFLE));
+      CallStackProfileMetricsProvider::GetProfilerCallback(&params);
   provider.OnRecordingEnabled();
 
   Profiles profiles = ProfilesFactory()
       .NewProfile(100, 10)
       .NewSample()
       .AddFrame(Frame::kUnknownModuleIndex, 0x1234)
       .Build();
-  callback.Run(std::move(profiles));
+  base::StackSamplingProfiler::SamplingParams sampling_params;
+  callback.Run(std::move(profiles), &sampling_params);
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   EXPECT_EQ(0, uma_proto.sampled_profile_size());
 }
 
 }  // namespace metrics