Fix some issues with atomics in the activity tracker.

base/debug/activity_tracker.h

 // 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.
 
 // Activity tracking provides a low-overhead method of collecting information
 // about the state of the application for analysis both while it is running
 // and after it has terminated unexpectedly. Its primary purpose is to help
 // locate reasons the browser becomes unresponsive by providing insight into
 // what all the various threads and processes are (or were) doing.
 
 #ifndef BASE_DEBUG_ACTIVITY_TRACKER_H_
 #define BASE_DEBUG_ACTIVITY_TRACKER_H_
 
 // std::atomic is undesired due to performance issues when used as global
 // variables. There are no such instances here. This module uses the
 // PersistentMemoryAllocator which also uses std::atomic and is written
 // by the same author.
 #include <atomic>
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/location.h"
 #include "base/metrics/persistent_memory_allocator.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 
 struct PendingTask;
 
 class FilePath;
 class Lock;
 class PlatformThreadHandle;
 class Process;
+class StaticAtomicSequenceNumber;
 class WaitableEvent;
 
 namespace debug {
 
 class ThreadActivityTracker;
 
 
 enum : int {
   // The maximum number of call-stack addresses stored per activity. This
   // cannot be changed without also changing the version number of the
@@ skipping 404 matching lines @@
   mutable char* memory_;
   mutable size_t available_;
 
   // A pointer to the unique ID for this instance.
   std::atomic<uint32_t>* const id_;
 
   base::ThreadChecker thread_checker_;
 
   // This ID is used to create unique indentifiers for user data so that it's
   // possible to tell if the information has been overwritten.
-  static std::atomic<uint32_t> next_id_;
+  static StaticAtomicSequenceNumber next_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ActivityUserData);
 };
 
 // This class manages tracking a stack of activities for a single thread in
 // a persistent manner, implementing a bounded-size stack in a fixed-size
 // memory allocation. In order to support an operational mode where another
 // thread is analyzing this data in real-time, atomic operations are used
 // where necessary to guarantee a consistent view from the outside.
 //
@@ skipping 256 matching lines @@
 #endif  // !defined(OS_NACL)
 
   // Like above but internally creates an allocator using local heap memory of
   // the specified size. This is used primarily for unit tests.
   static void CreateWithLocalMemory(size_t size,
                                     uint64_t id,
                                     StringPiece name,
                                     int stack_depth);
 
   // Gets the global activity-tracker or null if none exists.
-  static GlobalActivityTracker* Get() { return g_tracker_; }
+  static GlobalActivityTracker* Get() {
+    return reinterpret_cast<GlobalActivityTracker*>(
+        subtle::NoBarrier_Load(&g_tracker_));
+  }
 
   // Gets the persistent-memory-allocator in which data is stored. Callers
   // can store additional records here to pass more information to the
   // analysis process.
   PersistentMemoryAllocator* allocator() { return allocator_.get(); }
 
   // Gets the thread's activity-tracker if it exists. This is inline for
   // performance reasons and it uses thread-local-storage (TLS) so that there
   // is no significant lookup time required to find the one for the calling
   // thread. Ownership remains with the global tracker.
@@ skipping 145 matching lines @@
 
   // An object for holding global arbitrary key value pairs. Values must always
   // be written from the main UI thread.
   ActivityUserData user_data_;
 
   // A map of global module information, keyed by module path.
   std::map<const std::string, ModuleInfoRecord*> modules_;
   base::Lock modules_lock_;
 
   // The active global activity tracker.
-  static GlobalActivityTracker* g_tracker_;
+  static subtle::AtomicWord g_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(GlobalActivityTracker);
 };
 
 
 // Record entry in to and out of an arbitrary block of code.
 class BASE_EXPORT ScopedActivity
     : public GlobalActivityTracker::ScopedThreadActivity {
  public:
   // Track activity at the specified FROM_HERE location for an arbitrary
@@ skipping 115 matching lines @@
   ScopedProcessWaitActivity(const void* program_counter,
                             const base::Process* process);
   DISALLOW_COPY_AND_ASSIGN(ScopedProcessWaitActivity);
 };
 #endif
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_ACTIVITY_TRACKER_H_