Refactor embedded structures to top-level scope.

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 21 matching lines @@
 
 class FilePath;
 class Lock;
 class MemoryMappedFile;
 class PlatformThreadHandle;
 class Process;
 class WaitableEvent;
 
 namespace debug {
 
-// 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.
-//
-// This class is not generally used directly but instead managed by the
-// GlobalActivityTracker instance and updated using Scoped*Activity local
-// objects.
-class BASE_EXPORT ThreadActivityTracker {
- public:
-  enum : int {
-    // The maximum number of call-stack addresses stored per activity. This
-    // cannot be changed without also changing the version number of the
-    // structure. See kTypeIdActivityTracker in GlobalActivityTracker.
-    kActivityCallStackSize = 10
-  };
+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
+  // structure. See kTypeIdActivityTracker in GlobalActivityTracker.
+  kActivityCallStackSize = 10,
+};
+
+// The data associated with an activity is dependent upon the activity type.
+// This union defines all of the various fields. All fields must be explicitly
+// sized types to ensure no interoperability problems between 32-bit and
+// 64-bit systems.
+union ActivityData {
+  // Generic activities don't have any defined structure.
+  struct {
+    uint32_t id;   // An arbitrary identifier used for association.
+    int32_t info;  // An arbitrary value used for information purposes.
+  } generic;
+  struct {
+    uint64_t sequence_id;  // The sequence identifier of the posted task.
+  } task;
+  struct {
+    uint64_t lock_address;  // The memory address of the lock object.
+  } lock;
+  struct {
+    uint64_t event_address;  // The memory address of the event object.
+  } event;
+  struct {
+    int64_t thread_id;  // A unique identifier for a thread within a process.
+  } thread;
+  struct {
+    int64_t process_id;  // A unique identifier for a process.
+  } process;
+
+  // These methods create an ActivityData object from the appropriate
+  // parameters. Objects of this type should always be created this way to
+  // ensure that no fields remain unpopulated should the set of recorded
+  // fields change. They're defined inline where practical because they
+  // reduce to loading a small local structure with a few values, roughly
+  // the same as loading all those values into parameters.
+
+  static ActivityData ForGeneric(uint32_t id, int32_t info) {
+    ActivityData data;
+    data.generic.id = id;
+    data.generic.info = info;
+    return data;
+  }
+
+  static ActivityData ForTask(uint64_t sequence) {
+    ActivityData data;
+    data.task.sequence_id = sequence;
+    return data;
+  }
+
+  static ActivityData ForLock(const void* lock) {
+    ActivityData data;
+    data.lock.lock_address = reinterpret_cast<uintptr_t>(lock);
+    return data;
+  }
+
+  static ActivityData ForEvent(const void* event) {
+    ActivityData data;
+    data.event.event_address = reinterpret_cast<uintptr_t>(event);
+    return data;
+  }
+
+  static ActivityData ForThread(const PlatformThreadHandle& handle);
+  static ActivityData ForThread(const int64_t id) {
+    ActivityData data;
+    data.thread.thread_id = id;
+    return data;
+  }
+
+  static ActivityData ForProcess(const int64_t id) {
+    ActivityData data;
+    data.process.process_id = id;
+    return data;
+  }
+};
+
+// A "null" activity-data that can be passed to indicate "do not change".
+extern const ActivityData kNullActivityData;
+
+// This structure is the full contents recorded for every activity pushed
+// onto the stack. The |activity_type| indicates what is actually stored in
+// the |data| field. All fields must be explicitly sized types to ensure no
+// interoperability problems between 32-bit and 64-bit systems.
+struct Activity {
   // The type of an activity on the stack. Activities are broken into
   // categories with the category ID taking the top 4 bits and the lower
   // bits representing an action within that category. This combination
   // makes it easy to "switch" based on the type during analysis.
-  enum ActivityType : uint8_t {
+  enum Type : uint8_t {
     // This "null" constant is used to indicate "do not change" in calls.
     ACT_NULL = 0,
 
     // Task activities involve callbacks posted to a thread or thread-pool
     // using the PostTask() method or any of its friends.
     ACT_TASK = 1 << 4,
     ACT_TASK_RUN = ACT_TASK,
 
     // Lock activities involve the acquisition of "mutex" locks.
     ACT_LOCK = 2 << 4,
@@ skipping 17 matching lines @@
 
     // Generic activities are user defined and can be anything.
     ACT_GENERIC = 15 << 4,
 
     // These constants can be used to separate the category and action from
     // a combined activity type.
     ACT_CATEGORY_MASK = 0xF << 4,
     ACT_ACTION_MASK = 0xF
   };
 
-  // The data associated with an activity is dependent upon the activity type.
-  // This union defines all of the various fields. All fields must be explicitly
-  // sized types to ensure no interoperability problems between 32-bit and
-  // 64-bit systems.
-  union ActivityData {
-    // Generic activities don't have any defined structure.
-    struct {
-      uint32_t id;   // An arbitrary identifier used for association.
-      int32_t info;  // An arbitrary value used for information purposes.
-    } generic;
-    struct {
-      uint64_t sequence_id;  // The sequence identifier of the posted task.
-    } task;
-    struct {
-      uint64_t lock_address;  // The memory address of the lock object.
-    } lock;
-    struct {
-      uint64_t event_address;  // The memory address of the event object.
-    } event;
-    struct {
-      int64_t thread_id;  // A unique identifier for a thread within a process.
-    } thread;
-    struct {
-      int64_t process_id;  // A unique identifier for a process.
-    } process;
+  // Internal representation of time. During collection, this is in "ticks"
+  // but when returned in a snapshot, it is "wall time".
+  int64_t time_internal;
 
-    // These methods create an ActivityData object from the appropriate
-    // parameters. Objects of this type should always be created this way to
-    // ensure that no fields remain unpopulated should the set of recorded
-    // fields change. They're defined inline where practical because they
-    // reduce to loading a small local structure with a few values, roughly
-    // the same as loading all those values into parameters.
+  // The address that is the origin of the activity if it not obvious from
+  // the call stack. This is useful for things like tasks that are posted
+  // from a completely different thread though most activities will leave
+  // it null.
+  uint64_t origin_address;
 
-    static ActivityData ForGeneric(uint32_t id, int32_t info) {
-      ActivityData data;
-      data.generic.id = id;
-      data.generic.info = info;
-      return data;
-    }
+  // Array of program-counters that make up the top of the call stack.
+  // Despite the fixed size, this list is always null-terminated. Entries
+  // after the terminator have no meaning and may or may not also be null.
+  // The list will be completely empty if call-stack collection is not
+  // enabled.
+  uint64_t call_stack[kActivityCallStackSize];
 
-    static ActivityData ForTask(uint64_t sequence) {
-      ActivityData data;
-      data.task.sequence_id = sequence;
-      return data;
-    }
+  // The (enumerated) type of the activity. This defines what fields of the
+  // |data| record are valid.
+  uint8_t activity_type;
 
-    static ActivityData ForLock(const void* lock) {
-      ActivityData data;
-      data.lock.lock_address = reinterpret_cast<uintptr_t>(lock);
-      return data;
-    }
+  // Padding to ensure that the next member begins on a 64-bit boundary
+  // even on 32-bit builds which ensures inter-operability between CPU
+  // architectures. New fields can be taken from this space.
+  uint8_t padding[7];
 
-    static ActivityData ForEvent(const void* event) {
-      ActivityData data;
-      data.event.event_address = reinterpret_cast<uintptr_t>(event);
-      return data;
-    }
+  // Information specific to the |activity_type|.
+  ActivityData data;
 
-    static ActivityData ForThread(const PlatformThreadHandle& handle);
-    static ActivityData ForThread(const int64_t id) {
-      ActivityData data;
-      data.thread.thread_id = id;
-      return data;
-    }
+  static void FillFrom(Activity* activity,
+                       const void* origin,
+                       Type type,
+                       const ActivityData& data);
+};
 
-    static ActivityData ForProcess(const int64_t id) {
-      ActivityData data;
-      data.process.process_id = id;
-      return data;
-    }
-  };
+// This structure holds a copy of all the internal data at the moment the
+// "snapshot" operation is done. It is disconnected from the live tracker
+// so that continued operation of the thread will not cause changes here.
+struct BASE_EXPORT ActivitySnapshot {
+  // Explicit constructor/destructor are needed because of complex types
+  // with non-trivial default constructors and destructors.
+  ActivitySnapshot();
+  ~ActivitySnapshot();
 
-  // This structure is the full contents recorded for every activity pushed
-  // onto the stack. The |activity_type| indicates what is actually stored in
-  // the |data| field. All fields must be explicitly sized types to ensure no
-  // interoperability problems between 32-bit and 64-bit systems.
-  struct Activity {
-    // Internal representation of time. During collection, this is in "ticks"
-    // but when returned in a snapshot, it is "wall time".
-    int64_t time_internal;
+  // The name of the thread as set when it was created. The name may be
+  // truncated due to internal length limitations.
+  std::string thread_name;
 
-    // The address that is the origin of the activity if it not obvious from
-    // the call stack. This is useful for things like tasks that are posted
-    // from a completely different thread though most activities will leave
-    // it null.
-    uint64_t origin_address;
+  // The process and thread IDs. These values have no meaning other than
+  // they uniquely identify a running process and a running thread within
+  // that process.  Thread-IDs can be re-used across different processes
+  // and both can be re-used after the process/thread exits.
+  int64_t process_id = 0;
+  int64_t thread_id = 0;
 
-    // Array of program-counters that make up the top of the call stack.
-    // Despite the fixed size, this list is always null-terminated. Entries
-    // after the terminator have no meaning and may or may not also be null.
-    // The list will be completely empty if call-stack collection is not
-    // enabled.
-    uint64_t call_stack[kActivityCallStackSize];
+  // The current stack of activities that are underway for this thread. It
+  // is limited in its maximum size with later entries being left off.
+  std::vector<Activity> activity_stack;
 
-    // The (enumerated) type of the activity. This defines what fields of the
-    // |data| record are valid.
-    uint8_t activity_type;
+  // The current total depth of the activity stack, including those later
+  // entries not recorded in the |activity_stack| vector.
+  uint32_t activity_stack_depth = 0;
+};
 
-    // Padding to ensure that the next member begins on a 64-bit boundary
-    // even on 32-bit builds which ensures inter-operability between CPU
-    // architectures. New fields can be taken from this space.
-    uint8_t padding[7];
 
-    // Information specific to the |activity_type|.
-    ActivityData data;
-  };
-
-  // This structure holds a copy of all the internal data at the moment the
-  // "snapshot" operation is done. It is disconnected from the live tracker
-  // so that continued operation of the thread will not cause changes here.
-  struct BASE_EXPORT ActivitySnapshot {
-    // Explicit constructor/destructor are needed because of complex types
-    // with non-trivial default constructors and destructors.
-    ActivitySnapshot();
-    ~ActivitySnapshot();
-
-    // The name of the thread as set when it was created. The name may be
-    // truncated due to internal length limitations.
-    std::string thread_name;
-
-    // The process and thread IDs. These values have no meaning other than
-    // they uniquely identify a running process and a running thread within
-    // that process.  Thread-IDs can be re-used across different processes
-    // and both can be re-used after the process/thread exits.
-    int64_t process_id = 0;
-    int64_t thread_id = 0;
-
-    // The current stack of activities that are underway for this thread. It
-    // is limited in its maximum size with later entries being left off.
-    std::vector<Activity> activity_stack;
-
-    // The current total depth of the activity stack, including those later
-    // entries not recorded in the |activity_stack| vector.
-    uint32_t activity_stack_depth = 0;
-  };
-
+// 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.
+//
+// This class is not generally used directly but instead managed by the
+// GlobalActivityTracker instance and updated using Scoped*Activity local
+// objects.
+class BASE_EXPORT ThreadActivityTracker {
+ public:
   // This is the base class for having the compiler manage an activity on the
   // tracker's stack. It does nothing but call methods on the passed |tracker|
   // if it is not null, making it safe (and cheap) to create these objects
   // even if activity tracking is not enabled.
   class BASE_EXPORT ScopedActivity {
    public:
     ScopedActivity(ThreadActivityTracker* tracker,
                    const void* origin,
-                   ActivityType type,
+                   Activity::Type type,
                    const ActivityData& data)
         : tracker_(tracker) {
       if (tracker_)
         tracker_->PushActivity(origin, type, data);
     }
 
     ~ScopedActivity() {
       if (tracker_)
         tracker_->PopActivity();
     }
 
-    void ChangeTypeAndData(ActivityType type, const ActivityData& data) {
+    void ChangeTypeAndData(Activity::Type type, const ActivityData& data) {
       if (tracker_)
         tracker_->ChangeActivity(type, data);
     }
 
    private:
     // The thread tracker to which this object reports. It can be null if
     // activity tracking is not (yet) enabled.
     ThreadActivityTracker* const tracker_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedActivity);
   };
 
   // A ThreadActivityTracker runs on top of memory that is managed externally.
   // It must be large enough for the internal header and a few Activity
   // blocks. See SizeForStackDepth().
   ThreadActivityTracker(void* base, size_t size);
   virtual ~ThreadActivityTracker();
 
   // Indicates that an activity has started from a given |origin| address in
   // the code, though it can be null if the creator's address is not known.
   // The |type| and |data| describe the activity.
   void PushActivity(const void* origin,
-                    ActivityType type,
+                    Activity::Type type,
                     const ActivityData& data);
 
   // Changes the activity |type| and |data| of the top-most entry on the stack.
   // This is useful if the information has changed and it is desireable to
   // track that change without creating a new stack entry. If the type is
   // ACT_NULL or the data is kNullActivityData then that value will remain
   // unchanged. The type, if changed, must remain in the same category.
   // Changing both is not atomic so a snapshot operation could occur between
   // the update of |type| and |data| or between update of |data| fields.
-  void ChangeActivity(ActivityType type, const ActivityData& data);
+  void ChangeActivity(Activity::Type type, const ActivityData& data);
 
   // Indicates that an activity has completed.
   void PopActivity();
 
   // Returns whether the current data is valid or not. It is not valid if
   // corruption has been detected in the header or other data structures.
   bool IsValid() const;
 
   // Gets a copy of the tracker contents for analysis. Returns false if a
   // snapshot was not possible, perhaps because the data is not valid; the
   // contents of |output_snapshot| are undefined in that case. The current
   // implementation does not support concurrent snapshot operations.
   bool Snapshot(ActivitySnapshot* output_snapshot) const;
 
   // Calculates the memory size required for a given stack depth, including
   // the internal header structure for the stack.
   static size_t SizeForStackDepth(int stack_depth);
 
-  // A "null" activity-data that can be passed to indicate "do not change".
-  static const ActivityData kNullActivityData;
-
  private:
   friend class ActivityTrackerTest;
 
   // This structure contains all the common information about the thread so
   // it doesn't have to be repeated in every entry on the stack. It is defined
   // and used completely within the .cc file.
   struct Header;
 
   Header* const header_;        // Pointer to the Header structure.
   Activity* const stack_;       // The stack of activities.
@@ skipping 24 matching lines @@
   };
 
   // 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.
   class BASE_EXPORT ScopedThreadActivity
       : public ThreadActivityTracker::ScopedActivity {
    public:
     ScopedThreadActivity(const void* origin,
-                         ThreadActivityTracker::ActivityType type,
-                         const ThreadActivityTracker::ActivityData& data,
+                         Activity::Type type,
+                         const ActivityData& data,
                          bool lock_allowed)
         : ThreadActivityTracker::ScopedActivity(
               GetOrCreateTracker(lock_allowed),
               origin,
               type,
               data) {}
 
    private:
     // Gets (or creates) a tracker for the current thread. If locking is not
     // allowed (because a lock is being tracked which would cause recursion)
@@ skipping 230 matching lines @@
   explicit ScopedProcessWaitActivity(const base::Process* process);
  private:
   DISALLOW_COPY_AND_ASSIGN(ScopedProcessWaitActivity);
 };
 #endif
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_ACTIVITY_TRACKER_H_