// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// 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 <string>
#include "base/gtest_prod_util.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.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/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/pepper_input_handler.h"
#include "remoting/client/plugin/pepper_plugin_thread_delegate.h"
#include "remoting/proto/event.pb.h"
#include "remoting/protocol/client_stub.h"
#include "remoting/protocol/clipboard_stub.h"
#include "remoting/protocol/connection_to_host.h"
#include "remoting/protocol/cursor_shape_stub.h"
#include "remoting/protocol/input_event_tracker.h"
#include "remoting/protocol/mouse_input_filter.h"
#include "remoting/protocol/negotiating_client_authenticator.h"
#include "remoting/protocol/third_party_client_authenticator.h"
namespace base {
class DictionaryValue;
} // namespace base
namespace pp {
class InputEvent;
class Module;
} // namespace pp
namespace webrtc {
class DesktopRegion;
class DesktopSize;
class DesktopVector;
} // namespace webrtc
namespace remoting {
class ChromotingClient;
class ChromotingStats;
class ClientContext;
class DelegatingSignalStrategy;
class FrameConsumer;
class FrameConsumerProxy;
class PepperAudioPlayer;
class PepperTokenFetcher;
class PepperView;
class RectangleUpdateDecoder;
class SignalStrategy;
struct ClientConfig;
class ChromotingInstance :
public ClientUserInterface,
public protocol::ClipboardStub,
public protocol::CursorShapeStub,
public pp::Instance {
public:
// Plugin API version. This should be incremented whenever the API
// interface changes.
static const int kApiVersion = 7;
// Plugin API features. This allows orthogonal features to be supported
// without bumping the API version.
static const char kApiFeatures[];
// Capabilities supported by the plugin that should also be supported by the
// webapp to be enabled.
static const char kRequestedCapabilities[];
// Capabilities supported by the plugin that do not need to be supported by
// the webapp to be enabled.
static const char kSupportedCapabilities[];
// Backward-compatibility version used by for the messaging
// interface. Should be updated whenever we remove support for
// an older version of the API.
static const int kApiMinMessagingVersion = 5;
// Backward-compatibility version used by for the ScriptableObject
// interface. Should be updated whenever we remove support for
// 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();
// pp::Instance interface.
virtual void DidChangeFocus(bool has_focus) OVERRIDE;
virtual void DidChangeView(const pp::View& view) OVERRIDE;
virtual bool Init(uint32_t argc, const char* argn[],
const char* argv[]) OVERRIDE;
virtual void HandleMessage(const pp::Var& message) OVERRIDE;
virtual bool HandleInputEvent(const pp::InputEvent& event) OVERRIDE;
// ClientUserInterface interface.
virtual void OnConnectionState(protocol::ConnectionToHost::State state,
protocol::ErrorCode error) OVERRIDE;
virtual void OnConnectionReady(bool ready) OVERRIDE;
virtual void SetCapabilities(const std::string& capabilities) OVERRIDE;
virtual void SetPairingResponse(
const protocol::PairingResponse& pairing_response) OVERRIDE;
virtual void DeliverHostMessage(
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 protocol::ClipboardEvent& event) OVERRIDE;
// protocol::CursorShapeStub interface.
virtual void SetCursorShape(
const protocol::CursorShapeInfo& cursor_shape) OVERRIDE;
// Called by PepperView.
void SetDesktopSize(const webrtc::DesktopSize& size,
const webrtc::DesktopVector& dpi);
void SetDesktopShape(const webrtc::DesktopRegion& shape);
void OnFirstFrameReceived();
// Return statistics record by ChromotingClient.
// If no connection is currently active then NULL will be returned.
ChromotingStats* GetStats();
// Registers a global log message handler that redirects the log output to
// our plugin instance.
// This is called by the plugin's PPP_InitializeModule.
// Note that no logging will be processed unless a ChromotingInstance has been
// registered for logging (see RegisterLoggingInstance).
static void RegisterLogMessageHandler();
// Registers this instance so it processes messages sent by the global log
// message handler. This overwrites any previously registered instance.
void RegisterLoggingInstance();
// Unregisters this instance so that debug log messages will no longer be sent
// to it. If this instance is not the currently registered logging instance,
// then the currently registered instance will stay in effect.
void UnregisterLoggingInstance();
// A Log Message Handler that is called after each LOG message has been
// processed. This must be of type LogMessageHandlerFunction defined in
// base/logging.h.
static bool LogToUI(int severity, const char* file, int line,
size_t message_start, const std::string& str);
// Requests the webapp to fetch a third-party token.
void FetchThirdPartyToken(
const GURL& token_url,
const std::string& host_public_key,
const std::string& scope,
const base::WeakPtr<PepperTokenFetcher> pepper_token_fetcher);
private:
FRIEND_TEST_ALL_PREFIXES(ChromotingInstanceTest, TestCaseSetup);
// Used as the |FetchSecretCallback| for IT2Me (or Me2Me from old webapps).
// Immediately calls |secret_fetched_callback| with |shared_secret|.
static void FetchSecretFromString(
const std::string& shared_secret,
bool pairing_supported,
const protocol::SecretFetchedCallback& secret_fetched_callback);
// Message handlers for messages that come from JavaScript. Called
// from HandleMessage().
void HandleConnect(const base::DictionaryValue& data);
void HandleDisconnect(const base::DictionaryValue& data);
void HandleOnIncomingIq(const base::DictionaryValue& data);
void HandleReleaseAllKeys(const base::DictionaryValue& data);
void HandleInjectKeyEvent(const base::DictionaryValue& data);
void HandleRemapKey(const base::DictionaryValue& data);
void HandleTrapKey(const base::DictionaryValue& data);
void HandleSendClipboardItem(const base::DictionaryValue& data);
void HandleNotifyClientResolution(const base::DictionaryValue& data);
void HandlePauseVideo(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);
// Helper method to post messages to the webapp.
void PostChromotingMessage(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);
// Callback for DelegatingSignalStrategy.
void SendOutgoingIq(const std::string& iq);
void SendPerfStats();
void ProcessLogToUI(const std::string& message);
// Returns true if the hosting content has the chrome-extension:// scheme.
bool IsCallerAppOrExtension();
// Returns true if there is a ConnectionToHost and it is connected.
bool IsConnected();
// Used as the |FetchSecretCallback| for Me2Me connections.
// Uses the PIN request dialog in the webapp to obtain the shared secret.
void FetchSecretFromDialog(
bool pairing_supported,
const protocol::SecretFetchedCallback& secret_fetched_callback);
bool initialized_;
PepperPluginThreadDelegate plugin_thread_delegate_;
scoped_refptr<PluginThreadTaskRunner> plugin_task_runner_;
ClientContext context_;
scoped_refptr<RectangleUpdateDecoder> rectangle_decoder_;
scoped_ptr<PepperView> view_;
scoped_ptr<base::WeakPtrFactory<FrameConsumer> > view_weak_factory_;
pp::View plugin_view_;
// Contains the most-recently-reported desktop shape, if any.
scoped_ptr<webrtc::DesktopRegion> desktop_shape_;
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.
protocol::MouseInputFilter mouse_input_filter_;
protocol::InputEventTracker input_tracker_;
KeyEventMapper key_mapper_;
scoped_ptr<protocol::InputFilter> normalizing_input_filter_;
PepperInputHandler input_handler_;
// PIN Fetcher.
bool use_async_pin_dialog_;
protocol::SecretFetchedCallback secret_fetched_callback_;
base::WeakPtr<PepperTokenFetcher> pepper_token_fetcher_;
// Weak reference to this instance, used for global logging and task posting.
base::WeakPtrFactory<ChromotingInstance> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(ChromotingInstance);
};
} // namespace remoting
#endif // REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_