Fix some TSAN problems in Activity Tracker/Analyzer.

base/debug/activity_analyzer_unittest.cc

 // Copyright 2016 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/activity_analyzer.h"
 
+#include <atomic>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/debug/activity_tracker.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/pending_task.h"
@@ skipping 66 matching lines @@
 class SimpleActivityThread : public SimpleThread {
  public:
   SimpleActivityThread(const std::string& name,
                        const void* source,
                        Activity::Type activity,
                        const ActivityData& data)
       : SimpleThread(name, Options()),
         source_(source),
         activity_(activity),
         data_(data),
+        ready_(false),
+        exit_(false),
         exit_condition_(&lock_) {}
 
   ~SimpleActivityThread() override {}
 
   void Run() override {
     GlobalActivityTracker::Get()
         ->GetOrCreateTrackerForCurrentThread()
         ->PushActivity(source_, activity_, data_);
 
     {
       AutoLock auto_lock(lock_);
-      ready_ = true;
-      while (!exit_)
+      ready_.store(true, std::memory_order_relaxed);
+      while (!exit_.load(std::memory_order_relaxed))
         exit_condition_.Wait();
     }
 
     GlobalActivityTracker::Get()
         ->GetOrCreateTrackerForCurrentThread()
         ->PopActivity();
   }
 
   void Exit() {
     AutoLock auto_lock(lock_);
-    exit_ = true;
+    exit_.store(true, std::memory_order_relaxed);
     exit_condition_.Signal();
   }
 
   void WaitReady() {
-    SPIN_FOR_1_SECOND_OR_UNTIL_TRUE(ready_);
+    SPIN_FOR_1_SECOND_OR_UNTIL_TRUE(ready_.load(std::memory_order_relaxed));

[Alexander Potapenko, 2016/10/14 10:07:33]

You're waiting for another thread here, but do not create an actual
happens-before arc.
Accesses to ready_ should be acquire/release instead of relaxed.

   }
 
  private:
   const void* source_;
   Activity::Type activity_;
   ActivityData data_;
 
-  bool ready_ = false;
-  bool exit_ = false;
+  std::atomic<bool> ready_;
+  std::atomic<bool> exit_;
   Lock lock_;
   ConditionVariable exit_condition_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleActivityThread);
 };
 
 TEST_F(ActivityAnalyzerTest, GlobalAnalyzerConstruction) {
   GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3);
 
   PersistentMemoryAllocator* allocator =
@@ skipping 29 matching lines @@
   ThreadActivityAnalyzer* ta2 = analyzer.GetFirstAnalyzer();
   ASSERT_TRUE(ta2);
   EXPECT_FALSE(analyzer.GetNextAnalyzer());
   ThreadActivityAnalyzer::ThreadKey tk2 = ta2->GetThreadKey();
   EXPECT_EQ(ta2, analyzer.GetAnalyzerForThread(tk2));
   EXPECT_EQ(tk1, tk2);
 }
 
 }  // namespace debug
 }  // namespace base