Add out-of-process memory logging stream parsing.

chrome/profiling/memlog_connection_manager.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/memlog_connection_manager.h"
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/threading/thread.h"
+#include "chrome/profiling/allocation_tracker.h"
+#include "chrome/profiling/memlog_stream_parser.h"
+#include "chrome/profiling/profiling_globals.h"
+
+namespace profiling {
+
+struct MemlogConnectionManager::Connection {
+  Connection(AllocationTracker::CompleteCallback complete_cb,
+             int process_id,
+             scoped_refptr<MemlogReceiverPipe> p)
+      : thread(base::StringPrintf("Proc %d thread", process_id)),
+        pipe(p),
+        tracker(std::move(complete_cb)) {}
+
+  ~Connection() {}
+
+  base::Thread thread;
+
+  scoped_refptr<MemlogReceiverPipe> pipe;
+  scoped_refptr<MemlogStreamParser> parser;
+  AllocationTracker tracker;
+};
+
+MemlogConnectionManager::MemlogConnectionManager() {}
+
+MemlogConnectionManager::~MemlogConnectionManager() {
+  // Clear the callback since the server is refcounted and may outlive us.
+  server_->set_on_new_connection(
+      base::RepeatingCallback<void(scoped_refptr<MemlogReceiverPipe>)>());
+}
+
+void MemlogConnectionManager::StartConnections(const std::string& pipe_id) {
+  server_ = new MemlogReceiverPipeServer(
+      ProfilingGlobals::Get()->GetIORunner(), pipe_id,
+      base::BindRepeating(&MemlogConnectionManager::OnNewConnection,
+                          base::Unretained(this)));
+  server_->Start();
+}
+
+void MemlogConnectionManager::OnNewConnection(
+    scoped_refptr<MemlogReceiverPipe> new_pipe) {
+  int remote_process = new_pipe->GetRemoteProcessID();
+
+  // Task to post to clean up the connection. Don't need to retain |this| since
+  // it wil be called by objects owned by the MemlogConnectionManager.
+  AllocationTracker::CompleteCallback complete_cb = base::BindOnce(
+      &MemlogConnectionManager::OnConnectionCompleteThunk,
+      base::Unretained(this), base::MessageLoop::current()->task_runner(),
+      remote_process);
+
+  std::unique_ptr<Connection> connection = base::MakeUnique<Connection>(
+      std::move(complete_cb), remote_process, new_pipe);
+  connection->thread.Start();
+
+  connection->parser = new MemlogStreamParser(&connection->tracker);
+  new_pipe->SetReceiver(connection->thread.task_runner(), connection->parser);
+
+  connections_[remote_process] = std::move(connection);
+}
+
+void MemlogConnectionManager::OnConnectionComplete(int process_id) {
+  auto found = connections_.find(process_id);
+  CHECK(found != connections_.end());
+  connections_.erase(found);
+
+  // When all connections are closed, exit.
+  if (connections_.empty())
+    ProfilingGlobals::Get()->QuitWhenIdle();
+}
+
+// Posts back to the given thread the connection complete message.
+void MemlogConnectionManager::OnConnectionCompleteThunk(
+    scoped_refptr<base::SingleThreadTaskRunner> main_loop,
+    int process_id) {
+  // This code is called by the allocation tracker which is owned by the
+  // connection manager. When we tell the connection manager a connection is
+  // done, we know the conncetion manager will still be in scope.
+  main_loop->PostTask(FROM_HERE,
+                      base::Bind(&MemlogConnectionManager::OnConnectionComplete,
+                                 base::Unretained(this), process_id));
+}
+
+}  // namespace profiling