On heap tracking datastructure overflow, degrade instead of CHECK()

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 <algorithm>
 
 #include "base/trace_event/trace_event_memory_overhead.h"
 
@@ skipping 63 matching lines @@
     : AllocationRegister(kAllocationCapacity, kBacktraceCapacity) {}
 
 AllocationRegister::AllocationRegister(size_t allocation_capacity,
                                        size_t backtrace_capacity)
     : allocations_(allocation_capacity),
       backtraces_(backtrace_capacity) {}
 
 AllocationRegister::~AllocationRegister() {
 }
 
-void AllocationRegister::Insert(const void* address,
+bool AllocationRegister::Insert(const void* address,

[Primiano Tucci (use gerrit), 2017/03/30 13:32:40]

do we need this bool here?
If it's just for the test I'd just keep this a void and check that:
- the insert doesn't fail.
- the address is not in the list.

[awong, 2017/03/31 04:28:30]

I feel like the API is cleaner to have a bool return. Is there a downside to
this?

[Primiano Tucci (use gerrit), 2017/03/31 19:05:47]

Not strong enough to justify another round on this. You won. :P

                                 size_t size,
                                 const AllocationContext& context) {
   DCHECK(address != nullptr);
   if (size == 0) {
-    return;
+    return false;
   }
 
   AllocationInfo info = {
       size,
       context.type_name,
       InsertBacktrace(context.backtrace)
   };
 
   // Try to insert the allocation.
   auto index_and_flag = allocations_.Insert(address, info);
-  if (!index_and_flag.second) {
+  if (!index_and_flag.second &&
+      index_and_flag.first != AllocationMap::kInvalidKVIndex) {
     // |address| is already there - overwrite the allocation info.
     auto& old_info = allocations_.Get(index_and_flag.first).second;
     RemoveBacktrace(old_info.backtrace_index);
     old_info = info;
   }
+
+  return index_and_flag.second;
 }
 
 void AllocationRegister::Remove(const void* address) {
   auto index = allocations_.Find(address);
   if (index == AllocationMap::kInvalidKVIndex) {
     return;
   }
 
   const AllocationInfo& info = allocations_.Get(index).second;
   RemoveBacktrace(info.backtrace_index);
@@ skipping 55 matching lines @@
       address_and_info.first,
       address_and_info.second.size,
       AllocationContext(
           backtrace_and_count.first,
           address_and_info.second.type_name)
   };
 }
 
 }  // namespace trace_event
 }  // namespace base