Adding a unit test to verify the IPC channel between the network and desktop processes.

remoting/host/desktop_session_proxy.h

 // 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.
 
 #ifndef REMOTING_HOST_DESKTOP_SESSION_PROXY_H_
 #define REMOTING_HOST_DESKTOP_SESSION_PROXY_H_
 
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/process.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_platform_file.h"
 #include "media/video/capture/screen/screen_capturer.h"
 #include "media/video/capture/screen/shared_buffer.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "third_party/skia/include/core/SkRegion.h"
 
-#if defined(OS_WIN)
-#include "base/win/scoped_handle.h"
-#endif
-
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace IPC {
 class ChannelProxy;
 class Message;
 }  // namespace IPC
 
 struct SerializedCapturedData;
 
 namespace remoting {
 
 class AudioPacket;
 class ClientSession;
 class IpcAudioCapturer;
 class IpcVideoFrameCapturer;
 
 // This class routes calls to the DesktopEnvironment's stubs though the IPC
 // channel to the DesktopSessionAgent instance running in the desktop
 // integration process.
 class DesktopSessionProxy
     : public base::RefCountedThreadSafe<DesktopSessionProxy>,
       public IPC::Listener {
  public:
   DesktopSessionProxy(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       const std::string& client_jid,
       const base::Closure& disconnect_callback);
 
   // Mirrors DesktopEnvironment.
   scoped_ptr<AudioCapturer> CreateAudioCapturer(
       scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner);
   scoped_ptr<EventExecutor> CreateEventExecutor(
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
   scoped_ptr<media::ScreenCapturer> CreateVideoCapturer(
       scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner);
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
   virtual void OnChannelError() OVERRIDE;
 
   // Connects to the desktop session agent.
-  bool AttachToDesktop(IPC::PlatformFileForTransit desktop_process,
+  bool AttachToDesktop(base::ProcessHandle desktop_process,
                        IPC::PlatformFileForTransit desktop_pipe);
 
   // Closes the connection to the desktop session agent and cleans up
   // the associated resources.
   void DetachFromDesktop();
 
   // Disconnects the client session that owns |this|.
   void DisconnectSession();
 
   // Stores |audio_capturer| to be used to post captured audio packets.
@@ skipping 67 matching lines @@
   // deleted if the channel is broken.
   void SendToDesktop(IPC::Message* message);
 
   // Task runner on which methods of |audio_capturer_| will be invoked.
   scoped_refptr<base::SingleThreadTaskRunner> audio_capture_task_runner_;
 
   // Task runner on which public methods of this class should be called (unless
   // it is documented otherwise).
   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
+  // Task runner used for running background I/O.
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+
   // Task runner on which methods of |video_capturer_| will be invoked.
   scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner_;
 
   // Points to the audio capturer receiving captured audio packets.
   IpcAudioCapturer* audio_capturer_;
 
   // Points to the client stub passed to StartEventExecutor().
   scoped_ptr<protocol::ClipboardStub> client_clipboard_;
 
   // JID of the client session.
   std::string client_jid_;
 
   // IPC channel to the desktop session agent.
   scoped_ptr<IPC::ChannelProxy> desktop_channel_;
 
   // Disconnects the client session when invoked.
   base::Closure disconnect_callback_;
 
-#if defined(OS_WIN)
   // Handle of the desktop process.
-  base::win::ScopedHandle desktop_process_;
-#endif  // defined(OS_WIN)
+  base::ProcessHandle desktop_process_;
 
   int pending_capture_frame_requests_;
 
   typedef std::map<int, scoped_refptr<media::SharedBuffer> > SharedBuffers;
   SharedBuffers shared_buffers_;
 
   // Points to the video capturer receiving captured video frames.
   IpcVideoFrameCapturer* video_capturer_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopSessionProxy);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_DESKTOP_SESSION_PROXY_H_