Revert "[Sampling profiler] Provide timestamp with sample"

This reverts commit 6f0c3820.

Reason for revert: StackSamplerImplTest.CopyStackTimestamp is crashing on MSan bots.
https://ci.chromium.org/p/chromium/builders/ci/Linux%20MSan%20Tests/21249
https://ci.chromium.org/p/chromium/builders/ci/Linux%20ChromiumOS%20MSan%20Tests/16883

Original change's description:
> [Sampling profiler] Provide timestamp with sample
> 
> Records timestamps along with samples and plumbs them through to
> the ProfileBuilder interface. The CallStackProfileBuilder subclass
> will be updated in a following CL to record the timestamps, to
> support retrospective tagging of metadata on the samples.
> 
> Bug: 1034758
> Change-Id: Ic631d47773db5ce8ed5117c08aba5d5931cb7884
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1972931
> Reviewed-by: Lei Zhang <thestig@chromium.org>
> Reviewed-by: Etienne Pierre-Doray <etiennep@chromium.org>
> Reviewed-by: oysteine <oysteine@chromium.org>
> Commit-Queue: Mike Wittman <wittman@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#726526}

TBR=thestig@chromium.org,wittman@chromium.org,oysteine@chromium.org,etiennep@chromium.org

Change-Id: I752676dd15b9a6e2aad897c4c9442eaad1dda9b3
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 1034758
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1977893Reviewed-by: Kunihiko Sakamoto <ksakamoto@chromium.org>
Commit-Queue: Kunihiko Sakamoto <ksakamoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#726675}

base/profiler/profile_builder.h

@@ -62,8 +62,7 @@ class BASE_EXPORT ProfileBuilder {
   virtual void RecordMetadata(MetadataProvider* metadata_provider) {}
 
   // Records a new set of frames. Invoked when sampling a sample completes.
-  virtual void OnSampleCompleted(std::vector<Frame> frames,
-                                 TimeTicks sample_timestamp) = 0;
+  virtual void OnSampleCompleted(std::vector<Frame> frames) = 0;
 
   // Finishes the profile construction with |profile_duration| and
   // |sampling_period|. Invoked when sampling a profile completes.

base/profiler/stack_copier.h

@@ -9,7 +9,6 @@
 
 #include "base/base_export.h"
 #include "base/profiler/register_context.h"
-#include "base/time/time.h"
 
 namespace base {
 
@@ -27,12 +26,11 @@ class BASE_EXPORT StackCopier {
 
   // Copies the thread's register context into |thread_context|, the stack into
   // |stack_buffer|, and the top of stack address into |stack_top|. Records
-  // metadata while the thread is suspended via |profile_builder|. Records
-  // |timestamp| at the time the stack was copied. Returns true if successful.
+  // metadata while the thread is suspended via |profile_builder|. Returns true
+  // if successful.
   virtual bool CopyStack(StackBuffer* stack_buffer,
                          uintptr_t* stack_top,
                          ProfileBuilder* profile_builder,
-                         TimeTicks* timestamp,
                          RegisterContext* thread_context) = 0;
 
  protected:

base/profiler/stack_copier_signal.cc

@@ -82,19 +82,13 @@ struct HandlerParams {
   AsyncSafeWaitableEvent* event;
 
   // Return values:
-
   // Successfully copied the stack segment.
   bool* success;
-
   // The thread context of the leaf function.
   mcontext_t* context;
-
   // Buffer to copy the stack segment.
   StackBuffer* stack_buffer;
   const uint8_t** stack_copy_bottom;
-
-  // The timestamp when the stack was copied.
-  TimeTicks* timestamp;
 };
 
 // Pointer to the parameters to be "passed" to the CopyStackSignalHandler() from
@@ -107,11 +101,6 @@ std::atomic<HandlerParams*> g_handler_params;
 // function may only call reentrant code.
 void CopyStackSignalHandler(int n, siginfo_t* siginfo, void* sigcontext) {
   HandlerParams* params = g_handler_params.load(std::memory_order_acquire);
-
-  // TimeTicks::Now() is implemented in terms of clock_gettime on Linux, which
-  // is signal safe per the signal-safety(7) man page.
-  *params->timestamp = TimeTicks::Now();
-
   ScopedEventSignaller e(params->event);
   *params->success = false;
 
@@ -187,15 +176,13 @@ StackCopierSignal::~StackCopierSignal() = default;
 bool StackCopierSignal::CopyStack(StackBuffer* stack_buffer,
                                   uintptr_t* stack_top,
                                   ProfileBuilder* profile_builder,
-                                  TimeTicks* timestamp,
                                   RegisterContext* thread_context) {
   AsyncSafeWaitableEvent wait_event;
   bool copied = false;
   const uint8_t* stack_copy_bottom = nullptr;
   const uintptr_t stack_base_address = thread_delegate_->GetStackBaseAddress();
   HandlerParams params = {stack_base_address, &wait_event,  &copied,
-                          thread_context,     stack_buffer, &stack_copy_bottom,
-                          timestamp};
+                          thread_context,     stack_buffer, &stack_copy_bottom};
   {
     ScopedSetSignalHandlerParams scoped_handler_params(&params);
 

base/profiler/stack_copier_signal.h

@@ -25,7 +25,6 @@ class BASE_EXPORT StackCopierSignal : public StackCopier {
   bool CopyStack(StackBuffer* stack_buffer,
                  uintptr_t* stack_top,
                  ProfileBuilder* profile_builder,
-                 TimeTicks* timestamp,
                  RegisterContext* thread_context) override;
 
   using StackCopier::CopyStackContentsAndRewritePointers;

base/profiler/stack_copier_signal_unittest.cc

@@ -35,8 +35,7 @@ class TestProfileBuilder : public ProfileBuilder {
   void RecordMetadata(
       base::ProfileBuilder::MetadataProvider* metadata_provider) override {}
 
-  void OnSampleCompleted(std::vector<Frame> frames,
-                         TimeTicks sample_timestamp) override {}
+  void OnSampleCompleted(std::vector<Frame> frames) override {}
   void OnProfileCompleted(TimeDelta profile_duration,
                           TimeDelta sampling_period) override {}
 
@@ -96,7 +95,6 @@ TEST(StackCopierSignalTest, MAYBE_CopyStack) {
   memset(stack_buffer.buffer(), 0, stack_buffer.size());
   uintptr_t stack_top = 0;
   TestProfileBuilder profiler_builder;
-  TimeTicks timestamp;
   RegisterContext context;
 
   StackCopierSignal copier(std::make_unique<ThreadDelegatePosix>(
@@ -108,8 +106,8 @@ TEST(StackCopierSignalTest, MAYBE_CopyStack) {
   for (size_t i = 0; i < size(kStackSentinels); ++i)
     sentinels[i] = kStackSentinels[i];
 
-  bool result = copier.CopyStack(&stack_buffer, &stack_top, &profiler_builder,
-                                 &timestamp, &context);
+  bool result =
+      copier.CopyStack(&stack_buffer, &stack_top, &profiler_builder, &context);
   ASSERT_TRUE(result);
 
   uint32_t* const end = reinterpret_cast<uint32_t*>(stack_top);
@@ -122,33 +120,6 @@ TEST(StackCopierSignalTest, MAYBE_CopyStack) {
   EXPECT_NE(end, sentinel_location);
 }
 
-// TSAN hangs on the AsyncSafeWaitableEvent FUTEX_WAIT call.
-#if defined(THREAD_SANITIZER)
-#define MAYBE_CopyStackTimestamp DISABLED_CopyStackTimestamp
-#else
-#define MAYBE_CopyStackTimestamp CopyStackTimestamp
-#endif
-TEST(StackCopierSignalTest, MAYBE_CopyStackTimestamp) {
-  StackBuffer stack_buffer(/* buffer_size = */ 1 << 20);
-  memset(stack_buffer.buffer(), 0, stack_buffer.size());
-  uintptr_t stack_top = 0;
-  TestProfileBuilder profiler_builder;
-  TimeTicks timestamp;
-  RegisterContext context;
-
-  StackCopierSignal copier(std::make_unique<ThreadDelegatePosix>(
-      GetSamplingProfilerCurrentThreadToken()));
-
-  TimeTicks before = TimeTicks::Now();
-  bool result = copier.CopyStack(&stack_buffer, &stack_top, &profiler_builder,
-                                 &timestamp, &context);
-  TimeTicks after = TimeTicks::Now();
-  ASSERT_TRUE(result);
-
-  EXPECT_GE(timestamp, before);
-  EXPECT_LE(timestamp, after);
-}
-
 // Limit to 32-bit Android, which is the platform we care about for this
 // functionality. The test is broken on too many other varied platforms to try
 // to selectively disable.
@@ -162,7 +133,6 @@ TEST(StackCopierSignalTest, MAYBE_CopyStackFromOtherThread) {
   memset(stack_buffer.buffer(), 0, stack_buffer.size());
   uintptr_t stack_top = 0;
   TestProfileBuilder profiler_builder;
-  TimeTicks timestamp;
   RegisterContext context{};
 
   TargetThread target_thread;
@@ -172,8 +142,8 @@ TEST(StackCopierSignalTest, MAYBE_CopyStackFromOtherThread) {
 
   StackCopierSignal copier(std::make_unique<ThreadDelegatePosix>(thread_token));
 
-  bool result = copier.CopyStack(&stack_buffer, &stack_top, &profiler_builder,
-                                 &timestamp, &context);
+  bool result =
+      copier.CopyStack(&stack_buffer, &stack_top, &profiler_builder, &context);
   ASSERT_TRUE(result);
 
   target_thread.NotifyCopyFinished();

base/profiler/stack_copier_suspend.cc

@@ -26,7 +26,6 @@ StackCopierSuspend::~StackCopierSuspend() = default;
 bool StackCopierSuspend::CopyStack(StackBuffer* stack_buffer,
                                    uintptr_t* stack_top,
                                    ProfileBuilder* profile_builder,
-                                   TimeTicks* timestamp,
                                    RegisterContext* thread_context) {
   const uintptr_t top = thread_delegate_->GetStackBaseAddress();
   uintptr_t bottom = 0;
@@ -43,10 +42,6 @@ bool StackCopierSuspend::CopyStack(StackBuffer* stack_buffer,
     std::unique_ptr<SuspendableThreadDelegate::ScopedSuspendThread>
         suspend_thread = thread_delegate_->CreateScopedSuspendThread();
 
-    // TimeTicks::Now() is implemented in terms of reads to the timer tick
-    // counter or TSC register on x86/x86_64 so is reentrant.
-    *timestamp = TimeTicks::Now();
-
     if (!suspend_thread->WasSuccessful())
       return false;
 

base/profiler/stack_copier_suspend.h

@@ -27,7 +27,6 @@ class BASE_EXPORT StackCopierSuspend : public StackCopier {
   bool CopyStack(StackBuffer* stack_buffer,
                  uintptr_t* stack_top,
                  ProfileBuilder* profile_builder,
-                 TimeTicks* timestamp,
                  RegisterContext* thread_context) override;
 
  private:

base/profiler/stack_copier_suspend_unittest.cc

@@ -98,8 +98,7 @@ class TestProfileBuilder : public ProfileBuilder {
     recorded_metadata_ = true;
   }
 
-  void OnSampleCompleted(std::vector<Frame> frames,
-                         TimeTicks sample_timestamp) override {}
+  void OnSampleCompleted(std::vector<Frame> frames) override {}
   void OnProfileCompleted(TimeDelta profile_duration,
                           TimeDelta sampling_period) override {}
 
@@ -118,11 +117,9 @@ TEST(StackCopierSuspendTest, CopyStack) {
       std::make_unique<StackBuffer>(stack.size() * sizeof(uintptr_t));
   uintptr_t stack_top = 0;
   TestProfileBuilder profile_builder;
-  TimeTicks timestamp;
   RegisterContext register_context{};
   stack_copier_suspend.CopyStack(stack_buffer.get(), &stack_top,
-                                 &profile_builder, &timestamp,
-                                 &register_context);
+                                 &profile_builder, &register_context);
 
   uintptr_t* stack_copy_bottom =
       reinterpret_cast<uintptr_t*>(stack_buffer.get()->buffer());
@@ -142,11 +139,9 @@ TEST(StackCopierSuspendTest, CopyStackBufferTooSmall) {
   stack_buffer->buffer()[0] = 100;
   uintptr_t stack_top = 0;
   TestProfileBuilder profile_builder;
-  TimeTicks timestamp;
   RegisterContext register_context{};
   stack_copier_suspend.CopyStack(stack_buffer.get(), &stack_top,
-                                 &profile_builder, &timestamp,
-                                 &register_context);
+                                 &profile_builder, &register_context);
 
   uintptr_t* stack_copy_bottom =
       reinterpret_cast<uintptr_t*>(stack_buffer.get()->buffer());
@@ -169,11 +164,9 @@ TEST(StackCopierSuspendTest, CopyStackAndRewritePointers) {
       std::make_unique<StackBuffer>(stack.size() * sizeof(uintptr_t));
   uintptr_t stack_top = 0;
   TestProfileBuilder profile_builder;
-  TimeTicks timestamp;
   RegisterContext register_context{};
   stack_copier_suspend.CopyStack(stack_buffer.get(), &stack_top,
-                                 &profile_builder, &timestamp,
-                                 &register_context);
+                                 &profile_builder, &register_context);
 
   uintptr_t* stack_copy_bottom =
       reinterpret_cast<uintptr_t*>(stack_buffer.get()->buffer());
@@ -185,28 +178,6 @@ TEST(StackCopierSuspendTest, CopyStackAndRewritePointers) {
                               sizeof(uintptr_t)));
 }
 
-TEST(StackCopierSuspendTest, CopyStackTimeStamp) {
-  const std::vector<uintptr_t> stack = {0};
-  StackCopierSuspend stack_copier_suspend(
-      std::make_unique<TestSuspendableThreadDelegate>(stack));
-
-  std::unique_ptr<StackBuffer> stack_buffer =
-      std::make_unique<StackBuffer>(stack.size() * sizeof(uintptr_t));
-  uintptr_t stack_top = 0;
-  TestProfileBuilder profile_builder;
-  TimeTicks timestamp;
-  RegisterContext register_context{};
-
-  TimeTicks before = TimeTicks::Now();
-  stack_copier_suspend.CopyStack(stack_buffer.get(), &stack_top,
-                                 &profile_builder, &timestamp,
-                                 &register_context);
-  TimeTicks after = TimeTicks::Now();
-
-  EXPECT_GE(timestamp, before);
-  EXPECT_LE(timestamp, after);
-}
-
 TEST(StackCopierSuspendTest, RewriteRegisters) {
   std::vector<uintptr_t> stack = {0, 1, 2};
   RegisterContext register_context{};
@@ -219,11 +190,9 @@ TEST(StackCopierSuspendTest, RewriteRegisters) {
   std::unique_ptr<StackBuffer> stack_buffer =
       std::make_unique<StackBuffer>(stack.size() * sizeof(uintptr_t));
   uintptr_t stack_top = 0;
-  TimeTicks timestamp;
   TestProfileBuilder profile_builder;
   stack_copier_suspend.CopyStack(stack_buffer.get(), &stack_top,
-                                 &profile_builder, &timestamp,
-                                 &register_context);
+                                 &profile_builder, &register_context);
 
   uintptr_t stack_copy_bottom =
       reinterpret_cast<uintptr_t>(stack_buffer.get()->buffer());

base/profiler/stack_sampler_impl.cc

@@ -45,9 +45,8 @@ void StackSamplerImpl::RecordStackFrames(StackBuffer* stack_buffer,
 
   RegisterContext thread_context;
   uintptr_t stack_top;
-  TimeTicks timestamp;
-  bool success = stack_copier_->CopyStack(
-      stack_buffer, &stack_top, profile_builder, &timestamp, &thread_context);
+  bool success = stack_copier_->CopyStack(stack_buffer, &stack_top,
+                                          profile_builder, &thread_context);
   if (!success)
     return;
 
@@ -56,8 +55,7 @@ void StackSamplerImpl::RecordStackFrames(StackBuffer* stack_buffer,
 
   profile_builder->OnSampleCompleted(
       WalkStack(module_cache_, &thread_context, stack_top,
-                native_unwinder_.get(), aux_unwinder_.get()),
-      timestamp);
+                native_unwinder_.get(), aux_unwinder_.get()));
 }
 // static
 

base/profiler/stack_sampler_impl_unittest.cc

@@ -37,34 +37,24 @@ class TestProfileBuilder : public ProfileBuilder {
   ModuleCache* GetModuleCache() override { return module_cache_; }
   void RecordMetadata(
       ProfileBuilder::MetadataProvider* metadata_provider) override {}
-
-  void OnSampleCompleted(std::vector<Frame> frames,
-                         TimeTicks sample_timestamp) override {
-    last_timestamp_ = sample_timestamp;
-  }
-
+  void OnSampleCompleted(std::vector<Frame> frames) override {}
   void OnProfileCompleted(TimeDelta profile_duration,
                           TimeDelta sampling_period) override {}
 
-  TimeTicks last_timestamp() { return last_timestamp_; }
-
  private:
   ModuleCache* module_cache_;
-  TimeTicks last_timestamp_;
 };
 
 // A stack copier for use in tests that provides the expected behavior when
 // operating on the supplied fake stack.
 class TestStackCopier : public StackCopier {
  public:
-  TestStackCopier(const std::vector<uintptr_t>& fake_stack,
-                  TimeTicks timestamp = TimeTicks())
-      : fake_stack_(fake_stack), timestamp_(timestamp) {}
+  TestStackCopier(const std::vector<uintptr_t>& fake_stack)
+      : fake_stack_(fake_stack) {}
 
   bool CopyStack(StackBuffer* stack_buffer,
                  uintptr_t* stack_top,
                  ProfileBuilder* profile_builder,
-                 TimeTicks* timestamp,
                  RegisterContext* thread_context) override {
     std::memcpy(stack_buffer->buffer(), &fake_stack_[0], fake_stack_.size());
     *stack_top =
@@ -73,8 +63,6 @@ class TestStackCopier : public StackCopier {
     RegisterContextStackPointer(thread_context) =
         reinterpret_cast<uintptr_t>(&fake_stack_[0]);
 
-    *timestamp = timestamp_;
-
     return true;
   }
 
@@ -82,8 +70,6 @@ class TestStackCopier : public StackCopier {
   // Must be a reference to retain the underlying allocation from the vector
   // passed to the constructor.
   const std::vector<uintptr_t>& fake_stack_;
-
-  const TimeTicks timestamp_;
 };
 
 // Trivial unwinder implementation for testing.
@@ -239,24 +225,6 @@ TEST(StackSamplerImplTest, MAYBE_CopyStack) {
   EXPECT_EQ(stack, stack_copy);
 }
 
-TEST(StackSamplerImplTest, CopyStackTimestamp) {
-  ModuleCache module_cache;
-  const std::vector<uintptr_t> stack = {0};
-  InjectModuleForContextInstructionPointer(stack, &module_cache);
-  std::vector<uintptr_t> stack_copy;
-  TimeTicks timestamp = TimeTicks::UnixEpoch();
-  StackSamplerImpl stack_sampler_impl(
-      std::make_unique<TestStackCopier>(stack, timestamp),
-      std::make_unique<TestUnwinder>(stack.size(), &stack_copy), &module_cache);
-
-  std::unique_ptr<StackBuffer> stack_buffer =
-      std::make_unique<StackBuffer>(stack.size() * sizeof(uintptr_t));
-  TestProfileBuilder profile_builder(&module_cache);
-  stack_sampler_impl.RecordStackFrames(stack_buffer.get(), &profile_builder);
-
-  EXPECT_EQ(timestamp, profile_builder.last_timestamp());
-}
-
 TEST(StackSamplerImplTest, WalkStack_Completed) {
   ModuleCache module_cache;
   RegisterContext thread_context;

base/profiler/stack_sampling_profiler_test_util.cc

@@ -37,8 +37,7 @@ class TestProfileBuilder : public ProfileBuilder {
   ModuleCache* GetModuleCache() override { return module_cache_; }
   void RecordMetadata(MetadataProvider* metadata_provider) override {}
 
-  void OnSampleCompleted(std::vector<Frame> sample,
-                         TimeTicks sample_timestamp) override {
+  void OnSampleCompleted(std::vector<Frame> sample) override {
     EXPECT_TRUE(sample_.empty());
     sample_ = std::move(sample);
   }

base/profiler/stack_sampling_profiler_unittest.cc

@@ -174,8 +174,7 @@ class TestProfileBuilder : public ProfileBuilder {
   ModuleCache* GetModuleCache() override;
   void RecordMetadata(
       ProfileBuilder::MetadataProvider* metadata_provider) override;
-  void OnSampleCompleted(std::vector<Frame> sample,
-                         TimeTicks sample_timestamp) override;
+  void OnSampleCompleted(std::vector<Frame> sample) override;
   void OnProfileCompleted(TimeDelta profile_duration,
                           TimeDelta sampling_period) override;
 
@@ -209,8 +208,7 @@ void TestProfileBuilder::RecordMetadata(
   ++metadata_count_;
 }
 
-void TestProfileBuilder::OnSampleCompleted(std::vector<Frame> sample,
-                                           TimeTicks sample_timestamp) {
+void TestProfileBuilder::OnSampleCompleted(std::vector<Frame> sample) {
   samples_.push_back(std::move(sample));
 }
 

chrome/common/heap_profiler_controller.cc

@@ -107,10 +107,7 @@ void HeapProfilerController::RetrieveAndSendSnapshot() {
         static_cast<size_t>(
             std::llround(static_cast<double>(sample.total) / sample.size)),
         1);
-    // Heap "samples" represent allocation stacks aggregated over time so do not
-    // have a meaningful timestamp.
-    profile_builder.OnSampleCompleted(std::move(frames), base::TimeTicks(),
-                                      sample.total, count);
+    profile_builder.OnSampleCompleted(std::move(frames), sample.total, count);
   }
 
   profile_builder.OnProfileCompleted(base::TimeDelta(), base::TimeDelta());

components/metrics/call_stack_profile_builder.cc

@@ -87,16 +87,13 @@ void CallStackProfileBuilder::RecordMetadata(
 }
 
 void CallStackProfileBuilder::OnSampleCompleted(
-    std::vector<base::Frame> frames,
-    base::TimeTicks sample_timestamp) {
-  OnSampleCompleted(std::move(frames), sample_timestamp, 1, 1);
+    std::vector<base::Frame> frames) {
+  OnSampleCompleted(std::move(frames), 1, 1);
 }
 
-void CallStackProfileBuilder::OnSampleCompleted(
-    std::vector<base::Frame> frames,
-    base::TimeTicks sample_timestamp,
-    size_t weight,
-    size_t count) {
+void CallStackProfileBuilder::OnSampleCompleted(std::vector<base::Frame> frames,
+                                                size_t weight,
+                                                size_t count) {
   // Write CallStackProfile::Stack protobuf message.
   CallStackProfile::Stack stack;
 

components/metrics/call_stack_profile_builder.h

@@ -66,7 +66,6 @@ class CallStackProfileBuilder : public base::ProfileBuilder {
 
   // Both weight and count are used by the heap profiler only.
   void OnSampleCompleted(std::vector<base::Frame> frames,
-                         base::TimeTicks sample_timestamp,
                          size_t weight,
                          size_t count);
 
@@ -74,8 +73,7 @@ class CallStackProfileBuilder : public base::ProfileBuilder {
   base::ModuleCache* GetModuleCache() override;
   void RecordMetadata(
       base::ProfileBuilder::MetadataProvider* metadata_provider) override;
-  void OnSampleCompleted(std::vector<base::Frame> frames,
-                         base::TimeTicks sample_timestamp) override;
+  void OnSampleCompleted(std::vector<base::Frame> frames) override;
   void OnProfileCompleted(base::TimeDelta profile_duration,
                           base::TimeDelta sampling_period) override;
 

components/metrics/call_stack_profile_builder_unittest.cc

@@ -118,10 +118,10 @@ TEST(CallStackProfileBuilderTest, ProfilingCompleted) {
 
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted(frames1, base::TimeTicks());
+  profile_builder->OnSampleCompleted(frames1);
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted(frames2, base::TimeTicks());
+  profile_builder->OnSampleCompleted(frames2);
   profile_builder->OnProfileCompleted(base::TimeDelta::FromMilliseconds(500),
                                       base::TimeDelta::FromMilliseconds(100));
 
@@ -183,9 +183,9 @@ TEST(CallStackProfileBuilderTest, CustomWeightsAndCounts) {
   base::Frame frame1 = {0x10, &module1};
   std::vector<base::Frame> frames = {frame1};
 
-  profile_builder->OnSampleCompleted(frames, base::TimeTicks(), 42, 3);
-  profile_builder->OnSampleCompleted(frames, base::TimeTicks(), 1, 1);
-  profile_builder->OnSampleCompleted(frames, base::TimeTicks());
+  profile_builder->OnSampleCompleted(frames, 42, 3);
+  profile_builder->OnSampleCompleted(frames, 1, 1);
+  profile_builder->OnSampleCompleted(frames);
   profile_builder->OnProfileCompleted(base::TimeDelta(), base::TimeDelta());
 
   const SampledProfile& proto = profile_builder->test_sampled_profile();
@@ -219,10 +219,10 @@ TEST(CallStackProfileBuilderTest, StacksDeduped) {
   // to one.
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted(frames, base::TimeTicks());
+  profile_builder->OnSampleCompleted(frames);
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted(frames, base::TimeTicks());
+  profile_builder->OnSampleCompleted(frames);
 
   profile_builder->OnProfileCompleted(base::TimeDelta(), base::TimeDelta());
 
@@ -259,10 +259,10 @@ TEST(CallStackProfileBuilderTest, StacksNotDeduped) {
   // Two stacks are completed with the different frames therefore not deduped.
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted(frames1, base::TimeTicks());
+  profile_builder->OnSampleCompleted(frames1);
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted(frames2, base::TimeTicks());
+  profile_builder->OnSampleCompleted(frames2);
 
   profile_builder->OnProfileCompleted(base::TimeDelta(), base::TimeDelta());
 
@@ -305,7 +305,7 @@ TEST(CallStackProfileBuilderTest, Modules) {
 
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted(frames, base::TimeTicks());
+  profile_builder->OnSampleCompleted(frames);
   profile_builder->OnProfileCompleted(base::TimeDelta(), base::TimeDelta());
 
   const SampledProfile& proto = profile_builder->test_sampled_profile();
@@ -356,7 +356,7 @@ TEST(CallStackProfileBuilderTest, DedupModules) {
 
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted(frames, base::TimeTicks());
+  profile_builder->OnSampleCompleted(frames);
   profile_builder->OnProfileCompleted(base::TimeDelta(), base::TimeDelta());
 
   const SampledProfile& proto = profile_builder->test_sampled_profile();
@@ -408,25 +408,25 @@ TEST(CallStackProfileBuilderTest, WorkIds) {
   // not have continued_work set.
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted({frame}, base::TimeTicks());
+  profile_builder->OnSampleCompleted({frame});
 
   // The second sample with the same id should have continued_work set.
   work_id_recorder.current_id = 1;
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted({frame}, base::TimeTicks());
+  profile_builder->OnSampleCompleted({frame});
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted({frame}, base::TimeTicks());
+  profile_builder->OnSampleCompleted({frame});
 
   // Ids are in general non-contiguous across multiple samples.
   work_id_recorder.current_id = 10;
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted({frame}, base::TimeTicks());
+  profile_builder->OnSampleCompleted({frame});
   profile_builder->RecordMetadata(
       base::MetadataRecorder().CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted({frame}, base::TimeTicks());
+  profile_builder->OnSampleCompleted({frame});
 
   profile_builder->OnProfileCompleted(base::TimeDelta::FromMilliseconds(500),
                                       base::TimeDelta::FromMilliseconds(100));
@@ -458,7 +458,7 @@ TEST(CallStackProfileBuilderTest, RecordMetadata) {
   metadata_recorder.Set(100, base::nullopt, 10);
   profile_builder->RecordMetadata(
       metadata_recorder.CreateMetadataProvider().get());
-  profile_builder->OnSampleCompleted({frame}, base::TimeTicks());
+  profile_builder->OnSampleCompleted({frame});
 
   profile_builder->OnProfileCompleted(base::TimeDelta::FromMilliseconds(500),
                                       base::TimeDelta::FromMilliseconds(100));

services/tracing/public/cpp/stack_sampling/stack_sampler_android.cc

@@ -44,7 +44,7 @@ void StackSamplerAndroid::RecordStackFrames(
     uintptr_t address = reinterpret_cast<uintptr_t>(pcs[i]);
     frames.emplace_back(address, module_cache_->GetModuleForAddress(address));
   }
-  profile_builder->OnSampleCompleted(std::move(frames), TRACE_TIME_TICKS_NOW());
+  profile_builder->OnSampleCompleted(std::move(frames));
 }
 
 }  // namespace tracing

services/tracing/public/cpp/stack_sampling/tracing_sampler_profiler.cc

@@ -210,13 +210,12 @@ TracingSamplerProfiler::TracingProfileBuilder::GetModuleCache() {
 }
 
 void TracingSamplerProfiler::TracingProfileBuilder::OnSampleCompleted(
-    std::vector<base::Frame> frames,
-    base::TimeTicks sample_timestamp) {
+    std::vector<base::Frame> frames) {
   base::AutoLock l(trace_writer_lock_);
   if (!trace_writer_) {
     if (buffered_samples_.size() < kMaxBufferedSamples) {
       buffered_samples_.emplace_back(
-          BufferedSample(sample_timestamp, std::move(frames)));
+          BufferedSample(TRACE_TIME_TICKS_NOW(), std::move(frames)));
     }
     return;
   }
@@ -226,7 +225,7 @@ void TracingSamplerProfiler::TracingProfileBuilder::OnSampleCompleted(
     }
     buffered_samples_.clear();
   }
-  WriteSampleToTrace(BufferedSample(sample_timestamp, std::move(frames)));
+  WriteSampleToTrace(BufferedSample(TRACE_TIME_TICKS_NOW(), std::move(frames)));
 }
 
 void TracingSamplerProfiler::TracingProfileBuilder::WriteSampleToTrace(

services/tracing/public/cpp/stack_sampling/tracing_sampler_profiler.h

@@ -47,8 +47,7 @@ class COMPONENT_EXPORT(TRACING_CPP) TracingSamplerProfiler {
 
     // base::ProfileBuilder
     base::ModuleCache* GetModuleCache() override;
-    void OnSampleCompleted(std::vector<base::Frame> frames,
-                           base::TimeTicks sample_timestamp) override;
+    void OnSampleCompleted(std::vector<base::Frame> frames) override;
     void OnProfileCompleted(base::TimeDelta profile_duration,
                             base::TimeDelta sampling_period) override {}
 

services/tracing/public/cpp/stack_sampling/tracing_sampler_profiler_unittest.cc

@@ -358,16 +358,14 @@ TEST(TracingProfileBuilderTest, ValidModule) {
   TracingSamplerProfiler::TracingProfileBuilder profile_builder(
       base::PlatformThreadId(),
       std::make_unique<MockTraceWriter>(base::DoNothing()), false);
-  profile_builder.OnSampleCompleted({base::Frame(0x1010, &module)},
-                                    base::TimeTicks());
+  profile_builder.OnSampleCompleted({base::Frame(0x1010, &module)});
 }
 
 TEST(TracingProfileBuilderTest, InvalidModule) {
   TracingSamplerProfiler::TracingProfileBuilder profile_builder(
       base::PlatformThreadId(),
       std::make_unique<MockTraceWriter>(base::DoNothing()), false);
-  profile_builder.OnSampleCompleted({base::Frame(0x1010, nullptr)},
-                                    base::TimeTicks());
+  profile_builder.OnSampleCompleted({base::Frame(0x1010, nullptr)});
 }
 
 #if defined(OS_ANDROID) || defined(OS_LINUX)
@@ -394,8 +392,7 @@ TEST(TracingProfileBuilderTest, MangleELFModuleID) {
   auto* raw_trace_writer = trace_writer.get();
   TracingSamplerProfiler::TracingProfileBuilder profile_builder(
       base::PlatformThreadId(), std::move(trace_writer), false);
-  profile_builder.OnSampleCompleted({base::Frame(0x1010, &module)},
-                                    base::TimeTicks());
+  profile_builder.OnSampleCompleted({base::Frame(0x1010, &module)});
   raw_trace_writer->FlushPacketIfPossible();
   EXPECT_TRUE(found_build_id);
 }