[Tracing] Introduce HeapDumpWriter helper class

base/trace_event/memory_profiler_heap_dump_writer.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_heap_dump_writer.h"
+
+#include <numeric>
+
+#include "base/format_macros.h"
+#include "base/strings/stringprintf.h"
+#include "base/trace_event/memory_profiler_allocation_register.h"
+
+namespace base {
+namespace trace_event {
+
+namespace {
+
+template <typename T>
+bool PairSizeGt(const std::pair<T, size_t>& lhs,
+                const std::pair<T, size_t>& rhs) {
+  return lhs.second > rhs.second;
+}
+
+template <typename T>
+size_t PairSizeAdd(size_t acc, const std::pair<T, size_t>& rhs) {
+  return acc + rhs.second;
+}
+
+}  // namespace
+
+HeapDumpWriter::HeapDumpWriter(StackFrameDeduplicator* stack_frame_deduplicator)
+    : traced_value_(new TracedValue()),
+      stack_frame_deduplicator_(stack_frame_deduplicator) {}
+HeapDumpWriter::~HeapDumpWriter() {}

[Primiano Tucci (use gerrit), 2015/10/26 20:57:57]

add a blank line before this

[Ruud van Asseldonk, 2015/10/27 10:50:18]

Done.

+
+void HeapDumpWriter::InsertAllocation(const AllocationContext& context,
+                                      size_t size) {
+  bytes_by_backtrace_[context.backtrace] += size;
+}
+
+scoped_refptr<TracedValue> HeapDumpWriter::WriteHeapDump() {
+  // Sort the backtraces by size in descending order.
+  std::vector<std::pair<Backtrace, size_t>> sorted_by_backtrace;
+
+  std::copy(bytes_by_backtrace_.begin(), bytes_by_backtrace_.end(),
+            std::back_inserter(sorted_by_backtrace));
+  std::sort(sorted_by_backtrace.begin(), sorted_by_backtrace.end(),
+            PairSizeGt<Backtrace>);
+
+  traced_value_->BeginArray("heap");
+
+  // The global size, no column specified.
+  {
+    size_t total_size =
+        std::accumulate(sorted_by_backtrace.begin(), sorted_by_backtrace.end(),
+                        size_t(0), PairSizeAdd<Backtrace>);
+    traced_value_->BeginDictionary();
+    WriteSize(total_size);
+    traced_value_->EndDictionary();
+  }
+
+  // Size per backtrace.
+  for (auto bt_sz = sorted_by_backtrace.begin();

[Primiano Tucci (use gerrit), 2015/10/26 20:57:57]

I typically see this as "auto it" in the codebase, to give a hint about the fact
that this ia a iterator.
bt_sz is a bit cryptic :)

[Ruud van Asseldonk, 2015/10/27 10:50:18]

Done. I called it |bt_sz| because iterator dereferences to a (backtrace, size)
pair, though I admit that "bt" and "sz" isn't really helpful if you don't know
that.

+       bt_sz != sorted_by_backtrace.end(); bt_sz++) {
+    traced_value_->BeginDictionary();
+    // Insert a forward reference to the backtrace that will be written to the
+    // |stackFrames| dictionary later on.
+    int bt_index = stack_frame_deduplicator_->Insert(bt_sz->first);
+    traced_value_->SetInteger("bt", bt_index);

[Primiano Tucci (use gerrit), 2015/10/26 20:57:57]

were you not planning to make the indexes strings instead of integers?
I.e. shouldn't this be SetString?

[Ruud van Asseldonk, 2015/10/27 10:50:18]

Yes, I didn't update this one yet. Fixed.

+    WriteSize(bt_sz->second);
+    traced_value_->EndDictionary();
+  }
+
+  traced_value_->EndArray();  // heap
+
+  return traced_value_;
+}
+
+void HeapDumpWriter::WriteSize(size_t size) {
+  // Format size as hexadecimal string into |buffer_|.
+  SStringPrintf(&buffer_, "%" PRIx64, static_cast<uint64_t>(size));
+  traced_value_->SetString("size", buffer_);
+}
+
+}  // namespace trace_event
+}  // namespace base