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 698 matching lines @@
   // 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_;
+  Lock lock_;
   bool thread_running_;
   scoped_ptr<CancellationFlag> cancellation_flag_;
   scoped_ptr<WaitableEvent> waitable_event_for_testing_;
 };
 
 
 TraceSamplingThread::TraceSamplingThread()
     : thread_running_(false) {
+  AutoLock lock(lock_);
   cancellation_flag_.reset(new CancellationFlag);
 }
 
 TraceSamplingThread::~TraceSamplingThread() {
 }
 
 void TraceSamplingThread::ThreadMain() {
   PlatformThread::SetName("Sampling Thread");
   thread_running_ = true;
   const int kSamplingFrequencyMicroseconds = 1000;
-  while (!cancellation_flag_->IsSet()) {
+  while (true) {
     PlatformThread::Sleep(
         TimeDelta::FromMicroseconds(kSamplingFrequencyMicroseconds));
     GetSamples();
+
+    AutoLock lock(lock_);
+    if (cancellation_flag_->IsSet())
+        break;

[Alexander Potapenko, 2013/10/09 06:55:32]

Nit: please fix the indentation

[haraken, 2013/10/09 07:05:07]

Done.

     if (waitable_event_for_testing_.get())
       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);
@@ skipping 26 matching lines @@
 
 // static
 void TraceSamplingThread::ExtractCategoryAndName(const char* combined,
                                                  const char** category,
                                                  const char** name) {
   *category = combined;
   *name = &combined[strlen(combined) + 1];
 }
 
 void TraceSamplingThread::Stop() {
+  AutoLock lock(lock_);
   cancellation_flag_->Set();
 }
 
 void TraceSamplingThread::InstallWaitableEventForSamplingTesting(
     WaitableEvent* waitable_event) {
+  AutoLock lock(lock_);
   waitable_event_for_testing_.reset(waitable_event);
 }
 
 TraceBucketData::TraceBucketData(base::subtle::AtomicWord* bucket,
                                  const char* name,
                                  TraceSampleCallback callback)
     : bucket(bucket),
       bucket_name(name),
       callback(callback) {
 }
@@ skipping 1268 matching lines @@
         0,                       // num_args
         NULL,                    // arg_names
         NULL,                    // arg_types
         NULL,                    // arg_values
         NULL,                    // convertable values
         TRACE_EVENT_FLAG_NONE);  // flags
   }
 }
 
 }  // namespace trace_event_internal