Support early associated interface binding on ChannelMojo

ipc/ipc_message_pipe_reader.cc

 // Copyright 2014 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 "ipc/ipc_message_pipe_reader.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 37 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MessageSerializer);
 };
 
 }  // namespace
 
 MessagePipeReader::MessagePipeReader(
     mojo::MessagePipeHandle pipe,
     mojom::ChannelAssociatedPtr sender,
     mojo::AssociatedInterfaceRequest<mojom::Channel> receiver,
-    base::ProcessId peer_pid,
     MessagePipeReader::Delegate* delegate)
     : delegate_(delegate),
-      peer_pid_(peer_pid),
       sender_(std::move(sender)),
       binding_(this, std::move(receiver)),
       sender_interface_id_(sender_.interface_id()),
       sender_pipe_(pipe) {
   sender_.set_connection_error_handler(
       base::Bind(&MessagePipeReader::OnPipeError, base::Unretained(this),
                  MOJO_RESULT_FAILED_PRECONDITION));
   binding_.set_connection_error_handler(
       base::Bind(&MessagePipeReader::OnPipeError, base::Unretained(this),
                  MOJO_RESULT_FAILED_PRECONDITION));
@@ skipping 44 matching lines @@
 }
 
 void MessagePipeReader::GetRemoteInterface(
     const std::string& name,
     mojo::ScopedInterfaceEndpointHandle handle) {
   mojom::GenericInterfaceAssociatedRequest request;
   request.Bind(std::move(handle));
   sender_->GetAssociatedInterface(name, std::move(request));
 }
 
+void MessagePipeReader::SetPeerPid(int32_t peer_pid) {
+  peer_pid_ = peer_pid;
+  delegate_->OnPeerPidReceived();
+}
+
 void MessagePipeReader::Receive(
     mojo::Array<uint8_t> data,
     mojo::Array<mojom::SerializedHandlePtr> handles) {
+  DCHECK_NE(peer_pid_, base::kNullProcessId);
   Message message(
       data.size() == 0 ? "" : reinterpret_cast<const char*>(&data[0]),
       static_cast<uint32_t>(data.size()));
   message.set_sender_pid(peer_pid_);
 
   DVLOG(4) << "Receive " << message.type() << ": " << message.size();
   MojoResult write_result =
       ChannelMojo::WriteToMessageAttachmentSet(std::move(handles), &message);
   if (write_result != MOJO_RESULT_OK) {
     OnPipeError(write_result);
@@ skipping 10 matching lines @@
 void MessagePipeReader::GetAssociatedInterface(
     const mojo::String& name,
     mojom::GenericInterfaceAssociatedRequest request) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (delegate_)
     delegate_->OnAssociatedInterfaceRequest(name, request.PassHandle());
 }
 
 void MessagePipeReader::OnPipeError(MojoResult error) {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  Close();
+
+  // NOTE: The delegate call below may delete |this|.
   if (delegate_)
     delegate_->OnPipeError();
-  Close();
-}
-
-void MessagePipeReader::DelayedDeleter::operator()(
-    MessagePipeReader* ptr) const {
-  ptr->Close();
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                base::Bind(&DeleteNow, ptr));
 }
 
 }  // namespace internal
 }  // namespace IPC