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 36 namespace base { 37 class DictionaryValue; 38 } // namespace base 39 40 namespace pp { 41 class InputEvent; 42 class Module; 43 class VarDictionary; 44 } // namespace pp 45 46 namespace jingle_glue { 47 class JingleThreadWrapper; 48 } // namespace jingle_glue 49 50 namespace webrtc { 51 class DesktopRegion; 52 class DesktopSize; 53 class DesktopVector; 54 } // namespace webrtc 55 56 namespace remoting { 57 58 class ChromotingClient; 59 class ChromotingStats; 60 class ClientContext; 61 class DelegatingSignalStrategy; 62 class FrameConsumer; 63 class FrameConsumerProxy; 64 class PepperAudioPlayer; 65 class TokenFetcherProxy; 66 class PepperView; 67 class RectangleUpdateDecoder; 68 class SignalStrategy; 69 class VideoRenderer; 70 71 struct ClientConfig; 72 73 class 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
