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

base/debug/activity_tracker.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_tracker.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
@@ skipping 20 matching lines @@
 
 namespace {
 
 // The minimum depth a stack should support.
 const int kMinStackDepth = 2;
 
 // The amount of memory set aside for holding arbitrary user data (key/value
 // pairs) globally or associated with ActivityData entries.
 const size_t kUserDataSize = 1 << 10;     // 1 KiB
 const size_t kProcessDataSize = 4 << 10;  // 4 KiB
-const size_t kGlobalDataSize = 16 << 10;  // 16 KiB
 const size_t kMaxUserDataNameLength =
     static_cast<size_t>(std::numeric_limits<uint8_t>::max());
 
 // A constant used to indicate that module information is changing.
 const uint32_t kModuleInformationChanging = 0x80000000;
 
 // The key used to record process information.
 const char kProcessPhaseDataKey[] = "process-phase";
 
 // An atomically incrementing number, used to check for recreations of objects
@@ skipping 1540 matching lines @@
 
   bool success = record->EncodeFrom(info, required_size);
   DCHECK(success);
   allocator_->MakeIterable(record);
   modules_.insert(std::make_pair(info.file, record));
 }
 
 void GlobalActivityTracker::RecordFieldTrial(const std::string& trial_name,
                                              StringPiece group_name) {
   const std::string key = std::string("FieldTrial.") + trial_name;
-  global_data_.SetString(key, group_name);
+  process_data_.SetString(key, group_name);
 }
 
 GlobalActivityTracker::GlobalActivityTracker(
     std::unique_ptr<PersistentMemoryAllocator> allocator,
     int stack_depth,
     int64_t process_id)
     : allocator_(std::move(allocator)),
       stack_memory_size_(ThreadActivityTracker::SizeForStackDepth(stack_depth)),
       process_id_(process_id == 0 ? GetCurrentProcId() : process_id),
       this_thread_tracker_(&OnTLSDestroy),
@@ skipping 11 matching lines @@
                            kCachedUserDataMemories,
                            /*make_iterable=*/true),
       process_data_(allocator_->GetAsArray<char>(
                         AllocateFrom(allocator_.get(),
                                      kTypeIdProcessDataRecordFree,
                                      kProcessDataSize,
                                      kTypeIdProcessDataRecord),
                         kTypeIdProcessDataRecord,
                         kProcessDataSize),
                     kProcessDataSize,
-                    process_id_),
-      global_data_(
-          allocator_->GetAsArray<char>(
-              allocator_->Allocate(kGlobalDataSize, kTypeIdGlobalDataRecord),
-              kTypeIdGlobalDataRecord,
-              kGlobalDataSize),
-          kGlobalDataSize,
-          process_id_) {
+                    process_id_) {
   DCHECK_NE(0, process_id_);
 
   // Ensure that there is no other global object and then make this one such.
   DCHECK(!g_tracker_);
   subtle::Release_Store(&g_tracker_, reinterpret_cast<uintptr_t>(this));
 
   // The data records must be iterable in order to be found by an analyzer.
   allocator_->MakeIterable(allocator_->GetAsReference(
       process_data_.GetBaseAddress(), kTypeIdProcessDataRecord));
-  allocator_->MakeIterable(allocator_->GetAsReference(
-      global_data_.GetBaseAddress(), kTypeIdGlobalDataRecord));
 
   // Note that this process has launched.
   SetProcessPhase(PROCESS_LAUNCHED);
 
   // Fetch and record all activated field trials.
   FieldTrial::ActiveGroups active_groups;
   FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
   for (auto& group : active_groups)
     RecordFieldTrial(group.trial_name, group.group_name);
 }
@@ skipping 120 matching lines @@
     : GlobalActivityTracker::ScopedThreadActivity(
           program_counter,
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base