[Tracing] Add lookup support to AllocationRegister

base/trace_event/heap_profiler_allocation_register.h

 // Copyright 2015 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.
 
 #ifndef BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_REGISTER_H_
 #define BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_REGISTER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 16 matching lines @@
 // stored.
 //
 // Replaying a recording of Chrome's allocations and frees against this hash
 // table takes about 15% of the time that it takes to replay them against
 // |std::map|.
 class BASE_EXPORT AllocationRegister {
  public:
   // The data stored in the hash table;
   // contains the details about an allocation.
   struct Allocation {
-    void* address;
+    void* const address;
     size_t size;
     AllocationContext context;
   };
 
   // An iterator that iterates entries in the hash table efficiently, but in no
   // particular order. It can do this by iterating the cells and ignoring the
   // linked lists altogether. Instead of checking whether a cell is in the free
   // list to see if it should be skipped, a null address is used to indicate
   // that a cell is free.
   class BASE_EXPORT ConstIterator {
@@ skipping 20 matching lines @@
   // Inserts allocation details into the table. If the address was present
   // already, its details are updated. |address| must not be null. (This is
   // because null is used to mark free cells, to allow efficient iteration of
   // the hash table.)
   void Insert(void* address, size_t size, AllocationContext context);
 
   // Removes the address from the table if it is present. It is ok to call this
   // with a null pointer.
   void Remove(void* address);
 
+  // Returns a pointer to the allocation at the address, or null if there is no
+  // allocation at that address. This can be used to change the allocation
+  // context after insertion, for example to change the type name.
+  Allocation* Get(void* address);
+
   ConstIterator begin() const;
   ConstIterator end() const;
 
   // Estimates memory overhead including |sizeof(AllocationRegister)|.
   void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead) const;
 
  private:
   friend class AllocationRegisterTest;
   using CellIndex = uint32_t;
 
@@ skipping 74 matching lines @@
   // is used. This is the high water mark for the number of entries stored.
   CellIndex next_unused_cell_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationRegister);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_REGISTER_H_