Fixit: Fork base::TimeTicks --> TimeTicks + ThreadTicks + TraceTicks

content/renderer/devtools/v8_sampling_profiler.cc

 // Copyright 2014 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 "content/renderer/devtools/v8_sampling_profiler.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #define USE_SIGNALS
 #endif
@@ skipping 79 matching lines @@
       "0x%" PRIx64, static_cast<uint64>(reinterpret_cast<intptr_t>(value)));
 }
 
 class SampleRecord {
  public:
   static const int kMaxFramesCountLog2 = 8;
   static const unsigned kMaxFramesCount = (1u << kMaxFramesCountLog2) - 1;
 
   SampleRecord() {}
 
-  base::TimeTicks timestamp() const { return timestamp_; }
+  base::TraceTicks timestamp() const { return timestamp_; }
   void Collect(v8::Isolate* isolate,
-               base::TimeTicks timestamp,
+               base::TraceTicks timestamp,
                const v8::RegisterState& state);
   scoped_refptr<ConvertableToTraceFormat> ToTraceFormat() const;
 
  private:
-  base::TimeTicks timestamp_;
+  base::TraceTicks timestamp_;
   unsigned vm_state_ : 4;
   unsigned frames_count_ : kMaxFramesCountLog2;
   const void* frames_[kMaxFramesCount];
 
   DISALLOW_COPY_AND_ASSIGN(SampleRecord);
 };
 
 void SampleRecord::Collect(v8::Isolate* isolate,
-                           base::TimeTicks timestamp,
+                           base::TraceTicks timestamp,
                            const v8::RegisterState& state) {
   v8::SampleInfo sample_info;
   isolate->GetStackSample(state, (void**)frames_, kMaxFramesCount,
                           &sample_info);
   timestamp_ = timestamp;
   frames_count_ = sample_info.frames_count;
   vm_state_ = sample_info.vm_state;
 }
 
 scoped_refptr<ConvertableToTraceFormat> SampleRecord::ToTraceFormat() const {
@@ skipping 150 matching lines @@
     LOG(ERROR) << "pthread_kill failed with error " << error << " "
                << strerror(error);
   }
 #endif
   InjectPendingEvents();
 }
 
 void Sampler::DoSample(const v8::RegisterState& state) {
   // Called in the sampled thread signal handler.
   // Because of that it is not allowed to do any memory allocation here.
-  base::TimeTicks timestamp = base::TimeTicks::NowFromSystemTraceTime();
+  base::TraceTicks timestamp = base::TraceTicks::Now();
   SampleRecord* record = samples_data_->StartEnqueue();
   if (!record)
     return;
   record->Collect(isolate_, timestamp, state);
   samples_data_->FinishEnqueue();
 }
 
 void Sampler::InjectPendingEvents() {
   SampleRecord* record = samples_data_->Peek();
   while (record) {
     TRACE_EVENT_SAMPLE_WITH_TID_AND_TIMESTAMP1(
         TRACE_DISABLED_BY_DEFAULT("v8.cpu_profile"), "V8Sample",
         platform_data_.thread_id(),
-        (record->timestamp() - base::TimeTicks()).InMicroseconds(), "data",
+        (record->timestamp() - base::TraceTicks()).InMicroseconds(), "data",
         record->ToTraceFormat());
     samples_data_->Remove();
     record = samples_data_->Peek();
     base::subtle::NoBarrier_AtomicIncrement(&samples_count_, 1);
   }
 }
 
 // static
 void Sampler::InstallJitCodeEventHandler(Isolate* isolate, void* data) {
   // Called on the sampled V8 thread.
@@ skipping 308 matching lines @@
   render_thread_sampler_->SetEventsToCollectForTest(code_added_events,
                                                     sample_events);
   waitable_event_for_testing_.reset(new base::WaitableEvent(false, false));
 }
 
 void V8SamplingProfiler::WaitSamplingEventForTesting() {
   waitable_event_for_testing_->Wait();
 }
 
 }  // namespace blink