Use extensions_path.h instead of chrome_path.h from extension_icon_image_unittest.cc
[chromium-blink-merge.git] / remoting / host / chromoting_host.h
blobab35224aebb10f74dba0bd20b8ae4a372d25dd57
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef REMOTING_HOST_CHROMOTING_HOST_H_
6 #define REMOTING_HOST_CHROMOTING_HOST_H_
8 #include <list>
9 #include <string>
11 #include "base/memory/ref_counted.h"
12 #include "base/memory/scoped_ptr.h"
13 #include "base/memory/scoped_vector.h"
14 #include "base/memory/weak_ptr.h"
15 #include "base/observer_list.h"
16 #include "base/threading/non_thread_safe.h"
17 #include "base/threading/thread.h"
18 #include "net/base/backoff_entry.h"
19 #include "remoting/host/client_session.h"
20 #include "remoting/host/host_extension.h"
21 #include "remoting/host/host_status_monitor.h"
22 #include "remoting/host/host_status_observer.h"
23 #include "remoting/protocol/authenticator.h"
24 #include "remoting/protocol/connection_to_client.h"
25 #include "remoting/protocol/pairing_registry.h"
26 #include "remoting/protocol/session_manager.h"
28 namespace base {
29 class SingleThreadTaskRunner;
30 } // namespace base
32 namespace remoting {
34 namespace protocol {
35 class InputStub;
36 class SessionConfig;
37 class CandidateSessionConfig;
38 } // namespace protocol
40 class DesktopEnvironmentFactory;
42 // A class to implement the functionality of a host process.
44 // Here's the work flow of this class:
45 // 1. We should load the saved GAIA ID token or if this is the first
46 // time the host process runs we should prompt user for the
47 // credential. We will use this token or credentials to authenicate
48 // and register the host.
50 // 2. We listen for incoming connection using libjingle. We will create
51 // a ConnectionToClient object that wraps around linjingle for transport.
52 // A VideoScheduler is created with an Encoder and a webrtc::ScreenCapturer.
53 // A ConnectionToClient is added to the ScreenRecorder for transporting
54 // the screen captures. An InputStub is created and registered with the
55 // ConnectionToClient to receive mouse / keyboard events from the remote
56 // client.
57 // After we have done all the initialization we'll start the ScreenRecorder.
58 // We'll then enter the running state of the host process.
60 // 3. When the user is disconnected, we will pause the ScreenRecorder
61 // and try to terminate the threads we have created. This will allow
62 // all pending tasks to complete. After all of that completed we
63 // return to the idle state. We then go to step (2) if there a new
64 // incoming connection.
65 class ChromotingHost : public base::NonThreadSafe,
66 public ClientSession::EventHandler,
67 public protocol::SessionManager::Listener,
68 public HostStatusMonitor {
69 public:
70 // Both |signal_strategy| and |desktop_environment_factory| should outlive
71 // this object.
72 ChromotingHost(
73 SignalStrategy* signal_strategy,
74 DesktopEnvironmentFactory* desktop_environment_factory,
75 scoped_ptr<protocol::SessionManager> session_manager,
76 scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
77 scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
78 scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner,
79 scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner,
80 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
81 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
82 virtual ~ChromotingHost();
84 // Asynchronously starts the host.
86 // After this is invoked, the host process will connect to the talk
87 // network and start listening for incoming connections.
89 // This method can only be called once during the lifetime of this object.
90 void Start(const std::string& host_owner);
92 // HostStatusMonitor interface.
93 virtual void AddStatusObserver(HostStatusObserver* observer) OVERRIDE;
94 virtual void RemoveStatusObserver(HostStatusObserver* observer) OVERRIDE;
96 // Registers a host extension.
97 void AddExtension(scoped_ptr<HostExtension> extension);
99 // This method may be called only from
100 // HostStatusObserver::OnClientAuthenticated() to reject the new
101 // client.
102 void RejectAuthenticatingClient();
104 // Sets the authenticator factory to use for incoming
105 // connections. Incoming connections are rejected until
106 // authenticator factory is set. Must be called on the network
107 // thread after the host is started. Must not be called more than
108 // once per host instance because it may not be safe to delete
109 // factory before all authenticators it created are deleted.
110 void SetAuthenticatorFactory(
111 scoped_ptr<protocol::AuthenticatorFactory> authenticator_factory);
113 // Enables/disables curtaining when one or more clients are connected.
114 // Takes immediate effect if clients are already connected.
115 void SetEnableCurtaining(bool enable);
117 // Sets the maximum duration of any session. By default, a session has no
118 // maximum duration.
119 void SetMaximumSessionDuration(const base::TimeDelta& max_session_duration);
121 ////////////////////////////////////////////////////////////////////////////
122 // ClientSession::EventHandler implementation.
123 virtual void OnSessionAuthenticating(ClientSession* client) OVERRIDE;
124 virtual bool OnSessionAuthenticated(ClientSession* client) OVERRIDE;
125 virtual void OnSessionChannelsConnected(ClientSession* client) OVERRIDE;
126 virtual void OnSessionAuthenticationFailed(ClientSession* client) OVERRIDE;
127 virtual void OnSessionClosed(ClientSession* session) OVERRIDE;
128 virtual void OnSessionRouteChange(
129 ClientSession* session,
130 const std::string& channel_name,
131 const protocol::TransportRoute& route) OVERRIDE;
133 // SessionManager::Listener implementation.
134 virtual void OnSessionManagerReady() OVERRIDE;
135 virtual void OnIncomingSession(
136 protocol::Session* session,
137 protocol::SessionManager::IncomingSessionResponse* response) OVERRIDE;
139 // Gets the candidate configuration for the protocol.
140 const protocol::CandidateSessionConfig* protocol_config() const {
141 return protocol_config_.get();
144 // Sets desired configuration for the protocol. Must be called before Start().
145 void set_protocol_config(scoped_ptr<protocol::CandidateSessionConfig> config);
147 // The host uses a pairing registry to generate and store pairing information
148 // for clients for PIN-less authentication.
149 scoped_refptr<protocol::PairingRegistry> pairing_registry() const {
150 return pairing_registry_;
152 void set_pairing_registry(
153 scoped_refptr<protocol::PairingRegistry> pairing_registry) {
154 pairing_registry_ = pairing_registry;
157 base::WeakPtr<ChromotingHost> AsWeakPtr() {
158 return weak_factory_.GetWeakPtr();
161 private:
162 friend class ChromotingHostTest;
164 typedef std::list<ClientSession*> ClientList;
165 typedef ScopedVector<HostExtension> HostExtensionList;
167 // Immediately disconnects all active clients. Host-internal components may
168 // shutdown asynchronously, but the caller is guaranteed not to receive
169 // callbacks for disconnected clients after this call returns.
170 void DisconnectAllClients();
172 // Unless specified otherwise all members of this class must be
173 // used on the network thread only.
175 // Parameters specified when the host was created.
176 DesktopEnvironmentFactory* desktop_environment_factory_;
177 scoped_ptr<protocol::SessionManager> session_manager_;
178 scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
179 scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
180 scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner_;
181 scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner_;
182 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
183 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
185 // Connection objects.
186 SignalStrategy* signal_strategy_;
188 // Must be used on the network thread only.
189 ObserverList<HostStatusObserver> status_observers_;
191 // The connections to remote clients.
192 ClientList clients_;
194 // True if the host has been started.
195 bool started_;
197 // Configuration of the protocol.
198 scoped_ptr<protocol::CandidateSessionConfig> protocol_config_;
200 // Login backoff state.
201 net::BackoffEntry login_backoff_;
203 // Flags used for RejectAuthenticatingClient().
204 bool authenticating_client_;
205 bool reject_authenticating_client_;
207 // True if the curtain mode is enabled.
208 bool enable_curtaining_;
210 // The maximum duration of any session.
211 base::TimeDelta max_session_duration_;
213 // The pairing registry for PIN-less authentication.
214 scoped_refptr<protocol::PairingRegistry> pairing_registry_;
216 // List of host extensions.
217 HostExtensionList extensions_;
219 base::WeakPtrFactory<ChromotingHost> weak_factory_;
221 DISALLOW_COPY_AND_ASSIGN(ChromotingHost);
224 } // namespace remoting
226 #endif // REMOTING_HOST_CHROMOTING_HOST_H_