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/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"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/disconnect_window.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/local_input_monitor.h"
 #include "remoting/host/remote_input_filter.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/input_event_tracker.h"
 #include "third_party/skia/include/core/SkRegion.h"
 
+#if defined(OS_POSIX)
+#include "base/file_descriptor_posix.h"

[Sergey Ulanov, 2013/02/04 21:04:41]

nit: don't need #ifdef here - that header should compile on windows too.
Alternatively you can include base/file_util.h

[alexeypa (please no reviews), 2013/02/04 23:45:58]

Done.

+#endif  // defined(OS_POSIX)
+
 namespace remoting {
 
 namespace {
 
 // USB to XKB keycode map table.
 #define USB_KEYMAP(usb, xkb, win, mac) {usb, xkb}
 #include "ui/base/keycodes/usb_keycode_map.h"
 #undef USB_KEYMAP
 
 // Routes local clipboard events though the IPC channel to the network process.
@@ skipping 29 matching lines @@
 }  // namespace
 
 DesktopSessionAgent::Delegate::~Delegate() {
 }
 
 DesktopSessionAgent::~DesktopSessionAgent() {
   DCHECK(!audio_capturer_);
   DCHECK(!disconnect_window_);
   DCHECK(!local_input_monitor_);
   DCHECK(!network_channel_);
+  DCHECK(desktop_pipe_ == IPC::InvalidPlatformFileForTransit());

[Sergey Ulanov, 2013/02/04 21:04:41]

DCHECK_EQ

[alexeypa (please no reviews), 2013/02/04 23:45:58]

Done.

   DCHECK(!video_capturer_);
 }
 
 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,
@@ skipping 24 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() {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  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