Tiny little refactoring of DesktopEnvironment.

remoting/host/desktop_environment.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_ENVIRONMENT_H_
 #define REMOTING_HOST_DESKTOP_ENVIRONMENT_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "remoting/protocol/clipboard_stub.h"
+#include "remoting/protocol/input_stub.h"
+#include "third_party/skia/include/core/SkSize.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}  // namespace base
 
 namespace remoting {
 
-class AudioCapturer;
-class EventExecutor;
-class VideoFrameCapturer;
+class AudioEncoder;
+class VideoEncoder;
 
 namespace protocol {
-class ClipboardStub;
-}
+class AudioStub;
+class CursorShapeStub;
+class VideoStub;
+}  // namespace protocol
 
-class DesktopEnvironment {
+// This interface provides audio/video capturing, input injection and clipboard
+// handling capatilities utilized by ClientSession. All public methods of
+// DesktopEnvironment must be called on the network thread.
+class DesktopEnvironment
+    : public protocol::ClipboardStub,
+      public protocol::InputStub {
  public:
-  DesktopEnvironment(scoped_ptr<AudioCapturer> audio_capturer,
-                     scoped_ptr<EventExecutor> event_executor,
-                     scoped_ptr<VideoFrameCapturer> video_capturer);
-  virtual ~DesktopEnvironment();
+  DesktopEnvironment() {}
+  virtual ~DesktopEnvironment() {}
 
-  AudioCapturer* audio_capturer() const { return audio_capturer_.get(); }
-  EventExecutor* event_executor() const { return event_executor_.get(); }
-  VideoFrameCapturer* video_capturer() const { return video_capturer_.get(); }
+  // Starts recording audio. Recorded audio packets are ecoded by
+  // |audio_encoder| and passed to |audio_stub|. |audio_stub| must outlive
+  // |this|.
+  virtual void StartAudio(
+      scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
+      scoped_ptr<AudioEncoder> audio_encoder,
+      protocol::AudioStub* audio_stub) = 0;
 
-  // Starts the desktop environment passing |client_jid| of the attached
-  // authenticated session. Registers |client_clipboard| to receive
-  // notifications about local clipboard changes. |disconnect_callback| can be
-  // invoked by the DesktopEnvironment to request the client session to be
-  // disconnected. |disconnect_callback| is invoked on the same thread Start()
-  // has been called on.
-  virtual void Start(
-      scoped_ptr<protocol::ClipboardStub> client_clipboard,
-      const std::string& client_jid,
-      const base::Closure& disconnect_callback);
+  // Enable or disable audio on a running session.
+  // This leaves the audio capturer running, and only affects whether or not the
+  // captured audio is encoded and sent on the wire.
+  virtual void PauseAudio(bool pause) = 0;
+
+  // Starts input injection and registers |clipboard_stub| to receive local
+  // clipboard updates. |clipboard_stub| must outlive |this|.
+  virtual void StartInput(
+      scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+      protocol::ClipboardStub* clipboard_stub) = 0;
+
+  // Starts capturing video frames and track cursor share updates. Captured
+  // video frames are encoded by |video_encoder| and passed to |video_stub|.
+  // |cursor_shape_stub| will be notified about cursor shape changes. Both
+  // |cursor_shape_stub| and |video_stub| must outlive |this|.
+  virtual void StartVideo(
+      scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
+      scoped_ptr<VideoEncoder> video_encoder,
+      protocol::CursorShapeStub* cursor_shape_stub,
+      protocol::VideoStub* video_stub) = 0;
+
+  // Returns the screen size for the most recently captured video frame.
+  virtual SkISize GetScreenSize() const = 0;
+
+  // Pauses or resumes scheduling of frame captures. Pausing/resuming captures
+  // only affects capture scheduling and does not stop/start the capturer.
+  virtual void PauseVideo(bool pause) = 0;
+
+  // Updates the sequence number (used for performance measurements) embedded in
+  // VideoPackets.
+  virtual void UpdateSequenceNumber(int64 sequence_number) = 0;
 
  private:
-  // Used to capture audio to deliver to clients.
-  scoped_ptr<AudioCapturer> audio_capturer_;
-
-  // Executes input and clipboard events received from the client.
-  scoped_ptr<EventExecutor> event_executor_;
-
-  // Used to capture video to deliver to clients.
-  scoped_ptr<VideoFrameCapturer> video_capturer_;
-
   DISALLOW_COPY_AND_ASSIGN(DesktopEnvironment);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_DESKTOP_ENVIRONMENT_H_