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