The worker process launcher can now ask the worker to crash.

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 "base/bind.h"
@@ skipping 44 matching lines @@
 
   // base::MessagePumpForIO::IOHandler implementation.
   virtual void OnIOCompleted(base::MessagePumpForIO::IOContext* context,
                              DWORD bytes_transferred,
                              DWORD error) OVERRIDE;
 
   // IPC::Sender implementation.
   virtual bool Send(IPC::Message* message) OVERRIDE;
 
   // WorkerProcessLauncher::Delegate implementation.
+  virtual void CloseChannel() OVERRIDE;
   virtual DWORD GetProcessId() const OVERRIDE;
   virtual bool IsPermanentError(int failure_count) const OVERRIDE;
   virtual void KillProcess(DWORD exit_code) OVERRIDE;
   virtual bool LaunchProcess(
       IPC::Listener* delegate,
       base::win::ScopedHandle* process_exit_event_out) OVERRIDE;
 
   // Initializes the object returning true on success.
   bool Initialize(uint32 session_id);
 
@@ skipping 91 matching lines @@
   // |bytes_transferred| is used in job object notifications to supply
   // the message ID; |context| carries process ID.
   main_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Core::OnJobNotification, this, bytes_transferred,
       reinterpret_cast<DWORD>(context)));
 }
 
 bool WtsSessionProcessDelegate::Core::Send(IPC::Message* message) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
-  if (channel_.get()) {
+  if (channel_) {
     return channel_->Send(message);
   } else {
     delete message;
     return false;
   }
 }
 
+void WtsSessionProcessDelegate::Core::CloseChannel() {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+
+  channel_.reset();
+  pipe_.Close();
+}
+
 DWORD WtsSessionProcessDelegate::Core::GetProcessId() const {
   DWORD pid = 0;
   if (launch_elevated_ && pipe_.IsValid() &&
       get_named_pipe_client_pid_(pipe_, &pid)) {
     return pid;
   }
 
   if (worker_process_.IsValid())
     return ::GetProcessId(worker_process_);
 
@@ skipping 295 matching lines @@
   if (core_) {
     core_->Stop();
     core_ = NULL;
   }
 }
 
 bool WtsSessionProcessDelegate::Send(IPC::Message* message) {
   return core_->Send(message);
 }
 
+void WtsSessionProcessDelegate::CloseChannel() {
+  if (core_)
+    core_->CloseChannel();
+}
+
 DWORD WtsSessionProcessDelegate::GetProcessId() const {
   if (!core_)
     return 0;
 
   return core_->GetProcessId();
 }
 
 bool WtsSessionProcessDelegate::IsPermanentError(int failure_count) const {
   if (!core_)
     return false;
 
   return core_->IsPermanentError(failure_count);
 }
 
 void WtsSessionProcessDelegate::KillProcess(DWORD exit_code) {
   if (core_)
     core_->KillProcess(exit_code);
 }
 
 bool WtsSessionProcessDelegate::LaunchProcess(
     IPC::Listener* delegate,
     base::win::ScopedHandle* process_exit_event_out) {
   if (!core_)
     return false;
 
   return core_->LaunchProcess(delegate, process_exit_event_out);
 }
 
 } // namespace remoting