Adding a unit test to verify the IPC channel between the 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 "base/file_util.h"
 #include "base/logging.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "media/video/capture/screen/screen_capture_data.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/util.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
@@ skipping 52 matching lines @@
 
 DesktopSessionAgent::Delegate::~Delegate() {
 }
 
 DesktopSessionAgent::~DesktopSessionAgent() {
   DCHECK(!audio_capturer_);
   DCHECK(!disconnect_window_);
   DCHECK(!local_input_monitor_);
   DCHECK(!network_channel_);
   DCHECK(!video_capturer_);
+
+  CloseDesktopPipeHandle();
 }
 
 bool DesktopSessionAgent::OnMessageReceived(const IPC::Message& message) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   bool handled = true;
   if (started_) {
     IPC_BEGIN_MESSAGE_MAP(DesktopSessionAgent, message)
       IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_CaptureFrame,
                           OnCaptureFrame)
@@ skipping 23 matching lines @@
     OnChannelError();
   }
 
   return handled;
 }
 
 void DesktopSessionAgent::OnChannelConnected(int32 peer_pid) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   VLOG(1) << "IPC: desktop <- network (" << peer_pid << ")";
+
+  CloseDesktopPipeHandle();
 }
 
 void DesktopSessionAgent::OnChannelError() {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   // Make sure the channel is closed.
   network_channel_.reset();
+  CloseDesktopPipeHandle();
 
   // Notify the caller that the channel has been disconnected.
   if (delegate_.get())
     delegate_->OnNetworkProcessDisconnected();
 }
 
 void DesktopSessionAgent::OnLocalMouseMoved(const SkIPoint& new_pos) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   remote_input_filter_->LocalMouseMoved(new_pos);
@@ skipping 147 matching lines @@
 }
 
 bool DesktopSessionAgent::Start(const base::WeakPtr<Delegate>& delegate,
                                 IPC::PlatformFileForTransit* desktop_pipe_out) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
   DCHECK(delegate_.get() == NULL);
 
   delegate_ = delegate;
 
   // Create an IPC channel to communicate with the network process.
-  return CreateChannelForNetworkProcess(desktop_pipe_out, &network_channel_);
+  bool result = CreateChannelForNetworkProcess(&desktop_pipe_,
+                                               &network_channel_);
+  *desktop_pipe_out = desktop_pipe_;
+  return result;
 }
 
 void DesktopSessionAgent::Stop() {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   delegate_.reset();
 
   // Make sure the channel is closed.
   network_channel_.reset();
 
@@ skipping 214 matching lines @@
     scoped_refptr<AutoThreadTaskRunner> audio_capture_task_runner,
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> input_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     scoped_refptr<AutoThreadTaskRunner> video_capture_task_runner)
     : audio_capture_task_runner_(audio_capture_task_runner),
       caller_task_runner_(caller_task_runner),
       input_task_runner_(input_task_runner),
       io_task_runner_(io_task_runner),
       video_capture_task_runner_(video_capture_task_runner),
+      desktop_pipe_(IPC::InvalidPlatformFileForTransit()),
       current_size_(SkISize::Make(0, 0)),
       next_shared_buffer_id_(1),
       started_(false) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
+void DesktopSessionAgent::CloseDesktopPipeHandle() {
+  if (!(desktop_pipe_ == IPC::InvalidPlatformFileForTransit())) {
+#if defined(OS_WIN)
+    base::ClosePlatformFile(desktop_pipe_);
+#elif defined(OS_POSIX)
+    base::ClosePlatformFile(desktop_pipe_.fd);
+#else  // !defined(OS_POSIX)
+#error Unsupported platform.
+#endif  // !defined(OS_POSIX)
+
+    desktop_pipe_ = IPC::InvalidPlatformFileForTransit();
+  }
+}
+
 }  // namespace remoting