[Tracing] Introduce HeapDumpWriter helper class

base/trace_event/memory_profiler_allocation_context.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_MEMORY_PROFILER_ALLOCATION_CONTEXT_H_
 #define BASE_TRACE_EVENT_MEMORY_PROFILER_ALLOCATION_CONTEXT_H_
 
 #include <vector>
 
 #include "base/atomicops.h"
@@ skipping 51 matching lines @@
 // The number of stack frames stored in the backtrace is a trade off between
 // memory used for tracing and accuracy. Measurements done on a prototype
 // revealed that:
 //
 // - In 60 percent of the cases, stack depth <= 7.
 // - In 87 percent of the cases, stack depth <= 9.
 // - In 95 percent of the cases, stack depth <= 11.
 //
 // See the design doc (https://goo.gl/4s7v7b) for more details.
 
-// The allocation context is context metadata that is kept for every allocation
-// when heap profiling is enabled. To simplify memory management for
-// bookkeeping, this struct has a fixed size. All |const char*|s here
-// must have static lifetime.
-struct BASE_EXPORT AllocationContext {
-  struct Backtrace {
-    // Unused backtrace frames are filled with nullptr frames. If the stack is
-    // higher than what can be stored here, the bottom frames are stored. Based
-    // on the data above, a depth of 12 captures the full stack in the vast
-    // majority of the cases.
-    StackFrame frames[12];
-  } backtrace;
+struct BASE_EXPORT Backtrace {
+  // Unused backtrace frames are filled with nullptr frames. If the stack is
+  // higher than what can be stored here, the bottom frames are stored. Based
+  // on the data above, a depth of 12 captures the full stack in the vast
+  // majority of the cases.
+  StackFrame frames[12];
+};
 
-  // There is room for two arbitrary context fields, which can be set by the
-  // |TRACE_ALLOCATION_CONTEXT| macro. A nullptr key indicates that the field is
-  // unused.
-  std::pair<const char*, const char*> fields[2];
-};
+bool BASE_EXPORT operator==(const Backtrace& lhs, const Backtrace& rhs);
 
 // A data structure that allows grouping a set of backtraces in a space-
 // efficient manner by creating a call tree and writing it as a set of (node,
 // parent) pairs. The tree nodes reference both parent and children. The parent
 // is referenced by index into |frames_|. The children are referenced via a map
 // of |StackFrame|s to index into |frames_|. So there is a trie for bottum-up
 // lookup of a backtrace for deduplication, and a tree for compact storage in
 // the trace log.
 class BASE_EXPORT StackFrameDeduplicator {
  public:
@@ skipping 10 matching lines @@
 
     // Indices into |frames_| of frames called from the current frame.
     std::map<StackFrame, int> children;
   };
 
   using ConstIterator = std::vector<FrameNode>::const_iterator;
 
   StackFrameDeduplicator();
   ~StackFrameDeduplicator();
 
-  // Inserts a backtrace and returns the index of its leaf node in the range
-  // defined by |begin| and |end|. I.e. if this returns |n|, the node is
-  // |begin() + n|. Returns -1 if the backtrace is empty.
-  int Insert(const AllocationContext::Backtrace& bt);
+  // Inserts a backtrace and returns the index of its leaf node in |frames_|.
+  // Returns -1 if the backtrace is empty.
+  int Insert(const Backtrace& bt);
 
   // Iterators over the frame nodes in the call tree.
   ConstIterator begin() const { return frames_.begin(); }
   ConstIterator end() const { return frames_.end(); }
 
  private:
   std::map<StackFrame, int> roots_;
   std::vector<FrameNode> frames_;
 
   DISALLOW_COPY_AND_ASSIGN(StackFrameDeduplicator);
 };
 
+// The |AllocationContext| is context metadata that is kept for every allocation
+// when heap profiling is enabled. To simplify memory management for
+// bookkeeping, this struct has a fixed size. All |const char*|s here
+// must have static lifetime.
+struct BASE_EXPORT AllocationContext {
+  Backtrace backtrace;
+
+  // There is room for two arbitrary context fields, which can be set by the
+  // |TRACE_ALLOCATION_CONTEXT| macro. A nullptr key indicates that the field is
+  // unused.
+  std::pair<const char*, const char*> fields[2];
+};
+
 // The allocation context tracker keeps track of thread-local context for heap
 // profiling. It includes a pseudo stack of trace events, and it might contain
 // arbitrary (key, value) context. On every allocation the tracker provides a
 // snapshot of its context in the form of an |AllocationContext| that is to be
 // stored together with the allocation details.
 class BASE_EXPORT AllocationContextTracker {
  public:
   // Globally enables capturing allocation context.
   // TODO(ruuda): Should this be replaced by |EnableCapturing| in the future?
   // Or at least have something that guards agains enable -> disable -> enable?
@@ skipping 44 matching lines @@
 
   // A dictionary of arbitrary context.
   SmallMap<std::map<const char*, const char*>> context_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationContextTracker);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
+namespace BASE_HASH_NAMESPACE {
+
+template <>
+struct hash<base::trace_event::Backtrace> {
+  size_t operator()(const base::trace_event::Backtrace& backtrace) const;
+};
+
+}  // BASE_HASH_NAMESPACE
+
 #endif  // BASE_TRACE_EVENT_MEMORY_PROFILER_ALLOCATION_CONTEXT_H_