Add pipe implementation for OOP memory logging

chrome/profiling/memlog_receiver_pipe_server_win.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_receiver_pipe_server_win.h"
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/common/profiling/memlog_stream.h"
+
+namespace profiling {
+
+namespace {
+
+// Use a large buffer for our pipe. We don't want the sender to block
+// if at all possible since it will slow the app down quite a bit. Windows
+// seemed to max out a 64K per read when testing larger sizes, so use that.
+const int kBufferSize = 1024 * 64;
+
+}  // namespace
+
+MemlogReceiverPipeServer::MemlogReceiverPipeServer(
+    base::TaskRunner* io_runner,
+    const std::string& pipe_id,
+    NewConnectionCallback on_new_conn)
+    : io_runner_(io_runner),
+      pipe_id_(base::ASCIIToUTF16(pipe_id)),
+      on_new_connection_(on_new_conn) {}
+
+MemlogReceiverPipeServer::~MemlogReceiverPipeServer() {
+  // TODO(brettw) we should ensure this destructor is not called when there are
+  // pending I/O operations as per RegisterIOHandler documentation.
+}
+
+void MemlogReceiverPipeServer::Start() {
+  // TODO(brettw) this should perhaps not be async in case the subprocess
+  // launches and tries to connect before the first pipe instance is created.
+  io_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&MemlogReceiverPipeServer::ScheduleNewConnection, this, true));
+}
+
+base::string16 MemlogReceiverPipeServer::GetPipeName() const {
+  base::string16 pipe_name(kWindowsPipePrefix);
+  pipe_name.append(pipe_id_);
+  return pipe_name;
+}
+
+HANDLE MemlogReceiverPipeServer::CreatePipeInstance(bool first_instance) const {
+  base::string16 pipe_name = GetPipeName();
+
+  DWORD open_mode = PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED;
+  if (first_instance)
+    open_mode |= FILE_FLAG_FIRST_PIPE_INSTANCE;
+
+  return ::CreateNamedPipe(
+      pipe_name.c_str(), open_mode, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
+      PIPE_UNLIMITED_INSTANCES, kBufferSize, kBufferSize, 5000, NULL);
+}
+
+void MemlogReceiverPipeServer::ScheduleNewConnection(bool first_instance) {
+  DCHECK(!current_);
+  // Need Unretained to avoid creating a reference cycle.
+  current_ = base::MakeUnique<MemlogReceiverPipe::CompletionThunk>(
+      CreatePipeInstance(first_instance),
+      base::BindRepeating(&MemlogReceiverPipeServer::OnIOCompleted,
+                          base::Unretained(this)));
+  ::ConnectNamedPipe(current_->handle(), current_->overlapped());
+}
+
+void MemlogReceiverPipeServer::OnIOCompleted(size_t bytes_transfered,
+                                             DWORD error) {
+  scoped_refptr<MemlogReceiverPipe> pipe(
+      new MemlogReceiverPipe(std::move(current_)));
+  ScheduleNewConnection(false);
+
+  if (!on_new_connection_.is_null())
+    on_new_connection_.Run(pipe);
+  pipe->StartReadingOnIOThread();
+}
+
+}  // namespace profiling