1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
// 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.h"
#include "base/timer.h"
#include "remoting/host/client_session_control.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 "third_party/skia/include/core/SkPoint.h"
#include "third_party/skia/include/core/SkSize.h"
namespace base {
class SingleThreadTaskRunner;
} // namespace base
namespace remoting {
class AudioEncoder;
class AudioScheduler;
class DesktopEnvironment;
class DesktopEnvironmentFactory;
class InputInjector;
class ScreenControls;
class VideoEncoder;
class VideoScheduler;
// 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 {
public:
// Called after authentication has finished successfully. Returns true if
// the connection is allowed, or false otherwise.
virtual bool OnSessionAuthenticated(ClientSession* client) = 0;
// Called after we've finished connecting all channels.
virtual void OnSessionChannelsConnected(ClientSession* client) = 0;
// Called after authentication has failed. Must not tear down this
// object. OnSessionClosed() is notified after this handler
// returns.
virtual void OnSessionAuthenticationFailed(ClientSession* client) = 0;
// Called after connection has failed or after the client closed it.
virtual void OnSessionClosed(ClientSession* client) = 0;
// Called to notify of each message's sequence number. The
// callback must not tear down this object.
virtual void OnSessionSequenceNumber(ClientSession* client,
int64 sequence_number) = 0;
// Called on notification of a route change event, when a channel is
// connected.
virtual void OnSessionRouteChange(
ClientSession* client,
const std::string& channel_name,
const protocol::TransportRoute& route) = 0;
protected:
virtual ~EventHandler() {}
};
// |event_handler| and |desktop_environment_factory| must outlive |this|.
ClientSession(
EventHandler* event_handler,
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,
scoped_ptr<protocol::ConnectionToClient> connection,
DesktopEnvironmentFactory* desktop_environment_factory,
const base::TimeDelta& max_duration);
virtual ~ClientSession();
// protocol::HostStub interface.
virtual void NotifyClientResolution(
const protocol::ClientResolution& resolution) OVERRIDE;
virtual void ControlVideo(
const protocol::VideoControl& video_control) OVERRIDE;
virtual void ControlAudio(
const protocol::AudioControl& audio_control) OVERRIDE;
virtual void SetCapabilities(
const protocol::Capabilities& capabilities) OVERRIDE;
// protocol::ConnectionToClient::EventHandler interface.
virtual void OnConnectionAuthenticated(
protocol::ConnectionToClient* connection) OVERRIDE;
virtual void OnConnectionChannelsConnected(
protocol::ConnectionToClient* connection) OVERRIDE;
virtual void OnConnectionClosed(protocol::ConnectionToClient* connection,
protocol::ErrorCode error) OVERRIDE;
virtual void OnSequenceNumberUpdated(
protocol::ConnectionToClient* connection, int64 sequence_number) OVERRIDE;
virtual void OnRouteChange(
protocol::ConnectionToClient* connection,
const std::string& channel_name,
const protocol::TransportRoute& route) OVERRIDE;
// ClientSessionControl interface.
virtual const std::string& client_jid() const OVERRIDE;
virtual void DisconnectSession() OVERRIDE;
virtual void OnLocalMouseMoved(const SkIPoint& position) OVERRIDE;
virtual void SetDisableInputs(bool disable_inputs) OVERRIDE;
protocol::ConnectionToClient* connection() const {
return connection_.get();
}
bool is_authenticated() { return auth_input_filter_.enabled(); }
private:
// Creates a proxy for sending clipboard events to the client.
scoped_ptr<protocol::ClipboardStub> CreateClipboardProxy();
// Creates an audio encoder for the specified configuration.
static scoped_ptr<AudioEncoder> CreateAudioEncoder(
const protocol::SessionConfig& config);
// Creates a video encoder for the specified configuration.
static scoped_ptr<VideoEncoder> CreateVideoEncoder(
const protocol::SessionConfig& config);
EventHandler* event_handler_;
// The connection to the client.
scoped_ptr<protocol::ConnectionToClient> connection_;
std::string client_jid_;
// Used to disable callbacks to |this| once DisconnectSession() has been
// called.
base::WeakPtrFactory<ClientSessionControl> control_factory_;
// 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_;
// 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_;
// Filters used to disable input & clipboard when we're not authenticated.
protocol::InputFilter auth_input_filter_;
protocol::ClipboardFilter auth_clipboard_filter_;
// Factory for weak pointers to the client clipboard stub.
// This must appear after |clipboard_echo_filter_|, so that it won't outlive
// it.
base::WeakPtrFactory<protocol::ClipboardStub> client_clipboard_factory_;
// The maximum duration of this session.
// There is no maximum if this value is <= 0.
base::TimeDelta max_duration_;
// A timer that triggers a disconnect when the maximum session duration
// is reached.
base::OneShotTimer<ClientSession> 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_;
// Schedulers for audio and video capture.
scoped_refptr<AudioScheduler> audio_scheduler_;
scoped_refptr<VideoScheduler> video_scheduler_;
// 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_;
// Used to inject mouse and keyboard input and handle clipboard events.
scoped_ptr<InputInjector> input_injector_;
// Used to apply client-requested changes in screen resolution.
scoped_ptr<ScreenControls> screen_controls_;
DISALLOW_COPY_AND_ASSIGN(ClientSession);
};
} // namespace remoting
#endif // REMOTING_HOST_CLIENT_SESSION_H_
|
