[Tracing] Enable heap dumps with both type info and backtraces

base/trace_event/heap_profiler_heap_dump_writer.h

Index: base/trace_event/heap_profiler_heap_dump_writer.h
diff --git a/base/trace_event/heap_profiler_heap_dump_writer.h b/base/trace_event/heap_profiler_heap_dump_writer.h
index c3a776739973b270d6c34f9d4bca8c0806ec8a07..1213f1ccaa283a34e40ac6bb3e46817109ed6366 100644
--- a/base/trace_event/heap_profiler_heap_dump_writer.h
+++ b/base/trace_event/heap_profiler_heap_dump_writer.h
@@ -5,7 +5,7 @@
 #ifndef BASE_TRACE_EVENT_HEAP_PROFILER_HEAP_DUMP_WRITER_H_
 #define BASE_TRACE_EVENT_HEAP_PROFILER_HEAP_DUMP_WRITER_H_
 
-#include <string>
+#include <set>
 
 #include "base/base_export.h"
 #include "base/containers/hash_tables.h"
@@ -20,42 +20,68 @@ class StackFrameDeduplicator;
 class TracedValue;
 class TypeNameDeduplicator;
 
+namespace {
+struct Bucket;
+}
+
 // Helper class to dump a snapshot of an |AllocationRegister| or other heap
 // bookkeeping structure into a |TracedValue|. This class is intended to be
 // used as a one-shot local instance on the stack. To write heap dumps, call
-// |InsertAllocation| for every captured allocation, then call |WriteHeapDump|
-// to do the processing and generate a heap dump value for the trace log.
+// |InsertAllocation| for every captured allocation, then call |Dump| to do
+// the processing, and pass its return value to |Write| to get a |TracedValue|
+// that can be dumped into the trace log.
 class BASE_EXPORT HeapDumpWriter {
  public:
+  // An entry in the "entries" array as described in https://goo.gl/KY7zVE.
+  struct Entry {
+    size_t size;
+
+    // References a backtrace in the stack frame deduplicator. -1 means empty
+    // backtrace (the root of the tree).
+    int stack_frame_id;
+
+    // References a type name in the type name deduplicator. -1 indicates that
+    // the size is the cumulative size for all types (the root of the tree).
+    int type_id;
+  };
+
   // The |StackFrameDeduplicator| and |TypeNameDeduplicator| are not owned. The
   // heap dump writer assumes exclusive access to them during the lifetime of
   // the dump writer.
   HeapDumpWriter(StackFrameDeduplicator* stack_frame_deduplicator,
                  TypeNameDeduplicator* type_name_deduplicator);
+
   ~HeapDumpWriter();
 
   // Inserts information from which the heap dump will be generated. This method
   // does minimal processing, so it can be called when a lock is held.
   void InsertAllocation(const AllocationContext& context, size_t size);
 
-  // Aggregates allocations and writes an "entries" array to a traced value. See
-  // https://goo.gl/jYN4Zn for a description of the format.
-  scoped_refptr<TracedValue> WriteHeapDump();
+  // Aggregates allocations to compute the total size of the heap, then breaks
+  // down the heap recursively. This produces the values that should be dumped
+  // in the "entries" array. The number of entries is kept reasonable because
+  // long tails are not included. Use |Write| to convert to a traced value.
+  const std::set<Entry>& Dump();

[Primiano Tucci (use gerrit), 2015/12/08 18:05:30]

I understand this is for testability, but I'd like to see here only the method
that make sense for this class (GetHeapDump that returns a TracedValue). You can
make this a private method used internally and friend the test.

[Ruud van Asseldonk, 2015/12/09 14:07:53]

Obsolete now. I put it in a namespace instead.

+
+  // Writes an "entries" array to a traced value. See https://goo.gl/KY7zVE for
+  // a description of the format.
+  static scoped_refptr<TracedValue> Write(const std::set<Entry>& dump);

[Primiano Tucci (use gerrit), 2015/12/08 18:05:30]

and obviously drop (privatize) this

[Ruud van Asseldonk, 2015/12/09 14:07:54]

Obsolete now.

 
  private:
-  // Writes a "bt" key that references a stack frame in the |stackFrames|
-  // dictionary.
-  void WriteStackFrameIndex(int index);
+  // Inserts an |Entry| for |Bucket| into |entries_|. Returns false if the
+  // entry was present before, true if it was not.
+  bool InsertEntry(const Bucket& bucket);
 
-  // Writes a "type" key with the stringified type ID.
-  void WriteTypeId(int type_id);
+  // Recursively breaks down a bucket into smaller buckets and adds entries for
+  // the buckets worth dumping to |entries_|.
+  void BreakDown(const Bucket& bucket);
 
-  // Writes a "size" key with value |size| as a hexidecimal string to the traced
-  // value.
-  void WriteSize(size_t size);
+  // A map map from allocation context to the number of bytes allocated for that
+  // context.
+  hash_map<AllocationContext, size_t> bytes_by_context_;
 
-  // The value that this heap dumper writes to.
-  const scoped_refptr<TracedValue> traced_value_;
+  // The collection of entries that is filled by |Dump|.
+  std::set<Entry> entries_;
 
   // Helper for generating the |stackFrames| dictionary. Not owned, must outlive
   // this heap dump writer instance.
@@ -65,17 +91,13 @@ class BASE_EXPORT HeapDumpWriter {
   // dump writer instance.
   TypeNameDeduplicator* const type_name_deduplicator_;
 
-  // A map of allocation context to the number of bytes allocated for that
-  // context.
-  hash_map<AllocationContext, size_t> bytes_by_context_;
-
-  // Buffer for converting integers into strings, that is re-used throughout the
-  // dump.
-  std::string buffer_;
-
   DISALLOW_COPY_AND_ASSIGN(HeapDumpWriter);
 };
 
+// Comparison operator to enable putting |Entry| in a |std::set|.
+BASE_EXPORT bool operator<(HeapDumpWriter::Entry lhs,
+                           HeapDumpWriter::Entry rhs);
+
 }  // namespace trace_event
 }  // namespace base