heap-profiler: Clean up some comments and C++.

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 <limits>
 
 #include "base/trace_event/trace_event_memory_overhead.h"
@@ skipping 64 matching lines @@
     : AllocationRegister(kAllocationCapacity, kBacktraceCapacity) {}
 
 AllocationRegister::AllocationRegister(size_t allocation_capacity,
                                        size_t backtrace_capacity)
     : allocations_(allocation_capacity), backtraces_(backtrace_capacity) {
   Backtrace sentinel = {};
   sentinel.frames[0] = StackFrame::FromThreadName("[out of heap profiler mem]");
   sentinel.frame_count = 1;
 
   // Rationale for max / 2: in theory we could just start the sentinel with a
-  // refcount == 0. However, this optimization avoids to hit the 2nd condition
-  // of the "if" in RemoveBacktrace, hence reducing the chances of hurting the
-  // fastpath. From a functional viewpoint, the sentinel is safe even if we wrap
-  // over the refcount.
+  // refcount == 0. However, using max / 2 allows short circuiting of the
+  // conditional in RemoveBacktrace() keeping the sentinel logic out of the fast
+  // path. From a functional viewpoint, the sentinel is safe even if we wrap
+  // over refcount because .
   BacktraceMap::KVPair::second_type sentinel_refcount =
       std::numeric_limits<BacktraceMap::KVPair::second_type>::max() / 2;
   auto index_and_flag = backtraces_.Insert(sentinel, sentinel_refcount);
   DCHECK(index_and_flag.second);
-  out_of_storage_backtrace_index_ = index_and_flag.first;
+  DCHECK_EQ(index_and_flag.first, kOutOfStorageBacktraceIndex);
 }
 
 AllocationRegister::~AllocationRegister() {}
 
 bool AllocationRegister::Insert(const void* address,
                                 size_t size,
                                 const AllocationContext& context) {
   DCHECK(address != nullptr);
   if (size == 0) {
     return false;
@@ skipping 54 matching lines @@
   size_t resident = sizeof(AllocationRegister) +
                     allocations_.EstimateUsedMemory() +
                     backtraces_.EstimateUsedMemory();
   overhead->Add("AllocationRegister", allocated, resident);
 }
 
 AllocationRegister::BacktraceMap::KVIndex AllocationRegister::InsertBacktrace(
     const Backtrace& backtrace) {
   auto index = backtraces_.Insert(backtrace, 0).first;
   if (index == BacktraceMap::kInvalidKVIndex)
-    return out_of_storage_backtrace_index_;
+    return kOutOfStorageBacktraceIndex;
   auto& backtrace_and_count = backtraces_.Get(index);
   backtrace_and_count.second++;
   return index;
 }
 
 void AllocationRegister::RemoveBacktrace(BacktraceMap::KVIndex index) {
   auto& backtrace_and_count = backtraces_.Get(index);
   if (--backtrace_and_count.second == 0 &&
-      index != out_of_storage_backtrace_index_) {
+      index != kOutOfStorageBacktraceIndex) {
     // Backtrace is not referenced anymore - remove it.
     backtraces_.Remove(index);
   }
 }
 
 AllocationRegister::Allocation AllocationRegister::GetAllocation(
     AllocationMap::KVIndex index) const {
   const auto& address_and_info = allocations_.Get(index);
   const auto& backtrace_and_count =
       backtraces_.Get(address_and_info.second.backtrace_index);
   return {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