Avoid threading races on TraceSamplingThread's members

base/debug/trace_event_impl.cc

 // Copyright (c) 2012 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 "base/debug/trace_event_impl.h"
 
 #include <algorithm>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 822 matching lines @@
  public:
   TraceSamplingThread();
   virtual ~TraceSamplingThread();
 
   // Implementation of PlatformThread::Delegate:
   virtual void ThreadMain() OVERRIDE;
 
   static void DefaultSamplingCallback(TraceBucketData* bucekt_data);
 
   void Stop();
-  void InstallWaitableEventForSamplingTesting(WaitableEvent* waitable_event);
+  void WaitSamplingEventForTesting();
 
  private:
   friend class TraceLog;
 
   void GetSamples();
   // Not thread-safe. Once the ThreadMain has been called, this can no longer
   // be called.
   void RegisterSampleBucket(TRACE_EVENT_API_ATOMIC_WORD* bucket,
                             const char* const name,
                             TraceSampleCallback callback);
   // Splits a combined "category\0name" into the two component parts.
   static void ExtractCategoryAndName(const char* combined,
                                      const char** category,
                                      const char** name);
   std::vector<TraceBucketData> sample_buckets_;
   bool thread_running_;
-  scoped_ptr<CancellationFlag> cancellation_flag_;
-  scoped_ptr<WaitableEvent> waitable_event_for_testing_;
+  CancellationFlag cancellation_flag_;
+  WaitableEvent waitable_event_for_testing_;
 };
 
 
 TraceSamplingThread::TraceSamplingThread()
-    : thread_running_(false) {
-  cancellation_flag_.reset(new CancellationFlag);
+    : thread_running_(false),
+      waitable_event_for_testing_(false, false) {
 }
 
 TraceSamplingThread::~TraceSamplingThread() {
 }
 
 void TraceSamplingThread::ThreadMain() {
   PlatformThread::SetName("Sampling Thread");
   thread_running_ = true;
   const int kSamplingFrequencyMicroseconds = 1000;
-  while (!cancellation_flag_->IsSet()) {
+  while (!cancellation_flag_.IsSet()) {
     PlatformThread::Sleep(
         TimeDelta::FromMicroseconds(kSamplingFrequencyMicroseconds));
     GetSamples();
-    if (waitable_event_for_testing_.get())
-      waitable_event_for_testing_->Signal();
+    waitable_event_for_testing_.Signal();
   }
 }
 
 // static
 void TraceSamplingThread::DefaultSamplingCallback(
     TraceBucketData* bucket_data) {
   TRACE_EVENT_API_ATOMIC_WORD category_and_name =
       TRACE_EVENT_API_ATOMIC_LOAD(*bucket_data->bucket);
   if (!category_and_name)
     return;
@@ skipping 11 matching lines @@
   for (size_t i = 0; i < sample_buckets_.size(); ++i) {
     TraceBucketData* bucket_data = &sample_buckets_[i];
     bucket_data->callback.Run(bucket_data);
   }
 }
 
 void TraceSamplingThread::RegisterSampleBucket(
     TRACE_EVENT_API_ATOMIC_WORD* bucket,
     const char* const name,
     TraceSampleCallback callback) {
+  // Access to sample_buckets_ doesn't cause races with the sampling thread
+  // that uses the sample_buckets_, because it is guaranteed that
+  // RegisterSampleBucket is called before the sampling thread is created.
   DCHECK(!thread_running_);
   sample_buckets_.push_back(TraceBucketData(bucket, name, callback));
 }
 
 // static
 void TraceSamplingThread::ExtractCategoryAndName(const char* combined,
                                                  const char** category,
                                                  const char** name) {
   *category = combined;
   *name = &combined[strlen(combined) + 1];
 }
 
 void TraceSamplingThread::Stop() {
-  cancellation_flag_->Set();
+  cancellation_flag_.Set();
 }
 
-void TraceSamplingThread::InstallWaitableEventForSamplingTesting(
-    WaitableEvent* waitable_event) {
-  waitable_event_for_testing_.reset(waitable_event);
+void TraceSamplingThread::WaitSamplingEventForTesting() {
+  waitable_event_for_testing_.Wait();
 }
 
 TraceBucketData::TraceBucketData(base::subtle::AtomicWord* bucket,
                                  const char* name,
                                  TraceSampleCallback callback)
     : bucket(bucket),
       bucket_name(name),
       callback(callback) {
 }
 
@@ skipping 1052 matching lines @@
       it++) {
     if (it->second.empty())
       continue;
     InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, NULL),
                             it->first,
                             "thread_name", "name",
                             it->second);
   }
 }
 
-void TraceLog::InstallWaitableEventForSamplingTesting(
-    WaitableEvent* waitable_event) {
+void TraceLog::WaitSamplingEventForTesting() {
   if (!sampling_thread_)
     return;
-  sampling_thread_->InstallWaitableEventForSamplingTesting(waitable_event);
+  sampling_thread_->WaitSamplingEventForTesting();
 }
 
 void TraceLog::DeleteForTesting() {
   DeleteTraceLogForTesting::Delete();
 }
 
 TraceEvent* TraceLog::GetEventByHandle(TraceEventHandle handle) {
   return GetEventByHandleInternal(handle, NULL);
 }
 
@@ skipping 261 matching lines @@
             0, NULL, NULL, NULL, NULL, TRACE_EVENT_FLAG_NONE);
   }
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_)
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(event_handle_);
 }
 
 }  // namespace trace_event_internal