[Tracing] Add lookup support to AllocationRegister

base/trace_event/heap_profiler_allocation_register.cc

 // 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.
 
 #include "base/trace_event/heap_profiler_allocation_register.h"
 
 #include "base/trace_event/trace_event_memory_overhead.h"
 
 namespace base {
 namespace trace_event {
@@ skipping 25 matching lines @@
                                 size_t size,
                                 AllocationContext context) {
   DCHECK(address != nullptr);
 
   CellIndex* idx_ptr = Lookup(address);
 
   // If the index is 0, the address is not yet present, so insert it.
   if (*idx_ptr == 0) {
     *idx_ptr = GetFreeCell();
 
-    cells_[*idx_ptr].allocation.address = address;
+    // The address stored in a cell is const as long as it is exposed (via the
+    // iterators or |Get|), but because cells are re-used, a const cast is
+    // required to set it on insert and remove.
+    void* const& allocation_address = cells_[*idx_ptr].allocation.address;
+    const_cast<void*&>(allocation_address) = address;
     cells_[*idx_ptr].next = 0;
   }
 
   cells_[*idx_ptr].allocation.size = size;
   cells_[*idx_ptr].allocation.context = context;
 }
 
 void AllocationRegister::Remove(void* address) {
   // Get a pointer to the index of the cell that stores |address|. The index can
   // be an element of |buckets_| or the |next| member of a cell.
   CellIndex* idx_ptr = Lookup(address);
   CellIndex freed_idx = *idx_ptr;
 
   // If the index is 0, the address was not there in the first place.
   if (freed_idx == 0)
     return;
 
   // The cell at the index is now free, remove it from the linked list for
   // |Hash(address)|.
   Cell* freed_cell = &cells_[freed_idx];
   *idx_ptr = freed_cell->next;
 
   // Put the free cell at the front of the free list.
   freed_cell->next = free_list_;
   free_list_ = freed_idx;
 
   // Reset the address, so that on iteration the free cell is ignored.
-  freed_cell->allocation.address = nullptr;
+  const_cast<void*&>(freed_cell->allocation.address) = nullptr;
+}
+
+AllocationRegister::Allocation* AllocationRegister::Get(void* address) {
+  CellIndex* idx_ptr = Lookup(address);
+
+  // If the index is 0, the address is not present in the table.
+  return *idx_ptr == 0 ? nullptr : &cells_[*idx_ptr].allocation;
 }
 
 AllocationRegister::ConstIterator AllocationRegister::begin() const {
   // Initialize the iterator's index to 0. Cell 0 never stores an entry.
   ConstIterator iterator(*this, 0);
   // Incrementing will advance the iterator to the first used cell.
   ++iterator;
   return iterator;
 }
 
@@ skipping 92 matching lines @@
   size_t resident = sizeof(AllocationRegister)
                     // Include size of touched cells (size of |*cells_|).
                     + sizeof(Cell) * next_unused_cell_
                     // Size of |*buckets_|.
                     + sizeof(CellIndex) * kNumBuckets;
   overhead->Add("AllocationRegister", allocated, resident);
 }
 
 }  // namespace trace_event
 }  // namespace base