Add VideoStream interface.

remoting/host/client_session.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_CLIENT_SESSION_H_
 #define REMOTING_HOST_CLIENT_SESSION_H_
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "remoting/host/client_session_control.h"
 #include "remoting/host/gnubby_auth_handler.h"
 #include "remoting/host/host_extension_session_manager.h"
-#include "remoting/host/mouse_clamping_filter.h"
 #include "remoting/host/remote_input_filter.h"
 #include "remoting/protocol/clipboard_echo_filter.h"
 #include "remoting/protocol/clipboard_filter.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_event_tracker.h"
 #include "remoting/protocol/input_filter.h"
 #include "remoting/protocol/input_stub.h"
+#include "remoting/protocol/mouse_input_filter.h"
 #include "remoting/protocol/pairing_registry.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace remoting {
 
 class AudioPump;
 class DesktopEnvironment;
 class DesktopEnvironmentFactory;
 class InputInjector;
 class MouseShapePump;
 class ScreenControls;
 
-namespace protocol {
-class VideoFramePump;
-}  // namespace protocol
-
 // A ClientSession keeps a reference to a connection to a client, and maintains
 // per-client state.
 class ClientSession
     : public base::NonThreadSafe,
       public protocol::HostStub,
       public protocol::ConnectionToClient::EventHandler,
       public ClientSessionControl {
  public:
   // Callback interface for passing events to the ChromotingHost.
   class EventHandler {
@@ skipping 58 matching lines @@
 
   // protocol::ConnectionToClient::EventHandler interface.
   void OnConnectionAuthenticating(
       protocol::ConnectionToClient* connection) override;
   void OnConnectionAuthenticated(
       protocol::ConnectionToClient* connection) override;
   void OnConnectionChannelsConnected(
       protocol::ConnectionToClient* connection) override;
   void OnConnectionClosed(protocol::ConnectionToClient* connection,
                           protocol::ErrorCode error) override;
+  void OnCreateVideoEncoder(scoped_ptr<VideoEncoder>* encoder) override;
   void OnInputEventReceived(protocol::ConnectionToClient* connection,
                             int64_t timestamp) override;
   void OnRouteChange(protocol::ConnectionToClient* connection,
                      const std::string& channel_name,
                      const protocol::TransportRoute& route) override;
 
   // ClientSessionControl interface.
   const std::string& client_jid() const override;
   void DisconnectSession(protocol::ErrorCode error) override;
   void OnLocalMouseMoved(const webrtc::DesktopVector& position) override;
   void SetDisableInputs(bool disable_inputs) override;
   void ResetVideoPipeline() override;
 
   void SetGnubbyAuthHandlerForTesting(GnubbyAuthHandler* gnubby_auth_handler);
 
   protocol::ConnectionToClient* connection() const {
     return connection_.get();
   }
 
   bool is_authenticated() { return is_authenticated_;  }
 
   const std::string* client_capabilities() const {
     return client_capabilities_.get();
   }
 
  private:
   // Creates a proxy for sending clipboard events to the client.
   scoped_ptr<protocol::ClipboardStub> CreateClipboardProxy();
 
+  void OnScreenSizeChanged(const webrtc::DesktopSize& size);
+
   EventHandler* event_handler_;
 
   // The connection to the client.
   scoped_ptr<protocol::ConnectionToClient> connection_;
 
   std::string client_jid_;
 
   // Used to create a DesktopEnvironment instance for this session.
   DesktopEnvironmentFactory* desktop_environment_factory_;
 
   // The DesktopEnvironment instance for this session.
   scoped_ptr<DesktopEnvironment> desktop_environment_;
 
   // Filter used as the final element in the input pipeline.
   protocol::InputFilter host_input_filter_;
 
   // Tracker used to release pressed keys and buttons when disconnecting.
   protocol::InputEventTracker input_tracker_;
 
   // Filter used to disable remote inputs during local input activity.
   RemoteInputFilter remote_input_filter_;
 
   // Filter used to clamp mouse events to the current display dimensions.
-  MouseClampingFilter mouse_clamping_filter_;
+  protocol::MouseInputFilter mouse_clamping_filter_;
 
   // Filter to used to stop clipboard items sent from the client being echoed
   // back to it.  It is the final element in the clipboard (client -> host)
   // pipeline.
   protocol::ClipboardEchoFilter clipboard_echo_filter_;
 
   // Filters used to manage enabling & disabling of input & clipboard.
   protocol::InputFilter disable_input_filter_;
   protocol::ClipboardFilter disable_clipboard_filter_;
 
@@ skipping 10 matching lines @@
   // is reached.
   base::OneShotTimer max_duration_timer_;
 
   scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 
-  // Pumps for audio, video and mouse shape.
-  // |video_frame_pump_| and |mouse_shape_pump_| may be nullptr if the video
+  // Objects responsible for sending video, audio and mouse shape.
+  // |video_stream_| and |mouse_shape_pump_| may be nullptr if the video
   // stream is handled by an extension, see ResetVideoPipeline().
   scoped_ptr<AudioPump> audio_pump_;
-  scoped_ptr<protocol::VideoFramePump> video_frame_pump_;
+  scoped_ptr<protocol::VideoStream> video_stream_;
   scoped_ptr<MouseShapePump> mouse_shape_pump_;
 
   // The set of all capabilities supported by the client.
   scoped_ptr<std::string> client_capabilities_;
 
   // The set of all capabilities supported by the host.
   std::string host_capabilities_;
 
   // The set of all capabilities negotiated between client and host.
   std::string capabilities_;
@@ skipping 24 matching lines @@
   // Used to disable callbacks to |this| once DisconnectSession() has been
   // called.
   base::WeakPtrFactory<ClientSessionControl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSession);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_CLIENT_SESSION_H_