Remove 'global' user-data in favor of 'process' user-data.

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.
 
@@ skipping 746 matching lines @@
   // identified during extraction; the first 4 bytes of the SHA1 of the name
   // is used as a unique integer. A "version number" is added to the base
   // so that, if the structure of that object changes, stored older versions
   // will be safely ignored. These are public so that an external process
   // can recognize records of this type within an allocator.
   enum : uint32_t {
     kTypeIdActivityTracker = 0x5D7381AF + 4,   // SHA1(ActivityTracker) v4
     kTypeIdUserDataRecord = 0x615EDDD7 + 3,    // SHA1(UserDataRecord) v3
     kTypeIdGlobalLogMessage = 0x4CF434F9 + 1,  // SHA1(GlobalLogMessage) v1
     kTypeIdProcessDataRecord = kTypeIdUserDataRecord + 0x100,
-    kTypeIdGlobalDataRecord = kTypeIdUserDataRecord + 0x200,
 
     kTypeIdActivityTrackerFree = ~kTypeIdActivityTracker,
     kTypeIdUserDataRecordFree = ~kTypeIdUserDataRecord,
     kTypeIdProcessDataRecordFree = ~kTypeIdProcessDataRecord,
   };
 
   // An enumeration of common process life stages. All entries are given an
   // explicit number so they are known and remain constant; this allows for
   // cross-version analysis either locally or on a server.
   enum ProcessPhase : int {
@@ skipping 41 matching lines @@
     // many times a module may be loaded and unloaded.
     size_t size = 0;         // The size of the loaded module.
     uint32_t timestamp = 0;  // Opaque "timestamp" for the module.
     uint32_t age = 0;        // Opaque "age" for the module.
     uint8_t identifier[16];  // Opaque identifier (GUID, etc.) for the module.
     std::string file;        // The full path to the file. (UTF-8)
     std::string debug_file;  // The full path to the debug file.
   };
 
   // This is a thin wrapper around the thread-tracker's ScopedActivity that
-  // accesses the global tracker to provide some of the information, notably
-  // which thread-tracker to use. It is safe to create even if activity
-  // tracking is not enabled.
+  // allows thread-safe access to data values. It is safe to use even if
+  // activity tracking is not enabled.
   class BASE_EXPORT ScopedThreadActivity
       : public ThreadActivityTracker::ScopedActivity {
    public:
     ScopedThreadActivity(const void* program_counter,
                          const void* origin,
                          Activity::Type type,
                          const ActivityData& data,
                          bool lock_allowed);
     ~ScopedThreadActivity();
 
@@ skipping 183 matching lines @@
   }
 
   // Gets the process ID used for tracking. This is typically the same as what
   // the OS thinks is the current process but can be overridden for testing.
   int64_t process_id() { return process_id_; };
 
   // Accesses the process data record for storing arbitrary key/value pairs.
   // Updates to this are thread-safe.
   ActivityUserData& process_data() { return process_data_; }
 
-  // Accesses the global data record for storing arbitrary key/value pairs.
-  // Updates to this are thread-safe.
-  ActivityUserData& global_data() { return global_data_; }
-
  private:
   friend class GlobalActivityAnalyzer;
   friend class ScopedThreadActivity;
   friend class ActivityTrackerTest;
 
   enum : int {
     // The maximum number of threads that can be tracked within a process. If
     // more than this number run concurrently, tracking of new ones may cease.
     kMaxThreadCount = 100,
     kCachedThreadMemories = 10,
@@ skipping 134 matching lines @@
   // A caching memory allocator for thread-tracker objects.
   ActivityTrackerMemoryAllocator thread_tracker_allocator_;
   base::Lock thread_tracker_allocator_lock_;
 
   // A caching memory allocator for user data attached to activity data.
   ActivityTrackerMemoryAllocator user_data_allocator_;
   base::Lock user_data_allocator_lock_;
 
   // An object for holding arbitrary key value pairs with thread-safe access.
   ThreadSafeUserData process_data_;
-  ThreadSafeUserData global_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 subtle::AtomicWord g_tracker_;
 
   // A lock that is used to protect access to the following fields.
   base::Lock global_tracker_lock_;
@@ skipping 137 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_