Collect stability data from global and activity scopes

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 114 matching lines @@
   }
 };
 
 // A "null" activity-data that can be passed to indicate "do not change".
 extern const ActivityData kNullActivityData;
 
 
 // A helper class that is used for managing memory allocations within a
 // persistent memory allocator. Instances of this class are NOT thread-safe.
 // Use from a single thread or protect access with a lock.
-class ActivityTrackerMemoryAllocator {
+class BASE_EXPORT ActivityTrackerMemoryAllocator {
  public:
   using Reference = PersistentMemoryAllocator::Reference;
 
   // Creates a instance for allocating objects of a fixed |object_type|, a
   // corresponding |object_free| type, and the |object_size|. An internal
   // cache of the last |cache_size| released references will be kept for
   // quick future fetches. If |make_iterable| then allocated objects will
   // be marked "iterable" in the allocator.
   ActivityTrackerMemoryAllocator(PersistentMemoryAllocator* allocator,
                                  uint32_t object_type,
@@ skipping 154 matching lines @@
     SIGNED_VALUE,
     UNSIGNED_VALUE,
   };
 
   class BASE_EXPORT TypedValue {
    public:
     TypedValue();
     TypedValue(const TypedValue& other);
     ~TypedValue();
 
+    ValueType type() const { return type_; }
+
     // These methods return the extracted value in the correct format.
     StringPiece Get() const;
     StringPiece GetString() const;
     bool GetBool() const;
     char GetChar() const;
     int64_t GetInt() const;
     uint64_t GetUint() const;
 
     // These methods return references to process memory as originally provided
     // to corresponding Set calls. USE WITH CAUTION! There is no guarantee that
     // the referenced memory is assessible or useful.  It's possible that:
     //  - the memory was free'd and reallocated for a different purpose
     //  - the memory has been released back to the OS
     //  - the memory belongs to a different process's address space
     // Dereferencing the returned StringPiece when the memory is not accessible
     // will cause the program to SEGV!
     StringPiece GetReference() const;
     StringPiece GetStringReference() const;
 
    private:
     friend class ActivityUserData;
 
-    ValueType type;
-    uint64_t short_value;    // Used to hold copy of numbers, etc.
-    std::string long_value;  // Used to hold copy of raw/string data.
-    StringPiece ref_value;   // Used to hold reference to external data.
+    ValueType type_;

[bcwhite, 2017/01/10 18:00:38]

Thanks.  I think I started this as a struct is why the underscores were missing.

[manzagop (departed), 2017/01/10 18:55:48]

Acknowledged.

+    uint64_t short_value_;    // Used to hold copy of numbers, etc.
+    std::string long_value_;  // Used to hold copy of raw/string data.
+    StringPiece ref_value_;   // Used to hold reference to external data.
   };
 
   using Snapshot = std::map<std::string, TypedValue>;
 
   ActivityUserData(void* memory, size_t size);
   ~ActivityUserData();
 
   // Gets the unique ID number for this user data. If this changes then the
   // contents have been overwritten by another thread. The return value is
   // always non-zero unless it's actually just a data "sink".
@@ skipping 184 matching lines @@
     void ChangeTypeAndData(Activity::Type type, const ActivityData& data);
 
    protected:
     // The thread tracker to which this object reports. It can be null if
     // activity tracking is not (yet) enabled.
     ThreadActivityTracker* const tracker_;
 
     // An identifier that indicates a specific activity on the stack.
     ActivityId activity_id_;
 
+   private:
     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
@@ skipping 402 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_