Unflake V8 sampling profiler tests.

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 99 matching lines @@
   static scoped_ptr<Sampler> CreateForCurrentThread();
   static Sampler* GetInstance() { return tls_instance_.Pointer()->Get(); }
 
   // These methods are called from the sampling thread.
   void Start();
   void Stop();
   void Sample();
 
   void DoSample(const v8::RegisterState& state);
 
+  void SetEventsToCollectForTest(int code_added_events, int sample_events) {
+    code_added_events_to_collect_for_test_ = code_added_events;
+    sample_events_to_collect_for_test_ = sample_events;
+  }
+
   bool EventsCollectedForTest() const {
-    return base::subtle::NoBarrier_Load(&code_added_events_count_) != 0 ||
-           base::subtle::NoBarrier_Load(&samples_count_) != 0;
+    return base::subtle::NoBarrier_Load(&code_added_events_count_) >=
+               code_added_events_to_collect_for_test_ &&
+           base::subtle::NoBarrier_Load(&samples_count_) >=
+               sample_events_to_collect_for_test_;
   }
 
  private:
   Sampler();
 
   static void InstallJitCodeEventHandler(Isolate* isolate, void* data);
   static void HandleJitCodeEvent(const v8::JitCodeEvent* event);
   static scoped_refptr<ConvertableToTraceFormat> JitCodeEventToTraceFormat(
       const v8::JitCodeEvent* event);
   static base::PlatformThreadHandle GetCurrentThreadHandle();
 
   void InjectPendingEvents();
 
   static const unsigned kNumberOfSamples = 10;
   typedef LockFreeCircularQueue<SampleRecord, kNumberOfSamples> SamplingQueue;
 
   base::PlatformThreadId thread_id_;
   base::PlatformThreadHandle thread_handle_;
   Isolate* isolate_;
   scoped_ptr<SamplingQueue> samples_data_;
   base::subtle::Atomic32 code_added_events_count_;
   base::subtle::Atomic32 samples_count_;
+  int code_added_events_to_collect_for_test_;
+  int sample_events_to_collect_for_test_;
 
   static base::LazyInstance<base::ThreadLocalPointer<Sampler>>::Leaky
       tls_instance_;
 };
 
 base::LazyInstance<base::ThreadLocalPointer<Sampler>>::Leaky
     Sampler::tls_instance_ = LAZY_INSTANCE_INITIALIZER;
 
 Sampler::Sampler()
     : thread_id_(base::PlatformThread::CurrentId()),
       thread_handle_(Sampler::GetCurrentThreadHandle()),
       isolate_(Isolate::GetCurrent()),
       code_added_events_count_(0),
-      samples_count_(0) {
+      samples_count_(0),
+      code_added_events_to_collect_for_test_(0),
+      sample_events_to_collect_for_test_(0) {
   DCHECK(isolate_);
   DCHECK(!GetInstance());
   tls_instance_.Pointer()->Set(this);
 }
 
 Sampler::~Sampler() {
   DCHECK(GetInstance());
   tls_instance_.Pointer()->Set(nullptr);
 }
 
@@ skipping 37 matching lines @@
 
 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();
   SampleRecord* record = samples_data_->StartEnqueue();
   if (!record)
     return;
   record->Collect(isolate_, timestamp, state);
   samples_data_->FinishEnqueue();
-  base::subtle::NoBarrier_AtomicIncrement(&samples_count_, 1);
 }
 
 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", thread_id_,
         (record->timestamp() - base::TimeTicks()).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.
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.cpu_profile"),
                "Sampler::InstallJitCodeEventHandler");
   v8::JitCodeEventHandler handler =
       reinterpret_cast<v8::JitCodeEventHandler>(data);
@@ skipping 303 matching lines @@
                             base::Unretained(this)));
 }
 
 void V8SamplingProfiler::OnTraceLogDisabled() {
   if (!sampling_thread_.get())
     return;
   sampling_thread_->Stop();
   sampling_thread_.reset();
 }
 
-void V8SamplingProfiler::EnableSamplingEventForTesting() {
+void V8SamplingProfiler::EnableSamplingEventForTesting(int code_added_events,
+                                                       int sample_events) {
+  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