remoting: Add AttachmentBroker for daemon and desktop processes

remoting/host/win/wts_session_process_delegate.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.
 //
 // This file implements the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/win/wts_session_process_delegate.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
+#include "ipc/attachment_broker.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "remoting/host/host_main.h"
 #include "remoting/host/ipc_constants.h"
 #include "remoting/host/ipc_util.h"
 #include "remoting/host/switches.h"
 #include "remoting/host/win/launch_process_with_token.h"
 #include "remoting/host/win/worker_process_launcher.h"
@@ skipping 204 matching lines @@
   if (channel_) {
     channel_->Send(message);
   } else {
     delete message;
   }
 }
 
 void WtsSessionProcessDelegate::Core::CloseChannel() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
+  if (!channel_)
+    return;
+
+  IPC::AttachmentBroker::GetGlobal()->DeregisterCommunicationChannel(
+      channel_.get());
   channel_.reset();
   pipe_.Close();
 }
 
 void WtsSessionProcessDelegate::Core::KillProcess() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  channel_.reset();
+  CloseChannel();
+
   event_handler_ = nullptr;
   launch_pending_ = false;
-  pipe_.Close();
 
   if (launch_elevated_) {
     if (job_.IsValid())
       TerminateJobObject(job_.Get(), CONTROL_C_EXIT);
   } else {
     if (worker_process_.IsValid())
       TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT);
   }
 
   worker_process_.Close();
@@ skipping 145 matching lines @@
 
   if (!ResumeThread(worker_thread.Get())) {
     PLOG(ERROR) << "Failed to resume the worker thread";
     ReportFatalError();
     return;
   }
 
   channel_ = std::move(channel);
   pipe_ = std::move(pipe);
 
+  IPC::AttachmentBroker::GetGlobal()->RegisterCommunicationChannel(
+      channel_.get());
+
   // Report success if the worker process is lauched directly. Otherwise, PID of
   // the client connected to the pipe will be used later. See
   // OnChannelConnected().
   if (!launch_elevated_)
     ReportProcessLaunched(std::move(worker_process));
 }
 
 void WtsSessionProcessDelegate::Core::DrainJobNotifications() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
@@ skipping 47 matching lines @@
   if (launch_pending_) {
     LOG(ERROR) << "The worker process exited before connecting via IPC.";
     launch_pending_ = false;
     ReportFatalError();
   }
 }
 
 void WtsSessionProcessDelegate::Core::ReportFatalError() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  channel_.reset();
-  pipe_.Close();
+  CloseChannel();
 
   WorkerProcessLauncher* event_handler = event_handler_;
   event_handler_ = nullptr;
   event_handler->OnFatalError();
 }
 
 void WtsSessionProcessDelegate::Core::ReportProcessLaunched(
     base::win::ScopedHandle worker_process) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!worker_process_.IsValid());
@@ skipping 45 matching lines @@
 
 void WtsSessionProcessDelegate::CloseChannel() {
   core_->CloseChannel();
 }
 
 void WtsSessionProcessDelegate::KillProcess() {
   core_->KillProcess();
 }
 
 }  // namespace remoting