Refactor embedded structures to top-level scope.

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 "base/debug/stack_trace.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 15 matching lines @@
 
 // A number that identifies the memory as having been initialized. It's
 // arbitrary but happens to be the first 8 bytes of SHA1(ThreadActivityTracker).
 // A version number is added on so that major structure changes won't try to
 // read an older version (since the cookie won't match).
 const uint64_t kHeaderCookie = 0xC0029B240D4A3092ULL + 1;  // v1
 
 // The minimum depth a stack should support.
 const int kMinStackDepth = 2;
 
+union ThreadRef {
+  int64_t as_id;
+#if defined(OS_WIN)
+  // On Windows, the handle itself is often a pseudo-handle with a common
+  // value meaning "this thread" and so the thread-id is used. The former
+  // can be converted to a thread-id with a system call.
+  PlatformThreadId as_tid;
+#elif defined(OS_POSIX)
+  // On Posix, the handle is always a unique identifier so no conversion
+  // needs to be done. However, it's value is officially opaque so there
+  // is no one correct way to convert it to a numerical identifier.
+  PlatformThreadHandle::Handle as_handle;
+#endif
+};
+
 }  // namespace
 
 
+// It doesn't matter what is contained in this (though it will be all zeros)
+// as only the address of it is important.
+const ActivityData kNullActivityData = {};
+
+ActivityData ActivityData::ForThread(const PlatformThreadHandle& handle) {
+  ThreadRef thread_ref;
+  thread_ref.as_id = 0;  // Zero the union in case other is smaller.
+#if defined(OS_WIN)
+  thread_ref.as_tid = ::GetThreadId(handle.platform_handle());
+#elif defined(OS_POSIX)
+  thread_ref.as_handle = handle.platform_handle();
+#endif
+  return ForThread(thread_ref.as_id);
+}
+
+// static
+void Activity::FillFrom(Activity* activity,
+                        const void* origin,
+                        Type type,
+                        const ActivityData& data) {
+  activity->time_internal = base::TimeTicks::Now().ToInternalValue();
+  activity->origin_address = reinterpret_cast<uintptr_t>(origin);
+  activity->activity_type = type;
+  activity->data = data;
+
+#if defined(SYZYASAN)
+  // Create a stacktrace from the current location and get the addresses.
+  StackTrace stack_trace;
+  size_t stack_depth;
+  const void* const* stack_addrs = stack_trace.Addresses(&stack_depth);
+  // Copy the stack addresses, ignoring the first one (here).
+  size_t i;
+  for (i = 1; i < stack_depth && i < kActivityCallStackSize; ++i) {
+    activity->call_stack[i - 1] = reinterpret_cast<uintptr_t>(stack_addrs[i]);
+  }
+  activity->call_stack[i - 1] = 0;
+#else
+  activity->call_stack[0] = 0;
+#endif
+}
+
+ActivitySnapshot::ActivitySnapshot() {}
+ActivitySnapshot::~ActivitySnapshot() {}
+
+
 // This information is kept for every thread that is tracked. It is filled
 // the very first time the thread is seen. All fields must be of exact sizes
 // so there is no issue moving between 32 and 64-bit builds.
 struct ThreadActivityTracker::Header {
   // This unique number indicates a valid initialization of the memory.
   uint64_t cookie;
 
-  // The process-id and thread-id to which this data belongs. These identifiers
-  // are not guaranteed to mean anything but are unique, in combination, among
-  // all active trackers. It would be nice to always have the process_id be a
-  // 64-bit value but the necessity of having it atomic (for the memory barriers
-  // it provides) limits it to the natural word size of the machine.
+  // The process-id and thread-id (thread_ref.as_id) to which this data belongs.
+  // These identifiers are not guaranteed to mean anything but are unique, in
+  // combination, among all active trackers. It would be nice to always have
+  // the process_id be a 64-bit value but the necessity of having it atomic
+  // (for the memory barriers it provides) limits it to the natural word size
+  // of the machine.
 #ifdef ARCH_CPU_64_BITS
   std::atomic<int64_t> process_id;
 #else
   std::atomic<int32_t> process_id;
   int32_t process_id_padding;
 #endif
-
-  union {
-    int64_t as_id;
-#if defined(OS_WIN)
-    // On Windows, the handle itself is often a pseudo-handle with a common
-    // value meaning "this thread" and so the thread-id is used. The former
-    // can be converted to a thread-id with a system call.
-    PlatformThreadId as_tid;
-#elif defined(OS_POSIX)
-    // On Posix, the handle is always a unique identifier so no conversion
-    // needs to be done. However, it's value is officially opaque so there
-    // is no one correct way to convert it to a numerical identifier.
-    PlatformThreadHandle::Handle as_handle;
-#endif
-  } thread_ref;
+  ThreadRef thread_ref;
 
   // The start-time and start-ticks when the data was created. Each activity
   // record has a |time_internal| value that can be converted to a "wall time"
   // with these two values.
   int64_t start_time;
   int64_t start_ticks;
 
   // The number of Activity slots in the data.
   uint32_t stack_slots;
 
@@ skipping 12 matching lines @@
   // is not the current implementation so no parallel snapshots allowed).
   std::atomic<uint32_t> stack_unchanged;
 
   // The name of the thread (up to a maximum length). Dynamic-length names
   // are not practical since the memory has to come from the same persistent
   // allocator that holds this structure and to which this object has no
   // reference.
   char thread_name[32];
 };
 
-// It doesn't matter what is contained in this (though it will be all zeros)
-// as only the address of it is important.
-const ThreadActivityTracker::ActivityData
-    ThreadActivityTracker::kNullActivityData = {};
-
-ThreadActivityTracker::ActivityData
-ThreadActivityTracker::ActivityData::ForThread(
-    const PlatformThreadHandle& handle) {
-  // Header already has a conversion union; reuse that.
-  ThreadActivityTracker::Header header;
-  header.thread_ref.as_id = 0;  // Zero the union in case other is smaller.
-#if defined(OS_WIN)
-  header.thread_ref.as_tid = ::GetThreadId(handle.platform_handle());
-#elif defined(OS_POSIX)
-  header.thread_ref.as_handle = handle.platform_handle();
-#endif
-  return ForThread(header.thread_ref.as_id);
-}
-
-ThreadActivityTracker::ActivitySnapshot::ActivitySnapshot() {}
-ThreadActivityTracker::ActivitySnapshot::~ActivitySnapshot() {}
-
-
 ThreadActivityTracker::ThreadActivityTracker(void* base, size_t size)
     : header_(static_cast<Header*>(base)),
       stack_(reinterpret_cast<Activity*>(reinterpret_cast<char*>(base) +
                                          sizeof(Header))),
       stack_slots_(
           static_cast<uint32_t>((size - sizeof(Header)) / sizeof(Activity))) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Verify the parameters but fail gracefully if they're not valid so that
   // production code based on external inputs will not crash.  IsValid() will
@@ skipping 57 matching lines @@
   } else {
     // This is a file with existing data. Perform basic consistency checks.
     valid_ = true;
     valid_ = IsValid();
   }
 }
 
 ThreadActivityTracker::~ThreadActivityTracker() {}
 
 void ThreadActivityTracker::PushActivity(const void* origin,
-                                         ActivityType type,
+                                         Activity::Type type,
                                          const ActivityData& data) {
   // A thread-checker creates a lock to check the thread-id which means
   // re-entry into this code if lock acquisitions are being tracked.
-  DCHECK(type == ACT_LOCK_ACQUIRE || thread_checker_.CalledOnValidThread());
+  DCHECK(type == Activity::ACT_LOCK_ACQUIRE ||
+         thread_checker_.CalledOnValidThread());
 
   // Get the current depth of the stack. No access to other memory guarded
   // by this variable is done here so a "relaxed" load is acceptable.
   uint32_t depth = header_->current_depth.load(std::memory_order_relaxed);
 
   // Handle the case where the stack depth has exceeded the storage capacity.
   // Extra entries will be lost leaving only the base of the stack.
   if (depth >= stack_slots_) {
     // Since no other threads modify the data, no compare/exchange is needed.
     // Since no other memory is being modified, a "relaxed" store is acceptable.
     header_->current_depth.store(depth + 1, std::memory_order_relaxed);
     return;
   }
 
   // Get a pointer to the next activity and load it. No atomicity is required
   // here because the memory is known only to this thread. It will be made
   // known to other threads once the depth is incremented.
-  Activity* activity = &stack_[depth];
-  activity->time_internal = base::TimeTicks::Now().ToInternalValue();
-  activity->origin_address = reinterpret_cast<uintptr_t>(origin);
-  activity->activity_type = type;
-  activity->data = data;
-
-#if defined(SYZYASAN)
-  // Create a stacktrace from the current location and get the addresses.
-  StackTrace stack_trace;
-  size_t stack_depth;
-  const void* const* stack_addrs = stack_trace.Addresses(&stack_depth);
-  // Copy the stack addresses, ignoring the first one (here).
-  size_t i;
-  for (i = 1; i < stack_depth && i < kActivityCallStackSize; ++i) {
-    activity->call_stack[i - 1] = reinterpret_cast<uintptr_t>(stack_addrs[i]);
-  }
-  activity->call_stack[i - 1] = 0;
-#else
-  // Since the memory was initially zero and nothing ever overwrites it in
-  // this "else" case, there is no need to write even the null terminator.
-  //activity->call_stack[0] = 0;
-#endif
+  Activity::FillFrom(&stack_[depth], origin, type, data);
 
   // Save the incremented depth. Because this guards |activity| memory filled
   // above that may be read by another thread once the recorded depth changes,
   // a "release" store is required.
   header_->current_depth.store(depth + 1, std::memory_order_release);
 }
 
-void ThreadActivityTracker::ChangeActivity(ActivityType type,
+void ThreadActivityTracker::ChangeActivity(Activity::Type type,
                                            const ActivityData& data) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(type != ACT_NULL || &data != &kNullActivityData);
+  DCHECK(type != Activity::ACT_NULL || &data != &kNullActivityData);
 
   // Get the current depth of the stack and acquire the data held there.
   uint32_t depth = header_->current_depth.load(std::memory_order_acquire);
   DCHECK_LT(0U, depth);
 
   // Update the information if it is being recorded (i.e. within slot limit).
   if (depth <= stack_slots_) {
     Activity* activity = &stack_[depth - 1];
 
-    if (type != ACT_NULL) {
-      DCHECK_EQ(activity->activity_type & ACT_CATEGORY_MASK,
-                type & ACT_CATEGORY_MASK);
+    if (type != Activity::ACT_NULL) {
+      DCHECK_EQ(activity->activity_type & Activity::ACT_CATEGORY_MASK,
+                type & Activity::ACT_CATEGORY_MASK);
       activity->activity_type = type;
     }
 
     if (&data != &kNullActivityData)
       activity->data = data;
   }
 }
 
 void ThreadActivityTracker::PopActivity() {
   // Do an atomic decrement of the depth. No changes to stack entries guarded
   // by this variable are done here so a "relaxed" operation is acceptable.
   // |depth| will receive the value BEFORE it was modified.
   uint32_t depth =
       header_->current_depth.fetch_sub(1, std::memory_order_relaxed);
 
   // Validate that everything is running correctly.
   DCHECK_LT(0U, depth);
 
   // A thread-checker creates a lock to check the thread-id which means
   // re-entry into this code if lock acquisitions are being tracked.
-  DCHECK(stack_[depth - 1].activity_type == ACT_LOCK_ACQUIRE ||
+  DCHECK(stack_[depth - 1].activity_type == Activity::ACT_LOCK_ACQUIRE ||
          thread_checker_.CalledOnValidThread());
 
   // The stack has shrunk meaning that some other thread trying to copy the
   // contents for reporting purposes could get bad data. That thread would
   // have written a non-zero value into |stack_unchanged|; clearing it here
   // will let that thread detect that something did change. This needs to
   // happen after the atomic |depth| operation above so a "release" store
   // is required.
   header_->stack_unchanged.store(0, std::memory_order_release);
 }
@@ skipping 391 matching lines @@
     // the data won't be persisted.
     delete[] reinterpret_cast<char*>(mem_base);
   }
 }
 
 // static
 void GlobalActivityTracker::OnTLSDestroy(void* value) {
   delete reinterpret_cast<ManagedActivityTracker*>(value);
 }
 
-
 ScopedActivity::ScopedActivity(const tracked_objects::Location& location,
                                uint8_t action,
                                uint32_t id,
                                int32_t info)
     : GlobalActivityTracker::ScopedThreadActivity(
           location.program_counter(),
-          static_cast<ThreadActivityTracker::ActivityType>(
-              ThreadActivityTracker::ACT_GENERIC | action),
-          ThreadActivityTracker::ActivityData::ForGeneric(id, info),
+          static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
+          ActivityData::ForGeneric(id, info),
           /*lock_allowed=*/true),
       id_(id) {
   // The action must not affect the category bits of the activity type.
-  DCHECK_EQ(0, action & ThreadActivityTracker::ACT_CATEGORY_MASK);
+  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
 }
 
 void ScopedActivity::ChangeAction(uint8_t action) {
-  DCHECK_EQ(0, action & ThreadActivityTracker::ACT_CATEGORY_MASK);
-  ChangeTypeAndData(static_cast<ThreadActivityTracker::ActivityType>(
-                        ThreadActivityTracker::ACT_GENERIC | action),
-                    ThreadActivityTracker::kNullActivityData);
+  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
+  ChangeTypeAndData(static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
+                    kNullActivityData);
 }
 
 void ScopedActivity::ChangeInfo(int32_t info) {
-  ChangeTypeAndData(ThreadActivityTracker::ACT_NULL,
-                    ThreadActivityTracker::ActivityData::ForGeneric(id_, info));
+  ChangeTypeAndData(Activity::ACT_NULL, ActivityData::ForGeneric(id_, info));
 }
 
 void ScopedActivity::ChangeActionAndInfo(uint8_t action, int32_t info) {
-  DCHECK_EQ(0, action & ThreadActivityTracker::ACT_CATEGORY_MASK);
-  ChangeTypeAndData(static_cast<ThreadActivityTracker::ActivityType>(
-                        ThreadActivityTracker::ACT_GENERIC | action),
-                    ThreadActivityTracker::ActivityData::ForGeneric(id_, info));
+  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
+  ChangeTypeAndData(static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
+                    ActivityData::ForGeneric(id_, info));
 }
 
 ScopedTaskRunActivity::ScopedTaskRunActivity(const base::PendingTask& task)
     : GlobalActivityTracker::ScopedThreadActivity(
           task.posted_from.program_counter(),
-          ThreadActivityTracker::ACT_TASK_RUN,
-          ThreadActivityTracker::ActivityData::ForTask(task.sequence_num),
+          Activity::ACT_TASK_RUN,
+          ActivityData::ForTask(task.sequence_num),
           /*lock_allowed=*/true) {}
 
 ScopedLockAcquireActivity::ScopedLockAcquireActivity(
     const base::internal::LockImpl* lock)
     : GlobalActivityTracker::ScopedThreadActivity(
           nullptr,
-          ThreadActivityTracker::ACT_LOCK_ACQUIRE,
-          ThreadActivityTracker::ActivityData::ForLock(lock),
+          Activity::ACT_LOCK_ACQUIRE,
+          ActivityData::ForLock(lock),
           /*lock_allowed=*/false) {}
 
 ScopedEventWaitActivity::ScopedEventWaitActivity(
     const base::WaitableEvent* event)
     : GlobalActivityTracker::ScopedThreadActivity(
           nullptr,
-          ThreadActivityTracker::ACT_EVENT_WAIT,
-          ThreadActivityTracker::ActivityData::ForEvent(event),
+          Activity::ACT_EVENT_WAIT,
+          ActivityData::ForEvent(event),
           /*lock_allowed=*/true) {}
 
 ScopedThreadJoinActivity::ScopedThreadJoinActivity(
     const base::PlatformThreadHandle* thread)
     : GlobalActivityTracker::ScopedThreadActivity(
           nullptr,
-          ThreadActivityTracker::ACT_THREAD_JOIN,
-          ThreadActivityTracker::ActivityData::ForThread(*thread),
+          Activity::ACT_THREAD_JOIN,
+          ActivityData::ForThread(*thread),
           /*lock_allowed=*/true) {}
 
 #if !defined(OS_NACL) && !defined(OS_IOS)
 ScopedProcessWaitActivity::ScopedProcessWaitActivity(
     const base::Process* process)
     : GlobalActivityTracker::ScopedThreadActivity(
           nullptr,
-          ThreadActivityTracker::ACT_PROCESS_WAIT,
-          ThreadActivityTracker::ActivityData::ForProcess(process->Pid()),
+          Activity::ACT_PROCESS_WAIT,
+          ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base