[Tracing] Introduce HeapDumpWriter helper class

base/trace_event/memory_profiler_allocation_context.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/memory_profiler_allocation_context.h"
 
 #include <algorithm>
+#include <cstring>
 
+#include "base/hash.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 namespace trace_event {
 
 subtle::Atomic32 AllocationContextTracker::capture_enabled_ = 0;
 
 namespace {
 ThreadLocalStorage::StaticSlot g_tls_alloc_ctx_tracker = TLS_INITIALIZER;
 }
 
 AllocationStack::AllocationStack() {}
 AllocationStack::~AllocationStack() {}
 
-// This function is added to the TLS slot to clean up the instance when the
-// thread exits.
-void DestructAllocationContextTracker(void* alloc_ctx_tracker) {
-  delete static_cast<AllocationContextTracker*>(alloc_ctx_tracker);
-}
-
-AllocationContextTracker* AllocationContextTracker::GetThreadLocalTracker() {
-  auto tracker =
-      static_cast<AllocationContextTracker*>(g_tls_alloc_ctx_tracker.Get());
-
-  if (!tracker) {
-    tracker = new AllocationContextTracker();
-    g_tls_alloc_ctx_tracker.Set(tracker);
-  }
-
-  return tracker;
+bool operator==(const Backtrace& lhs, const Backtrace& rhs) {
+  // Pointer equality of the stack frames is assumed, so instead of doing a deep
+  // string comparison on all of the frames, a |memcmp| suffices.
+  return std::memcmp(lhs.frames, rhs.frames, sizeof(lhs.frames)) == 0;
 }
 
 StackFrameDeduplicator::FrameNode::FrameNode(StackFrame frame,
                                              int parent_frame_index)
     : frame(frame), parent_frame_index(parent_frame_index) {}
 StackFrameDeduplicator::FrameNode::~FrameNode() {}
 
 StackFrameDeduplicator::StackFrameDeduplicator() {}
 StackFrameDeduplicator::~StackFrameDeduplicator() {}
 
-int StackFrameDeduplicator::Insert(const AllocationContext::Backtrace& bt) {
+int StackFrameDeduplicator::Insert(const Backtrace& bt) {
   int frame_index = -1;
   std::map<StackFrame, int>* nodes = &roots_;
 
   for (size_t i = 0; i < arraysize(bt.frames); i++) {
     if (!bt.frames[i])
       break;
 
     auto node = nodes->find(bt.frames[i]);
     if (node == nodes->end()) {
       // There is no tree node for this frame yet, create it. The parent node
@@ skipping 14 matching lines @@
       // A tree node for this frame exists. Look for the next one.
       frame_index = node->second;
     }
 
     nodes = &frames_[frame_index].children;
   }
 
   return frame_index;
 }
 
+// This function is added to the TLS slot to clean up the instance when the
+// thread exits.
+void DestructAllocationContextTracker(void* alloc_ctx_tracker) {

[Primiano Tucci (use gerrit), 2015/10/27 11:56:20]

This should be moved perhaps in the anonymous namespace

[Ruud van Asseldonk, 2015/10/27 11:59:31]

Can do when refactoring, other CLs touch this piece too and want to avoid
conflicts.

+  delete static_cast<AllocationContextTracker*>(alloc_ctx_tracker);
+}
+
+AllocationContextTracker* AllocationContextTracker::GetThreadLocalTracker() {
+  auto tracker =
+      static_cast<AllocationContextTracker*>(g_tls_alloc_ctx_tracker.Get());
+
+  if (!tracker) {
+    tracker = new AllocationContextTracker();
+    g_tls_alloc_ctx_tracker.Set(tracker);
+  }
+
+  return tracker;
+}
+
 AllocationContextTracker::AllocationContextTracker() {}
 AllocationContextTracker::~AllocationContextTracker() {}
 
 // static
 void AllocationContextTracker::SetCaptureEnabled(bool enabled) {
   // When enabling capturing, also initialize the TLS slot. This does not create
   // a TLS instance yet.
   if (enabled && !g_tls_alloc_ctx_tracker.initialized())
     g_tls_alloc_ctx_tracker.Initialize(DestructAllocationContextTracker);
 
@@ skipping 72 matching lines @@
     // If there is room for more, fill the remaining slots with nullptr keys.
     for (; dst != dst_end; dst++)
       dst->first = nullptr;
   }
 
   return ctx;
 }
 
 }  // namespace trace_event
 }  // namespace base
+
+namespace BASE_HASH_NAMESPACE {
+using base::trace_event::Backtrace;
+
+uint32_t hash<Backtrace>::operator()(const Backtrace& backtrace) const {
+  return base::SuperFastHash(reinterpret_cast<const char*>(backtrace.frames),
+                             sizeof(backtrace.frames));
+}
+
+}  // BASE_HASH_NAMESPACE