Add process lifetime annotations to stack samples.

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>
@@ skipping 175 matching lines @@
   std::vector<Profile> profiles;
   for (size_t i = 0; i < arraysize(profile_sample_frames); ++i) {
     Profile profile;
     profile.modules.insert(
         profile.modules.end(), &profile_modules[i][0],
         &profile_modules[i][0] + arraysize(profile_modules[i]));
 
     for (size_t j = 0; j < arraysize(profile_sample_frames[i]); ++j) {
       profile.samples.push_back(Sample());
       Sample& sample = profile.samples.back();
-      sample.insert(sample.end(), &profile_sample_frames[i][j][0],
-                    &profile_sample_frames[i][j][0] +
-                    arraysize(profile_sample_frames[i][j]));
+      sample.frames.insert(sample.frames.end(), &profile_sample_frames[i][j][0],
+                           &profile_sample_frames[i][j][0] +
+                               arraysize(profile_sample_frames[i][j]));
     }
 
     profile.profile_duration = profile_durations[i];
     profile.sampling_period = profile_sampling_periods[i];
 
     profiles.push_back(std::move(profile));
   }
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
   AppendProfiles(
       CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
                              CallStackProfileParams::UI_THREAD,
                              CallStackProfileParams::PROCESS_STARTUP,
                              CallStackProfileParams::MAY_SHUFFLE),
       std::move(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::SizeTToString(i));
     const SampledProfile& sampled_profile = uma_proto.sampled_profile().Get(i);
     ASSERT_TRUE(sampled_profile.has_call_stack_profile());
     const CallStackProfile& call_stack_profile =
         sampled_profile.call_stack_profile();
-
     ASSERT_EQ(static_cast<int>(arraysize(profile_sample_frames[i])),
               call_stack_profile.sample().size());
     for (size_t j = 0; j < arraysize(profile_sample_frames[i]); ++j) {
       SCOPED_TRACE("sample " + base::SizeTToString(j));
       const CallStackProfile::Sample& proto_sample =
           call_stack_profile.sample().Get(j);
       ASSERT_EQ(static_cast<int>(arraysize(profile_sample_frames[i][j])),
                 proto_sample.entry().size());
       ASSERT_TRUE(proto_sample.has_count());
       EXPECT_EQ(1u, proto_sample.count());
@@ skipping 53 matching lines @@
         module_base_address,
         "ABCD",
 #if defined(OS_WIN)
         base::FilePath(L"c:\\some\\path\\to\\chrome.exe")
 #else
         base::FilePath("/some/path/to/chrome")
 #endif
     )
   };
 
-  // Duplicate samples in slots 0, 2, and 3.
+  // Samples are unique only if the phase, activity, and frame all match.
+  const uint32_t profile_phases_and_activities[][2] = {
+    { 1, 0 },
+    { 1, 0 },
+    { 3, 0 },
+    { 3, 0 },
+    { 3, 1 },
+    // Unique above, duplicates below.
+    { 1, 0 },
+    { 1, 0 },
+    { 3, 0 },
+  };
   const Frame sample_frames[][1] = {

[Mike Wittman, 2016/11/03 21:15:39]

This test is getting kind of hard to follow... I think it would be easier to
understand if we represent the data at the Sample level. e.g.

Sample sample1({Frame(module_base_address + 0x10, 0)}, 1, 0);
Sample sample2({Frame(module_base_address + 0x20, 0)}, 1, 0);
Sample sample3({Frame(module_base_address + 0x10, 0)}, 3, 0);
Sample sample4({Frame(module_base_address + 0x20, 0)}, 3, 0);
Sample sample5({Frame(module_base_address + 0x20, 0)}, 3, 1);
const Sample samples[] = {
  sample1,
  sample2,
  sample3,
  sample4,
  sample5,
  sample1,
  sample1,
  sample3
};

struct Expected {
  Sample sample;
  int count;
};

Expected expected[] = {
  {sample1, 3},
  {sample2, 1},
  {sample3, 2},
  {sample4, 1},
  {sample5, 1}
};

     { Frame(module_base_address + 0x10, 0), },
     { Frame(module_base_address + 0x20, 0), },
     { Frame(module_base_address + 0x10, 0), },
-    { Frame(module_base_address + 0x10, 0) }
+    { Frame(module_base_address + 0x20, 0), },
+    { Frame(module_base_address + 0x10, 0), },
+    // Unique above, duplicates below.
+    { Frame(module_base_address + 0x10, 0), },
+    { Frame(module_base_address + 0x10, 0), },
+    { Frame(module_base_address + 0x10, 0), },
+  };
+
+  const int duplicate_counts[] = {
+    3, 1, 2, 1, 1,
   };
 
   Profile profile;
   profile.modules.insert(profile.modules.end(), &modules[0],
       &modules[0] + arraysize(modules));
 
   for (size_t i = 0; i < arraysize(sample_frames); ++i) {
     profile.samples.push_back(Sample());
     Sample& sample = profile.samples.back();
-    sample.insert(sample.end(), &sample_frames[i][0],
-                  &sample_frames[i][0] + arraysize(sample_frames[i]));
+    sample.process_phases = profile_phases_and_activities[i][0];
+    sample.current_activities = profile_phases_and_activities[i][1];
+    sample.frames.insert(sample.frames.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);
   Profiles profiles;
   profiles.push_back(std::move(profile));
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
   AppendProfiles(
       CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
                              CallStackProfileParams::UI_THREAD,
                              CallStackProfileParams::PROCESS_STARTUP,
                              CallStackProfileParams::MAY_SHUFFLE),
       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_EQ(2, call_stack_profile.sample().size());
-  for (int i = 0; i < 2; ++i) {
-    SCOPED_TRACE("sample " + base::IntToString(i));
+  ASSERT_EQ(static_cast<int>(arraysize(duplicate_counts)),
+            call_stack_profile.sample().size());
+  for (size_t i = 0; i < arraysize(duplicate_counts); ++i) {
+    SCOPED_TRACE("sample " + base::SizeTToString(i));
     const CallStackProfile::Sample& proto_sample =
         call_stack_profile.sample().Get(i);
+
+    // For MAY_SHUFFLE, these are reset with every sample.
+    uint32_t process_phase = 0;
+    uint32_t current_activities = 0;
+
     ASSERT_EQ(static_cast<int>(arraysize(sample_frames[i])),
               proto_sample.entry().size());
     ASSERT_TRUE(proto_sample.has_count());
-    EXPECT_EQ(i == 0 ? 3u : 1u, proto_sample.count());
+    EXPECT_EQ(duplicate_counts[i], proto_sample.count());
     for (size_t j = 0; j < arraysize(sample_frames[i]); ++j) {
       SCOPED_TRACE("frame " + base::SizeTToString(j));
       const CallStackProfile::Entry& entry = proto_sample.entry().Get(j);
       ASSERT_TRUE(entry.has_address());
       const char* instruction_pointer = reinterpret_cast<const char*>(
           sample_frames[i][j].instruction_pointer);
       const char* module_base_address = reinterpret_cast<const char*>(
           modules[sample_frames[i][j].module_index].base_address);
       EXPECT_EQ(
           static_cast<uint64_t>(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()));
     }
+
+    for (int x = 0; x < proto_sample.process_phase_size(); ++x) {
+      process_phase |= 1 << proto_sample.process_phase(x);
+    }
+    EXPECT_EQ(profile_phases_and_activities[i][0], process_phase);
+
+    for (int x = 0; x < proto_sample.activities_begun_size(); ++x) {
+      current_activities |= 1 << proto_sample.activities_begun(x);
+    }
+    for (int x = 0; x < proto_sample.activities_ended_size(); ++x) {

[Mike Wittman, 2016/11/03 21:15:39]

EXPECT_EQ(0u, proto_sample.activities_ended_size()) ?

+      current_activities &= ~(1 << proto_sample.activities_ended(x));
+    }
+    EXPECT_EQ(profile_phases_and_activities[i][1], current_activities);
   }
 }
 
 // Checks that only contiguous duplicate samples are collapsed with
 // preserve_sample_ordering = true.
 TEST_F(CallStackProfileMetricsProviderTest, RepeatedStacksOrdered) {
   const uintptr_t module_base_address = 0x1000;
 
   const Module modules[] = {
     Module(
         module_base_address,
         "ABCD",
 #if defined(OS_WIN)
         base::FilePath(L"c:\\some\\path\\to\\chrome.exe")
 #else
         base::FilePath("/some/path/to/chrome")
 #endif
     )
   };
 
-  // Duplicate samples in slots 0, 2, and 3.
+  // Samples are unique only if the phase, activity, and frame all match.
+  const uint32_t profile_phases_and_activities[][2] = {
+    { 1, 0 },
+    { 1, 0 },
+    { 1, 0 },
+    { 1, 0 },
+
+    { 3, 0 },
+    { 3, 1 },
+    { 3, 0 },
+    { 3, 0 },
+  };
   const Frame sample_frames[][1] = {

[Mike Wittman, 2016/11/03 21:15:39]

Same comment here about representing with Sample.

     { Frame(module_base_address + 0x10, 0), },
     { Frame(module_base_address + 0x20, 0), },
     { Frame(module_base_address + 0x10, 0), },
-    { Frame(module_base_address + 0x10, 0) }
+    { Frame(module_base_address + 0x10, 0), },
+
+    { Frame(module_base_address + 0x10, 0), },
+    { Frame(module_base_address + 0x20, 0), },
+    { Frame(module_base_address + 0x10, 0), },
+    { Frame(module_base_address + 0x10, 0), },
+  };
+
+  const int duplicate_counts[] = {
+    1, 1, 2, 1, 1, 2
   };
 
   Profile profile;
   profile.modules.insert(profile.modules.end(), &modules[0],
       &modules[0] + arraysize(modules));
 
   for (size_t i = 0; i < arraysize(sample_frames); ++i) {
     profile.samples.push_back(Sample());
     Sample& sample = profile.samples.back();
-    sample.insert(sample.end(), &sample_frames[i][0],
-                  &sample_frames[i][0] + arraysize(sample_frames[i]));
+    sample.process_phases = profile_phases_and_activities[i][0];
+    sample.current_activities = profile_phases_and_activities[i][1];
+    sample.frames.insert(sample.frames.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);
   Profiles profiles;
   profiles.push_back(std::move(profile));
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
   AppendProfiles(CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
                                         CallStackProfileParams::UI_THREAD,
                                         CallStackProfileParams::PROCESS_STARTUP,
                                         CallStackProfileParams::PRESERVE_ORDER),
                  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_EQ(3, call_stack_profile.sample().size());
-  for (int i = 0; i < 3; ++i) {
-    SCOPED_TRACE("sample " + base::IntToString(i));
+  // For PRESERVE_ORDER, these are reset with every profile.
+  uint32_t process_phase = 0;
+  uint32_t current_activities = 0;
+
+  ASSERT_EQ(static_cast<int>(arraysize(duplicate_counts)),
+            call_stack_profile.sample().size());
+  for (size_t i = 0, d = 0; i < arraysize(duplicate_counts);
+       d += duplicate_counts[i], ++i) {
+    // |d| is the index after compensating for duplicate compression.
+    SCOPED_TRACE("sample " + base::SizeTToString(i));
     const CallStackProfile::Sample& proto_sample =
         call_stack_profile.sample().Get(i);
     ASSERT_EQ(static_cast<int>(arraysize(sample_frames[i])),
               proto_sample.entry().size());
     ASSERT_TRUE(proto_sample.has_count());
-    EXPECT_EQ(i == 2 ? 2u : 1u, proto_sample.count());
-    for (size_t j = 0; j < arraysize(sample_frames[i]); ++j) {
+    EXPECT_EQ(duplicate_counts[i], proto_sample.count());
+    for (size_t j = 0; j < arraysize(sample_frames[d]); ++j) {
       SCOPED_TRACE("frame " + base::SizeTToString(j));
       const CallStackProfile::Entry& entry = proto_sample.entry().Get(j);
       ASSERT_TRUE(entry.has_address());
       const char* instruction_pointer = reinterpret_cast<const char*>(
-          sample_frames[i][j].instruction_pointer);
+          sample_frames[d][j].instruction_pointer);
       const char* module_base_address = reinterpret_cast<const char*>(
-          modules[sample_frames[i][j].module_index].base_address);
+          modules[sample_frames[d][j].module_index].base_address);
       EXPECT_EQ(
           static_cast<uint64_t>(instruction_pointer - module_base_address),
           entry.address());
       ASSERT_TRUE(entry.has_module_id_index());
-      EXPECT_EQ(sample_frames[i][j].module_index,
+      EXPECT_EQ(sample_frames[d][j].module_index,
                 static_cast<size_t>(entry.module_id_index()));
     }
+
+    for (int x = 0; x < proto_sample.process_phase_size(); ++x) {
+      process_phase |= 1 << proto_sample.process_phase(x);
+    }
+    EXPECT_EQ(profile_phases_and_activities[d][0], process_phase);
+
+    for (int x = 0; x < proto_sample.activities_begun_size(); ++x) {
+      current_activities |= 1 << proto_sample.activities_begun(x);
+    }
+    for (int x = 0; x < proto_sample.activities_ended_size(); ++x) {
+      current_activities &= ~(1 << proto_sample.activities_ended(x));
+    }
+    EXPECT_EQ(profile_phases_and_activities[d][1], current_activities);
   }
 }
 
 // Checks that unknown modules produce an empty Entry.
 TEST_F(CallStackProfileMetricsProviderTest, UnknownModule) {
-  const Frame frame(0x1000, Frame::kUnknownModuleIndex);
-
   Profile profile;
-
-  profile.samples.push_back(Sample(1, frame));
-
+  profile.samples.push_back(Sample(Frame(0x1000, Frame::kUnknownModuleIndex)));
   profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
   profile.sampling_period = base::TimeDelta::FromMilliseconds(10);
   Profiles profiles;
   profiles.push_back(std::move(profile));
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
   AppendProfiles(
       CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
                              CallStackProfileParams::UI_THREAD,
@@ skipping 20 matching lines @@
   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(0x1000, Frame::kUnknownModuleIndex)));
+        Sample((Frame(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);
     Profiles profiles;
     profiles.push_back(std::move(profile));
 
     provider.OnRecordingEnabled();
     AppendProfiles(
         CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
@@ skipping 12 matching lines @@
     ASSERT_TRUE(call_stack_profile.has_sampling_period_ms());
     EXPECT_EQ(i, call_stack_profile.sampling_period_ms());
   }
 }
 
 // Checks that pending profiles are provided to ProvideGeneralMetrics
 // when collected before CallStackProfileMetricsProvider is instantiated.
 TEST_F(CallStackProfileMetricsProviderTest,
        ProfilesProvidedWhenCollectedBeforeInstantiation) {
   Profile profile;
-  profile.samples.push_back(
-      Sample(1, Frame(0x1000, Frame::kUnknownModuleIndex)));
-
+  profile.samples.push_back(Sample(Frame(0x1000, Frame::kUnknownModuleIndex)));
   profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
   profile.sampling_period = base::TimeDelta::FromMilliseconds(10);
   Profiles profiles;
   profiles.push_back(std::move(profile));
 
   AppendProfiles(
       CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
                              CallStackProfileParams::UI_THREAD,
                              CallStackProfileParams::PROCESS_STARTUP,
                              CallStackProfileParams::MAY_SHUFFLE),
       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) {
   Profile profile;
-  profile.samples.push_back(
-      Sample(1, Frame(0x1000, Frame::kUnknownModuleIndex)));
-
+  profile.samples.push_back(Sample(Frame(0x1000, Frame::kUnknownModuleIndex)));
   profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
   profile.sampling_period = base::TimeDelta::FromMilliseconds(10);
   Profiles profiles;
   profiles.push_back(std::move(profile));
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingDisabled();
   AppendProfiles(
       CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
                              CallStackProfileParams::UI_THREAD,
                              CallStackProfileParams::PROCESS_STARTUP,
                              CallStackProfileParams::MAY_SHUFFLE),
       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) {
   Profile profile;
-  profile.samples.push_back(
-      Sample(1, Frame(0x1000, Frame::kUnknownModuleIndex)));
-
+  profile.samples.push_back(Sample(Frame(0x1000, Frame::kUnknownModuleIndex)));
   profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
   profile.sampling_period = base::TimeDelta::FromMilliseconds(10);
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
   base::StackSamplingProfiler::CompletedCallback callback =
       CallStackProfileMetricsProvider::GetProfilerCallback(
           CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
                                  CallStackProfileParams::UI_THREAD,
                                  CallStackProfileParams::PROCESS_STARTUP,
                                  CallStackProfileParams::MAY_SHUFFLE));
 
   provider.OnRecordingDisabled();
   Profiles profiles;
   profiles.push_back(std::move(profile));
   callback.Run(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 enabled, but then disabled and reenabled while profiling.
 TEST_F(CallStackProfileMetricsProviderTest,
        ProfilesNotProvidedAfterChangeToDisabledThenEnabled) {
   Profile profile;
-  profile.samples.push_back(
-      Sample(1, Frame(0x1000, Frame::kUnknownModuleIndex)));
-
+  profile.samples.push_back(Sample(Frame(0x1000, Frame::kUnknownModuleIndex)));
   profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
   profile.sampling_period = base::TimeDelta::FromMilliseconds(10);
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingEnabled();
   base::StackSamplingProfiler::CompletedCallback callback =
       CallStackProfileMetricsProvider::GetProfilerCallback(
           CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
                                  CallStackProfileParams::UI_THREAD,
                                  CallStackProfileParams::PROCESS_STARTUP,
                                  CallStackProfileParams::MAY_SHUFFLE));
 
   provider.OnRecordingDisabled();
   provider.OnRecordingEnabled();
   Profiles profiles;
   profiles.push_back(std::move(profile));
   callback.Run(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, but then enabled while profiling.
 TEST_F(CallStackProfileMetricsProviderTest,
        ProfilesNotProvidedAfterChangeFromDisabled) {
   Profile profile;
-  profile.samples.push_back(
-      Sample(1, Frame(0x1000, Frame::kUnknownModuleIndex)));
-
+  profile.samples.push_back(Sample(Frame(0x1000, Frame::kUnknownModuleIndex)));
   profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
   profile.sampling_period = base::TimeDelta::FromMilliseconds(10);
 
   CallStackProfileMetricsProvider provider;
   provider.OnRecordingDisabled();
   base::StackSamplingProfiler::CompletedCallback callback =
       CallStackProfileMetricsProvider::GetProfilerCallback(
           CallStackProfileParams(CallStackProfileParams::BROWSER_PROCESS,
                                  CallStackProfileParams::UI_THREAD,
                                  CallStackProfileParams::PROCESS_STARTUP,
                                  CallStackProfileParams::MAY_SHUFFLE));
 
   provider.OnRecordingEnabled();
   Profiles profiles;
   profiles.push_back(std::move(profile));
   callback.Run(std::move(profiles));
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   EXPECT_EQ(0, uma_proto.sampled_profile_size());
 }
 
 }  // namespace metrics