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_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
6#define REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
7
8#include <string>
9
10#include "base/gtest_prod_util.h"
11#include "base/memory/scoped_ptr.h"
12#include "base/memory/weak_ptr.h"
13#include "base/thread_task_runner_handle.h"
14#include "ppapi/c/pp_instance.h"
15#include "ppapi/c/pp_rect.h"
16#include "ppapi/c/pp_resource.h"
17#include "ppapi/cpp/instance.h"
18#include "ppapi/cpp/text_input_controller.h"
19#include "ppapi/cpp/var.h"
20#include "remoting/client/client_context.h"
21#include "remoting/client/client_user_interface.h"
22#include "remoting/client/key_event_mapper.h"
23#include "remoting/client/plugin/media_source_video_renderer.h"
24#include "remoting/client/plugin/pepper_input_handler.h"
25#include "remoting/client/plugin/pepper_plugin_thread_delegate.h"
26#include "remoting/proto/event.pb.h"
27#include "remoting/protocol/client_stub.h"
28#include "remoting/protocol/clipboard_stub.h"
29#include "remoting/protocol/connection_to_host.h"
30#include "remoting/protocol/cursor_shape_stub.h"
31#include "remoting/protocol/input_event_tracker.h"
32#include "remoting/protocol/mouse_input_filter.h"
33#include "remoting/protocol/negotiating_client_authenticator.h"
34#include "remoting/protocol/third_party_client_authenticator.h"
35
36namespace base {
37class DictionaryValue;
38}  // namespace base
39
40namespace pp {
41class InputEvent;
42class Module;
43class VarDictionary;
44}  // namespace pp
45
46namespace jingle_glue {
47class JingleThreadWrapper;
48}  // namespace jingle_glue
49
50namespace webrtc {
51class DesktopRegion;
52class DesktopSize;
53class DesktopVector;
54}  // namespace webrtc
55
56namespace remoting {
57
58class ChromotingClient;
59class ChromotingStats;
60class ClientContext;
61class DelegatingSignalStrategy;
62class FrameConsumer;
63class FrameConsumerProxy;
64class PepperAudioPlayer;
65class TokenFetcherProxy;
66class PepperView;
67class RectangleUpdateDecoder;
68class SignalStrategy;
69class VideoRenderer;
70
71struct ClientConfig;
72
73class ChromotingInstance :
74      public ClientUserInterface,
75      public MediaSourceVideoRenderer::Delegate,
76      public protocol::ClipboardStub,
77      public protocol::CursorShapeStub,
78      public pp::Instance {
79 public:
80  // Plugin API version. This should be incremented whenever the API
81  // interface changes.
82  static const int kApiVersion = 7;
83
84  // Plugin API features. This allows orthogonal features to be supported
85  // without bumping the API version.
86  static const char kApiFeatures[];
87
88  // Capabilities supported by the plugin that should also be supported by the
89  // webapp to be enabled.
90  static const char kRequestedCapabilities[];
91
92  // Capabilities supported by the plugin that do not need to be supported by
93  // the webapp to be enabled.
94  static const char kSupportedCapabilities[];
95
96  // Backward-compatibility version used by for the messaging
97  // interface. Should be updated whenever we remove support for
98  // an older version of the API.
99  static const int kApiMinMessagingVersion = 5;
100
101  // Backward-compatibility version used by for the ScriptableObject
102  // interface. Should be updated whenever we remove support for
103  // an older version of the API.
104  static const int kApiMinScriptableVersion = 5;
105
106  explicit ChromotingInstance(PP_Instance instance);
107  virtual ~ChromotingInstance();
108
109  // pp::Instance interface.
110  virtual void DidChangeFocus(bool has_focus) OVERRIDE;
111  virtual void DidChangeView(const pp::View& view) OVERRIDE;
112  virtual bool Init(uint32_t argc, const char* argn[],
113                    const char* argv[]) OVERRIDE;
114  virtual void HandleMessage(const pp::Var& message) OVERRIDE;
115  virtual bool HandleInputEvent(const pp::InputEvent& event) OVERRIDE;
116
117  // ClientUserInterface interface.
118  virtual void OnConnectionState(protocol::ConnectionToHost::State state,
119                                 protocol::ErrorCode error) OVERRIDE;
120  virtual void OnConnectionReady(bool ready) OVERRIDE;
121  virtual void OnRouteChanged(const std::string& channel_name,
122                              const protocol::TransportRoute& route) OVERRIDE;
123  virtual void SetCapabilities(const std::string& capabilities) OVERRIDE;
124  virtual void SetPairingResponse(
125      const protocol::PairingResponse& pairing_response) OVERRIDE;
126  virtual void DeliverHostMessage(
127      const protocol::ExtensionMessage& message) OVERRIDE;
128  virtual protocol::ClipboardStub* GetClipboardStub() OVERRIDE;
129  virtual protocol::CursorShapeStub* GetCursorShapeStub() OVERRIDE;
130
131  // protocol::ClipboardStub interface.
132  virtual void InjectClipboardEvent(
133      const protocol::ClipboardEvent& event) OVERRIDE;
134
135  // protocol::CursorShapeStub interface.
136  virtual void SetCursorShape(
137      const protocol::CursorShapeInfo& cursor_shape) OVERRIDE;
138
139  // Called by PepperView.
140  void SetDesktopSize(const webrtc::DesktopSize& size,
141                      const webrtc::DesktopVector& dpi);
142  void SetDesktopShape(const webrtc::DesktopRegion& shape);
143  void OnFirstFrameReceived();
144
145  // Return statistics record by ChromotingClient.
146  // If no connection is currently active then NULL will be returned.
147  ChromotingStats* GetStats();
148
149  // Registers a global log message handler that redirects the log output to
150  // our plugin instance.
151  // This is called by the plugin's PPP_InitializeModule.
152  // Note that no logging will be processed unless a ChromotingInstance has been
153  // registered for logging (see RegisterLoggingInstance).
154  static void RegisterLogMessageHandler();
155
156  // Registers this instance so it processes messages sent by the global log
157  // message handler. This overwrites any previously registered instance.
158  void RegisterLoggingInstance();
159
160  // Unregisters this instance so that debug log messages will no longer be sent
161  // to it. If this instance is not the currently registered logging instance,
162  // then the currently registered instance will stay in effect.
163  void UnregisterLoggingInstance();
164
165  // A Log Message Handler that is called after each LOG message has been
166  // processed. This must be of type LogMessageHandlerFunction defined in
167  // base/logging.h.
168  static bool LogToUI(int severity, const char* file, int line,
169                      size_t message_start, const std::string& str);
170
171  // Requests the webapp to fetch a third-party token.
172  void FetchThirdPartyToken(
173      const GURL& token_url,
174      const std::string& host_public_key,
175      const std::string& scope,
176      const base::WeakPtr<TokenFetcherProxy> pepper_token_fetcher);
177
178 private:
179  FRIEND_TEST_ALL_PREFIXES(ChromotingInstanceTest, TestCaseSetup);
180
181  // Used as the |FetchSecretCallback| for IT2Me (or Me2Me from old webapps).
182  // Immediately calls |secret_fetched_callback| with |shared_secret|.
183  static void FetchSecretFromString(
184      const std::string& shared_secret,
185      bool pairing_supported,
186      const protocol::SecretFetchedCallback& secret_fetched_callback);
187
188  // Message handlers for messages that come from JavaScript. Called
189  // from HandleMessage().
190  void HandleConnect(const base::DictionaryValue& data);
191  void HandleDisconnect(const base::DictionaryValue& data);
192  void HandleOnIncomingIq(const base::DictionaryValue& data);
193  void HandleReleaseAllKeys(const base::DictionaryValue& data);
194  void HandleInjectKeyEvent(const base::DictionaryValue& data);
195  void HandleRemapKey(const base::DictionaryValue& data);
196  void HandleTrapKey(const base::DictionaryValue& data);
197  void HandleSendClipboardItem(const base::DictionaryValue& data);
198  void HandleNotifyClientResolution(const base::DictionaryValue& data);
199  void HandlePauseVideo(const base::DictionaryValue& data);
200  void HandleVideoControl(const base::DictionaryValue& data);
201  void HandlePauseAudio(const base::DictionaryValue& data);
202  void HandleOnPinFetched(const base::DictionaryValue& data);
203  void HandleOnThirdPartyTokenFetched(const base::DictionaryValue& data);
204  void HandleRequestPairing(const base::DictionaryValue& data);
205  void HandleExtensionMessage(const base::DictionaryValue& data);
206  void HandleAllowMouseLockMessage();
207  void HandleEnableMediaSourceRendering();
208  void HandleSendMouseInputWhenUnfocused();
209  void HandleDelegateLargeCursors();
210
211  // Helper method to post messages to the webapp.
212  void PostChromotingMessage(const std::string& method,
213                             const pp::VarDictionary& data);
214
215  // Same as above, but serializes messages to JSON before sending them.  This
216  // method is used for backward compatibility with older version of the webapp
217  // that expect to received most messages formatted using JSON.
218  //
219  // TODO(sergeyu): When all current versions of the webapp support raw messages
220  // remove this method and use PostChromotingMessage() instead.
221  void PostLegacyJsonMessage(const std::string& method,
222                       scoped_ptr<base::DictionaryValue> data);
223
224  // Posts trapped keys to the web-app to handle.
225  void SendTrappedKey(uint32 usb_keycode, bool pressed);
226
227  // Callback for DelegatingSignalStrategy.
228  void SendOutgoingIq(const std::string& iq);
229
230  void SendPerfStats();
231
232  void ProcessLogToUI(const std::string& message);
233
234  // Returns true if the hosting content has the chrome-extension:// scheme.
235  bool IsCallerAppOrExtension();
236
237  // Returns true if there is a ConnectionToHost and it is connected.
238  bool IsConnected();
239
240  // Used as the |FetchSecretCallback| for Me2Me connections.
241  // Uses the PIN request dialog in the webapp to obtain the shared secret.
242  void FetchSecretFromDialog(
243      bool pairing_supported,
244      const protocol::SecretFetchedCallback& secret_fetched_callback);
245
246  // MediaSourceVideoRenderer::Delegate implementation.
247  virtual void OnMediaSourceSize(const webrtc::DesktopSize& size,
248                                 const webrtc::DesktopVector& dpi) OVERRIDE;
249  virtual void OnMediaSourceShape(const webrtc::DesktopRegion& shape) OVERRIDE;
250  virtual void OnMediaSourceReset(const std::string& format) OVERRIDE;
251  virtual void OnMediaSourceData(uint8_t* buffer, size_t buffer_size,
252                                 bool keyframe) OVERRIDE;
253
254  bool initialized_;
255
256  PepperPluginThreadDelegate plugin_thread_delegate_;
257  scoped_refptr<PluginThreadTaskRunner> plugin_task_runner_;
258  scoped_ptr<base::ThreadTaskRunnerHandle> thread_task_runner_handle_;
259  scoped_ptr<jingle_glue::JingleThreadWrapper> thread_wrapper_;
260  ClientContext context_;
261  scoped_ptr<VideoRenderer> video_renderer_;
262  scoped_ptr<PepperView> view_;
263  scoped_ptr<base::WeakPtrFactory<FrameConsumer> > view_weak_factory_;
264  pp::View plugin_view_;
265
266  // Contains the most-recently-reported desktop shape, if any.
267  scoped_ptr<webrtc::DesktopRegion> desktop_shape_;
268
269  scoped_ptr<DelegatingSignalStrategy> signal_strategy_;
270
271  scoped_ptr<ChromotingClient> client_;
272
273  // Input pipeline components, in reverse order of distance from input source.
274  protocol::MouseInputFilter mouse_input_filter_;
275  protocol::InputEventTracker input_tracker_;
276  KeyEventMapper key_mapper_;
277  scoped_ptr<protocol::InputFilter> normalizing_input_filter_;
278  PepperInputHandler input_handler_;
279
280  // Used to control text input settings, such as whether to show the IME.
281  pp::TextInputController text_input_controller_;
282
283  // PIN Fetcher.
284  bool use_async_pin_dialog_;
285  protocol::SecretFetchedCallback secret_fetched_callback_;
286
287  // Set to true if the webapp has requested to use MediaSource API for
288  // rendering. In that case all the encoded video will be passed to the
289  // webapp for decoding.
290  bool use_media_source_rendering_;
291
292  // Set to true if the web-app can handle large cursors. If false, then large
293  // cursors will be cropped to the maximum size supported by Pepper.
294  bool delegate_large_cursors_;
295
296  base::WeakPtr<TokenFetcherProxy> token_fetcher_proxy_;
297
298  // Weak reference to this instance, used for global logging and task posting.
299  base::WeakPtrFactory<ChromotingInstance> weak_factory_;
300
301  DISALLOW_COPY_AND_ASSIGN(ChromotingInstance);
302};
303
304}  // namespace remoting
305
306#endif  // REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
307