Updates for improved PMA 'object' interface.

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 43 matching lines @@
   // 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 {
+  // SHA1(base::debug::ActivityData): Increment this if structure changes!
+  static constexpr uint32_t kPersistentTypeId = 0x72DC176D + 1;
+  // Expected size for 32/64-bit check. Update this if structure changes!
+  static constexpr size_t kExpectedInstanceSize = 8;

[manzagop (departed), 2017/02/17 15:50:55]

static_assert for this? Same below.

[bcwhite, 2017/02/17 15:52:11]

These sizes are asserted by the PMA when using the object interface.

+
   // 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.
@@ skipping 81 matching lines @@
   // Gets a reference to an object of the configured type. This can return
   // a null reference if it was not possible to allocate the memory.
   Reference GetObjectReference();
 
   // Returns an object to the "free" pool.
   void ReleaseObjectReference(Reference ref);
 
   // Helper function to access an object allocated using this instance.
   template <typename T>
   T* GetAsObject(Reference ref) {
-    return allocator_->GetAsObject<T>(ref, object_type_);
+    return allocator_->GetAsObject<T>(ref);
   }
 
   // Similar to GetAsObject() but converts references to arrays of objects.
   template <typename T>
   T* GetAsArray(Reference ref, size_t count) {
     return allocator_->GetAsArray<T>(ref, object_type_, count);
   }
 
   // The current "used size" of the internal cache, visible for testing.
   size_t cache_used() const { return cache_used_; }
@@ skipping 15 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ActivityTrackerMemoryAllocator);
 };
 
 
 // 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 {
+  // SHA1(base::debug::Activity): Increment this if structure changes!
+  static constexpr uint32_t kPersistentTypeId = 0x99425159 + 1;
+  // Expected size for 32/64-bit check. Update this if structure changes!
+  static constexpr size_t kExpectedInstanceSize =
+      48 + ActivityData::kExpectedInstanceSize;
+
   // 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 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.
@@ skipping 857 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_