Add out-of-process memory logging stream parsing.

chrome/profiling/allocation_tracker.cc

+// Copyright 2017 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 "chrome/profiling/allocation_tracker.h"
+
+#include "base/callback.h"
+#include "chrome/profiling/profiling_globals.h"
+#include "chrome/profiling/stack_storage.h"
+
+namespace profiling {
+
+AllocationTracker::Alloc::Alloc(size_t sz, StackStorage::Key key)
+    : size(sz), stack_key(key) {}
+
+AllocationTracker::AllocationTracker(CompleteCallback complete_cb)
+    : complete_callback_(std::move(complete_cb)),
+      stack_storage_(ProfilingGlobals::Get()->GetStackStorage()) {}
+
+AllocationTracker::~AllocationTracker() {
+  std::vector<StackStorage::Key> to_free;
+  to_free.reserve(live_allocs_.size());
+  for (const auto& cur : live_allocs_)
+    to_free.push_back(cur.second.stack_key);
+  stack_storage_->Free(to_free);
+}
+
+void AllocationTracker::OnHeader(const StreamHeader& header) {}
+
+void AllocationTracker::OnAlloc(const AllocPacket& alloc_packet,
+                                Stack&& stack) {

[awong, 2017/06/19 20:00:13]

r-value reference? Why not by copy?

[brettw, 2017/06/19 23:29:45]

I assume you mean by value. I didn't want to have the caller accidentally copy
stacks. Stacks in this component are not something that should be copied,
they're passed from the parser to the tracker, and then inserted into the
StackStorage object. Normally one would do by-value to allow the caller to
decide whether it wants to move or give you a copy (I usually do this as per the
comment where Boris asked me to do the opposite thing).

+  StackStorage::Key stack_key = stack_storage_->Insert(std::move(stack));
+
+  live_allocs_.emplace(Address(alloc_packet.address),
+                       Alloc(alloc_packet.size, stack_key));
+}
+
+void AllocationTracker::OnFree(const FreePacket& free_packet) {
+  auto found = live_allocs_.find(Address(free_packet.address));
+  if (found != live_allocs_.end()) {
+    stack_storage_->Free(found->second.stack_key);
+    live_allocs_.erase(found);
+  }
+}
+
+void AllocationTracker::OnComplete() {
+  std::move(complete_callback_).Run();
+  // Danger: object may be deleted now.
+}
+
+}  // namespace profiling