Use ChannelMojo between the remoting network and desktop processes.

remoting/host/desktop_session_agent.cc

 // Copyright (c) 2012 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 "remoting/host/desktop_session_agent.h"
 
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/process_handle.h"
 #include "build/build_config.h"
-#include "ipc/attachment_broker.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/input_injector.h"
 #include "remoting/host/ipc_util.h"
@@ skipping 173 matching lines @@
   }
 
   CHECK(handled) << "Received unexpected IPC type: " << message.type();
   return handled;
 }
 
 void DesktopSessionAgent::OnChannelConnected(int32_t peer_pid) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   VLOG(1) << "IPC: desktop <- network (" << peer_pid << ")";
-
-  desktop_pipe_.Close();
 }
 
 void DesktopSessionAgent::OnChannelError() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Make sure the channel is closed.
-  if (IPC::AttachmentBroker::GetGlobal()) {
-    IPC::AttachmentBroker::GetGlobal()->DeregisterCommunicationChannel(
-        network_channel_.get());
-  }
   network_channel_.reset();
-  desktop_pipe_.Close();
 
   // Notify the caller that the channel has been disconnected.
   if (delegate_.get())
     delegate_->OnNetworkProcessDisconnected();
 }
 
 DesktopSessionAgent::~DesktopSessionAgent() {
   DCHECK(!audio_capturer_);
   DCHECK(!desktop_environment_);
   DCHECK(!network_channel_);
@@ skipping 149 matching lines @@
   std::string serialized_packet;
   if (!packet->SerializeToString(&serialized_packet)) {
     LOG(ERROR) << "Failed to serialize AudioPacket.";
     return;
   }
 
   SendToNetwork(base::MakeUnique<ChromotingDesktopNetworkMsg_AudioPacket>(
       serialized_packet));
 }
 
-bool DesktopSessionAgent::Start(const base::WeakPtr<Delegate>& delegate,
-                                IPC::PlatformFileForTransit* desktop_pipe_out) {
+mojo::ScopedMessagePipeHandle DesktopSessionAgent::Start(
+    const base::WeakPtr<Delegate>& delegate) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(delegate_.get() == nullptr);
 
   delegate_ = delegate;
 
-  // Create an IPC channel to communicate with the network process.
-  bool result = CreateConnectedIpcChannel(io_task_runner_,
-                                          this,
-                                          &desktop_pipe_,
-                                          &network_channel_);
-  base::PlatformFile raw_desktop_pipe = desktop_pipe_.GetPlatformFile();
-#if defined(OS_WIN)
-  *desktop_pipe_out =
-      IPC::PlatformFileForTransit(raw_desktop_pipe, base::GetCurrentProcId());
-#elif defined(OS_POSIX)
-  *desktop_pipe_out = IPC::PlatformFileForTransit(raw_desktop_pipe, false);
-#else
-#error Unsupported platform.
-#endif
-  return result;
+  mojo::MessagePipe pipe;
+  network_channel_ = IPC::ChannelProxy::Create(
+      pipe.handle0.release(), IPC::Channel::MODE_SERVER, this, io_task_runner_);
+  return std::move(pipe.handle1);
 }
 
 void DesktopSessionAgent::Stop() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   delegate_.reset();
 
   // Make sure the channel is closed.
-  if (IPC::AttachmentBroker::GetGlobal()) {
-    IPC::AttachmentBroker::GetGlobal()->DeregisterCommunicationChannel(
-        network_channel_.get());
-  }
   network_channel_.reset();
 
   if (started_) {
     started_ = false;
 
     // Ignore any further callbacks.
     weak_factory_.InvalidateWeakPtrs();
     client_jid_.clear();
 
     remote_input_filter_.reset();
@@ skipping 143 matching lines @@
   }
 }
 
 void DesktopSessionAgent::StopAudioCapturer() {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   audio_capturer_.reset();
 }
 
 }  // namespace remoting