| // 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_PROTOCOL_CONNECTION_TO_CLIENT_H_ |
| #define REMOTING_PROTOCOL_CONNECTION_TO_CLIENT_H_ |
| |
| #include <deque> |
| #include <string> |
| #include <vector> |
| |
| #include "base/memory/scoped_ptr.h" |
| #include "base/synchronization/lock.h" |
| #include "base/threading/non_thread_safe.h" |
| #include "remoting/protocol/audio_writer.h" |
| #include "remoting/protocol/session.h" |
| #include "remoting/protocol/video_writer.h" |
| |
| namespace net { |
| class IPEndPoint; |
| } // namespace net |
| |
| namespace remoting { |
| namespace protocol { |
| |
| class ClientStub; |
| class ClipboardStub; |
| class HostStub; |
| class InputStub; |
| class HostControlDispatcher; |
| class HostEventDispatcher; |
| |
| // This class represents a remote viewer connection to the chromoting |
| // host. It sets up all protocol channels and connects them to the |
| // stubs. |
| class ConnectionToClient : public base::NonThreadSafe, |
| public Session::EventHandler { |
| public: |
| class EventHandler { |
| public: |
| // Called when the network connection is authenticated. |
| virtual void OnConnectionAuthenticated(ConnectionToClient* connection) = 0; |
| |
| // Called when the network connection is authenticated and all |
| // channels are connected. |
| virtual void OnConnectionChannelsConnected( |
| ConnectionToClient* connection) = 0; |
| |
| // Called when the network connection is closed or failed. |
| virtual void OnConnectionClosed(ConnectionToClient* connection, |
| ErrorCode error) = 0; |
| |
| // Called when sequence number is updated. |
| virtual void OnSequenceNumberUpdated(ConnectionToClient* connection, |
| int64 sequence_number) = 0; |
| |
| // Called on notification of a route change event, which happens when a |
| // channel is connected. |
| virtual void OnRouteChange(ConnectionToClient* connection, |
| const std::string& channel_name, |
| const TransportRoute& route) = 0; |
| |
| protected: |
| virtual ~EventHandler() {} |
| }; |
| |
| // Constructs a ConnectionToClient object for the |session|. Takes |
| // ownership of |session|. |
| explicit ConnectionToClient(Session* session); |
| virtual ~ConnectionToClient(); |
| |
| // Set |event_handler| for connection events. Must be called once when this |
| // object is created. |
| void SetEventHandler(EventHandler* event_handler); |
| |
| // Returns the connection in use. |
| virtual Session* session(); |
| |
| // Disconnect the client connection. |
| virtual void Disconnect(); |
| |
| // Update the sequence number when received from the client. EventHandler |
| // will be called. |
| virtual void UpdateSequenceNumber(int64 sequence_number); |
| |
| // Get the stubs used by the host to transmit messages to the client. |
| // The stubs must not be accessed before OnConnectionAuthenticated(), or |
| // after OnConnectionClosed(). |
| // Note that the audio stub will be NULL if audio is not enabled. |
| virtual VideoStub* video_stub(); |
| virtual AudioStub* audio_stub(); |
| virtual ClientStub* client_stub(); |
| |
| // Set/get the stubs which will handle messages we receive from the client. |
| // All stubs MUST be set before the session's channels become connected. |
| virtual void set_clipboard_stub(ClipboardStub* clipboard_stub); |
| virtual ClipboardStub* clipboard_stub(); |
| virtual void set_host_stub(HostStub* host_stub); |
| virtual HostStub* host_stub(); |
| virtual void set_input_stub(InputStub* input_stub); |
| virtual InputStub* input_stub(); |
| |
| // Session::EventHandler interface. |
| virtual void OnSessionStateChange(Session::State state) OVERRIDE; |
| virtual void OnSessionRouteChange(const std::string& channel_name, |
| const TransportRoute& route) OVERRIDE; |
| |
| private: |
| // Callback for channel initialization. |
| void OnChannelInitialized(bool successful); |
| |
| void NotifyIfChannelsReady(); |
| |
| void Close(ErrorCode error); |
| |
| // Stops writing in the channels. |
| void CloseChannels(); |
| |
| // Event handler for handling events sent from this object. |
| EventHandler* handler_; |
| |
| // Stubs that are called for incoming messages. |
| ClipboardStub* clipboard_stub_; |
| HostStub* host_stub_; |
| InputStub* input_stub_; |
| |
| // The libjingle channel used to send and receive data from the remote client. |
| scoped_ptr<Session> session_; |
| |
| scoped_ptr<HostControlDispatcher> control_dispatcher_; |
| scoped_ptr<HostEventDispatcher> event_dispatcher_; |
| scoped_ptr<VideoWriter> video_writer_; |
| scoped_ptr<AudioWriter> audio_writer_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ConnectionToClient); |
| }; |
| |
| } // namespace protocol |
| } // namespace remoting |
| |
| #endif // REMOTING_PROTOCOL_CONNECTION_TO_CLIENT_H_ |