// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// TODO(ajwong): We need to come up with a better description of the
-// responsibilities for each thread.
-
#ifndef REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
#define REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
#include "base/gtest_prod_util.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
+#include "base/thread_task_runner_handle.h"
#include "ppapi/c/pp_instance.h"
#include "ppapi/c/pp_rect.h"
#include "ppapi/c/pp_resource.h"
#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/text_input_controller.h"
#include "ppapi/cpp/var.h"
#include "remoting/client/client_context.h"
#include "remoting/client/client_user_interface.h"
#include "remoting/client/key_event_mapper.h"
-#include "remoting/client/plugin/normalizing_input_filter.h"
+#include "remoting/client/plugin/media_source_video_renderer.h"
#include "remoting/client/plugin/pepper_input_handler.h"
#include "remoting/client/plugin/pepper_plugin_thread_delegate.h"
#include "remoting/proto/event.pb.h"
namespace pp {
class InputEvent;
class Module;
+class VarDictionary;
} // namespace pp
+namespace jingle_glue {
+class JingleThreadWrapper;
+} // namespace jingle_glue
+
namespace webrtc {
class DesktopRegion;
class DesktopSize;
class FrameConsumer;
class FrameConsumerProxy;
class PepperAudioPlayer;
-class PepperTokenFetcher;
+class TokenFetcherProxy;
class PepperView;
class RectangleUpdateDecoder;
class SignalStrategy;
+class VideoRenderer;
struct ClientConfig;
class ChromotingInstance :
public ClientUserInterface,
+ public MediaSourceVideoRenderer::Delegate,
public protocol::ClipboardStub,
public protocol::CursorShapeStub,
public pp::Instance {
// an older version of the API.
static const int kApiMinScriptableVersion = 5;
- // Helper method to parse authentication_methods parameter.
- static bool ParseAuthMethods(const std::string& auth_methods,
- ClientConfig* config);
-
explicit ChromotingInstance(PP_Instance instance);
virtual ~ChromotingInstance();
virtual void OnConnectionState(protocol::ConnectionToHost::State state,
protocol::ErrorCode error) OVERRIDE;
virtual void OnConnectionReady(bool ready) OVERRIDE;
+ virtual void OnRouteChanged(const std::string& channel_name,
+ const protocol::TransportRoute& route) OVERRIDE;
virtual void SetCapabilities(const std::string& capabilities) OVERRIDE;
virtual void SetPairingResponse(
const protocol::PairingResponse& pairing_response) OVERRIDE;
const protocol::ExtensionMessage& message) OVERRIDE;
virtual protocol::ClipboardStub* GetClipboardStub() OVERRIDE;
virtual protocol::CursorShapeStub* GetCursorShapeStub() OVERRIDE;
- virtual scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
- GetTokenFetcher(const std::string& host_public_key) OVERRIDE;
// protocol::ClipboardStub interface.
virtual void InjectClipboardEvent(
const GURL& token_url,
const std::string& host_public_key,
const std::string& scope,
- const base::WeakPtr<PepperTokenFetcher> pepper_token_fetcher);
+ const base::WeakPtr<TokenFetcherProxy> pepper_token_fetcher);
private:
FRIEND_TEST_ALL_PREFIXES(ChromotingInstanceTest, TestCaseSetup);
void HandleSendClipboardItem(const base::DictionaryValue& data);
void HandleNotifyClientResolution(const base::DictionaryValue& data);
void HandlePauseVideo(const base::DictionaryValue& data);
+ void HandleVideoControl(const base::DictionaryValue& data);
void HandlePauseAudio(const base::DictionaryValue& data);
void HandleOnPinFetched(const base::DictionaryValue& data);
void HandleOnThirdPartyTokenFetched(const base::DictionaryValue& data);
void HandleRequestPairing(const base::DictionaryValue& data);
void HandleExtensionMessage(const base::DictionaryValue& data);
void HandleAllowMouseLockMessage();
-
- // Helper method called from Connect() to connect with parsed config.
- void ConnectWithConfig(const ClientConfig& config,
- const std::string& local_jid);
+ void HandleEnableMediaSourceRendering();
+ void HandleSendMouseInputWhenUnfocused();
+ void HandleDelegateLargeCursors();
// Helper method to post messages to the webapp.
void PostChromotingMessage(const std::string& method,
- scoped_ptr<base::DictionaryValue> data);
+ const pp::VarDictionary& data);
+
+ // Same as above, but serializes messages to JSON before sending them. This
+ // method is used for backward compatibility with older version of the webapp
+ // that expect to received most messages formatted using JSON.
+ //
+ // TODO(sergeyu): When all current versions of the webapp support raw messages
+ // remove this method and use PostChromotingMessage() instead.
+ void PostLegacyJsonMessage(const std::string& method,
+ scoped_ptr<base::DictionaryValue> data);
// Posts trapped keys to the web-app to handle.
void SendTrappedKey(uint32 usb_keycode, bool pressed);
bool pairing_supported,
const protocol::SecretFetchedCallback& secret_fetched_callback);
+ // MediaSourceVideoRenderer::Delegate implementation.
+ virtual void OnMediaSourceSize(const webrtc::DesktopSize& size,
+ const webrtc::DesktopVector& dpi) OVERRIDE;
+ virtual void OnMediaSourceShape(const webrtc::DesktopRegion& shape) OVERRIDE;
+ virtual void OnMediaSourceReset(const std::string& format) OVERRIDE;
+ virtual void OnMediaSourceData(uint8_t* buffer, size_t buffer_size,
+ bool keyframe) OVERRIDE;
+
bool initialized_;
PepperPluginThreadDelegate plugin_thread_delegate_;
scoped_refptr<PluginThreadTaskRunner> plugin_task_runner_;
+ scoped_ptr<base::ThreadTaskRunnerHandle> thread_task_runner_handle_;
+ scoped_ptr<jingle_glue::JingleThreadWrapper> thread_wrapper_;
ClientContext context_;
- scoped_refptr<RectangleUpdateDecoder> rectangle_decoder_;
+ scoped_ptr<VideoRenderer> video_renderer_;
scoped_ptr<PepperView> view_;
scoped_ptr<base::WeakPtrFactory<FrameConsumer> > view_weak_factory_;
pp::View plugin_view_;
scoped_ptr<DelegatingSignalStrategy> signal_strategy_;
- scoped_ptr<protocol::ConnectionToHost> host_connection_;
scoped_ptr<ChromotingClient> client_;
// Input pipeline components, in reverse order of distance from input source.
scoped_ptr<protocol::InputFilter> normalizing_input_filter_;
PepperInputHandler input_handler_;
+ // Used to control text input settings, such as whether to show the IME.
+ pp::TextInputController text_input_controller_;
+
// PIN Fetcher.
bool use_async_pin_dialog_;
protocol::SecretFetchedCallback secret_fetched_callback_;
- base::WeakPtr<PepperTokenFetcher> pepper_token_fetcher_;
+ // Set to true if the webapp has requested to use MediaSource API for
+ // rendering. In that case all the encoded video will be passed to the
+ // webapp for decoding.
+ bool use_media_source_rendering_;
+
+ // Set to true if the web-app can handle large cursors. If false, then large
+ // cursors will be cropped to the maximum size supported by Pepper.
+ bool delegate_large_cursors_;
+
+ base::WeakPtr<TokenFetcherProxy> token_fetcher_proxy_;
// Weak reference to this instance, used for global logging and task posting.
base::WeakPtrFactory<ChromotingInstance> weak_factory_;
projects / platform / framework / web / crosswalk.git / blobdiff