// 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.
#include "remoting/client/plugin/chromoting_instance.h"
#include <algorithm>
#include <string>
#include <vector>
#include "base/bind.h"
#include "base/callback.h"
#include "base/json/json_reader.h"
#include "base/json/json_writer.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/strings/string_split.h"
#include "base/strings/stringprintf.h"
#include "base/synchronization/lock.h"
#include "base/threading/thread.h"
#include "base/values.h"
#include "crypto/random.h"
#include "jingle/glue/thread_wrapper.h"
#include "media/base/media.h"
#include "net/socket/ssl_server_socket.h"
#include "ppapi/cpp/completion_callback.h"
#include "ppapi/cpp/dev/url_util_dev.h"
#include "ppapi/cpp/image_data.h"
#include "ppapi/cpp/input_event.h"
#include "ppapi/cpp/rect.h"
#include "remoting/base/constants.h"
#include "remoting/base/util.h"
#include "remoting/client/chromoting_client.h"
#include "remoting/client/client_config.h"
#include "remoting/client/frame_consumer_proxy.h"
#include "remoting/client/plugin/delegating_signal_strategy.h"
#include "remoting/client/plugin/pepper_audio_player.h"
#include "remoting/client/plugin/pepper_input_handler.h"
#include "remoting/client/plugin/pepper_port_allocator.h"
#include "remoting/client/plugin/pepper_token_fetcher.h"
#include "remoting/client/plugin/pepper_view.h"
#include "remoting/client/rectangle_update_decoder.h"
#include "remoting/protocol/connection_to_host.h"
#include "remoting/protocol/host_stub.h"
#include "remoting/protocol/libjingle_transport_factory.h"
#include "third_party/libjingle/source/talk/base/helpers.h"
#include "url/gurl.h"
// Windows defines 'PostMessage', so we have to undef it.
#if defined(PostMessage)
#undef PostMessage
#endif
namespace remoting {
namespace {
// 32-bit BGRA is 4 bytes per pixel.
const int kBytesPerPixel = 4;
#if defined(ARCH_CPU_LITTLE_ENDIAN)
const uint32_t kPixelAlphaMask = 0xff000000;
#else // !defined(ARCH_CPU_LITTLE_ENDIAN)
const uint32_t kPixelAlphaMask = 0x000000ff;
#endif // !defined(ARCH_CPU_LITTLE_ENDIAN)
// Default DPI to assume for old clients that use notifyClientResolution.
const int kDefaultDPI = 96;
// Interval at which to sample performance statistics.
const int kPerfStatsIntervalMs = 1000;
// URL scheme used by Chrome apps and extensions.
const char kChromeExtensionUrlScheme[] = "chrome-extension";
// Maximum width and height of a mouse cursor supported by PPAPI.
const int kMaxCursorWidth = 32;
const int kMaxCursorHeight = 32;
#if defined(USE_OPENSSL)
// Size of the random seed blob used to initialize RNG in libjingle. Libjingle
// uses the seed only for OpenSSL builds. OpenSSL needs at least 32 bytes of
// entropy (see http://wiki.openssl.org/index.php/Random_Numbers), but stores
// 1039 bytes of state, so we initialize it with 1k or random data.
const int kRandomSeedSize = 1024;
#endif // defined(USE_OPENSSL)
std::string ConnectionStateToString(protocol::ConnectionToHost::State state) {
// Values returned by this function must match the
// remoting.ClientSession.State enum in JS code.
switch (state) {
case protocol::ConnectionToHost::INITIALIZING:
return "INITIALIZING";
case protocol::ConnectionToHost::CONNECTING:
return "CONNECTING";
case protocol::ConnectionToHost::AUTHENTICATED:
// Report the authenticated state as 'CONNECTING' to avoid changing
// the interface between the plugin and webapp.
return "CONNECTING";
case protocol::ConnectionToHost::CONNECTED:
return "CONNECTED";
case protocol::ConnectionToHost::CLOSED:
return "CLOSED";
case protocol::ConnectionToHost::FAILED:
return "FAILED";
}
NOTREACHED();
return std::string();
}
// TODO(sergeyu): Ideally we should just pass ErrorCode to the webapp
// and let it handle it, but it would be hard to fix it now because
// client plugin and webapp versions may not be in sync. It should be
// easy to do after we are finished moving the client plugin to NaCl.
std::string ConnectionErrorToString(protocol::ErrorCode error) {
// Values returned by this function must match the
// remoting.ClientSession.Error enum in JS code.
switch (error) {
case protocol::OK:
return "NONE";
case protocol::PEER_IS_OFFLINE:
return "HOST_IS_OFFLINE";
case protocol::SESSION_REJECTED:
case protocol::AUTHENTICATION_FAILED:
return "SESSION_REJECTED";
case protocol::INCOMPATIBLE_PROTOCOL:
return "INCOMPATIBLE_PROTOCOL";
case protocol::HOST_OVERLOAD:
return "HOST_OVERLOAD";
case protocol::CHANNEL_CONNECTION_ERROR:
case protocol::SIGNALING_ERROR:
case protocol::SIGNALING_TIMEOUT:
case protocol::UNKNOWN_ERROR:
return "NETWORK_FAILURE";
}
DLOG(FATAL) << "Unknown error code" << error;
return std::string();
}
// Returns true if |pixel| is not completely transparent.
bool IsVisiblePixel(uint32_t pixel) {
return (pixel & kPixelAlphaMask) != 0;
}
// Returns true if there is at least one visible pixel in the given range.
bool IsVisibleRow(const uint32_t* begin, const uint32_t* end) {
return std::find_if(begin, end, &IsVisiblePixel) != end;
}
// This flag blocks LOGs to the UI if we're already in the middle of logging
// to the UI. This prevents a potential infinite loop if we encounter an error
// while sending the log message to the UI.
bool g_logging_to_plugin = false;
bool g_has_logging_instance = false;
base::LazyInstance<scoped_refptr<base::SingleThreadTaskRunner> >::Leaky
g_logging_task_runner = LAZY_INSTANCE_INITIALIZER;
base::LazyInstance<base::WeakPtr<ChromotingInstance> >::Leaky
g_logging_instance = LAZY_INSTANCE_INITIALIZER;
base::LazyInstance<base::Lock>::Leaky
g_logging_lock = LAZY_INSTANCE_INITIALIZER;
logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
} // namespace
// String sent in the "hello" message to the webapp to describe features.
const char ChromotingInstance::kApiFeatures[] =
"highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey "
"notifyClientResolution pauseVideo pauseAudio asyncPin thirdPartyAuth "
"pinlessAuth extensionMessage allowMouseLock";
const char ChromotingInstance::kRequestedCapabilities[] = "";
const char ChromotingInstance::kSupportedCapabilities[] = "desktopShape";
bool ChromotingInstance::ParseAuthMethods(const std::string& auth_methods_str,
ClientConfig* config) {
std::vector<std::string> auth_methods;
base::SplitString(auth_methods_str, ',', &auth_methods);
for (std::vector<std::string>::iterator it = auth_methods.begin();
it != auth_methods.end(); ++it) {
protocol::AuthenticationMethod authentication_method =
protocol::AuthenticationMethod::FromString(*it);
if (authentication_method.is_valid())
config->authentication_methods.push_back(authentication_method);
}
if (config->authentication_methods.empty()) {
LOG(ERROR) << "No valid authentication methods specified.";
return false;
}
return true;
}
ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
: pp::Instance(pp_instance),
initialized_(false),
plugin_task_runner_(new PluginThreadTaskRunner(&plugin_thread_delegate_)),
context_(plugin_task_runner_.get()),
input_tracker_(&mouse_input_filter_),
key_mapper_(&input_tracker_),
normalizing_input_filter_(CreateNormalizingInputFilter(&key_mapper_)),
input_handler_(this, normalizing_input_filter_.get()),
use_async_pin_dialog_(false),
weak_factory_(this) {
RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_WHEEL);
RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
// Resister this instance to handle debug log messsages.
RegisterLoggingInstance();
#if defined(USE_OPENSSL)
// Initialize random seed for libjingle. It's necessary only with OpenSSL.
char random_seed[kRandomSeedSize];
crypto::RandBytes(random_seed, sizeof(random_seed));
talk_base::InitRandom(random_seed, sizeof(random_seed));
#endif // defined(USE_OPENSSL)
// Send hello message.
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetInteger("apiVersion", kApiVersion);
data->SetString("apiFeatures", kApiFeatures);
data->SetInteger("apiMinVersion", kApiMinMessagingVersion);
data->SetString("requestedCapabilities", kRequestedCapabilities);
data->SetString("supportedCapabilities", kSupportedCapabilities);
PostChromotingMessage("hello", data.Pass());
}
ChromotingInstance::~ChromotingInstance() {
DCHECK(plugin_task_runner_->BelongsToCurrentThread());
// Unregister this instance so that debug log messages will no longer be sent
// to it. This will stop all logging in all Chromoting instances.
UnregisterLoggingInstance();
// PepperView must be destroyed before the client.
view_weak_factory_.reset();
view_.reset();
client_.reset();
plugin_task_runner_->Quit();
// Ensure that nothing touches the plugin thread delegate after this point.
plugin_task_runner_->DetachAndRunShutdownLoop();
// Stopping the context shuts down all chromoting threads.
context_.Stop();
}
bool ChromotingInstance::Init(uint32_t argc,
const char* argn[],
const char* argv[]) {
CHECK(!initialized_);
initialized_ = true;
VLOG(1) << "Started ChromotingInstance::Init";
// Check to make sure the media library is initialized.
// http://crbug.com/91521.
if (!media::IsMediaLibraryInitialized()) {
LOG(ERROR) << "Media library not initialized.";
return false;
}
// Check that the calling content is part of an app or extension.
if (!IsCallerAppOrExtension()) {
LOG(ERROR) << "Not an app or extension";
return false;
}
// Enable support for SSL server sockets, which must be done as early as
// possible, preferably before any NSS SSL sockets (client or server) have
// been created.
// It's possible that the hosting process has already made use of SSL, in
// which case, there may be a slight race.
net::EnableSSLServerSockets();
// Start all the threads.
context_.Start();
return true;
}
void ChromotingInstance::HandleMessage(const pp::Var& message) {
if (!message.is_string()) {
LOG(ERROR) << "Received a message that is not a string.";
return;
}
scoped_ptr<base::Value> json(
base::JSONReader::Read(message.AsString(),
base::JSON_ALLOW_TRAILING_COMMAS));
base::DictionaryValue* message_dict = NULL;
std::string method;
base::DictionaryValue* data = NULL;
if (!json.get() ||
!json->GetAsDictionary(&message_dict) ||
!message_dict->GetString("method", &method) ||
!message_dict->GetDictionary("data", &data)) {
LOG(ERROR) << "Received invalid message:" << message.AsString();
return;
}
if (method == "connect") {
HandleConnect(*data);
} else if (method == "disconnect") {
HandleDisconnect(*data);
} else if (method == "incomingIq") {
HandleOnIncomingIq(*data);
} else if (method == "releaseAllKeys") {
HandleReleaseAllKeys(*data);
} else if (method == "injectKeyEvent") {
HandleInjectKeyEvent(*data);
} else if (method == "remapKey") {
HandleRemapKey(*data);
} else if (method == "trapKey") {
HandleTrapKey(*data);
} else if (method == "sendClipboardItem") {
HandleSendClipboardItem(*data);
} else if (method == "notifyClientResolution") {
HandleNotifyClientResolution(*data);
} else if (method == "pauseVideo") {
HandlePauseVideo(*data);
} else if (method == "pauseAudio") {
HandlePauseAudio(*data);
} else if (method == "useAsyncPinDialog") {
use_async_pin_dialog_ = true;
} else if (method == "onPinFetched") {
HandleOnPinFetched(*data);
} else if (method == "onThirdPartyTokenFetched") {
HandleOnThirdPartyTokenFetched(*data);
} else if (method == "requestPairing") {
HandleRequestPairing(*data);
} else if (method == "extensionMessage") {
HandleExtensionMessage(*data);
} else if (method == "allowMouseLock") {
HandleAllowMouseLockMessage();
}
}
void ChromotingInstance::DidChangeFocus(bool has_focus) {
DCHECK(plugin_task_runner_->BelongsToCurrentThread());
input_handler_.DidChangeFocus(has_focus);
}
void ChromotingInstance::DidChangeView(const pp::View& view) {
DCHECK(plugin_task_runner_->BelongsToCurrentThread());
plugin_view_ = view;
if (view_) {
view_->SetView(view);
mouse_input_filter_.set_input_size(view_->get_view_size_dips());
}
}
bool ChromotingInstance::HandleInputEvent(const pp::InputEvent& event) {
DCHECK(plugin_task_runner_->BelongsToCurrentThread());
if (!IsConnected())
return false;
return input_handler_.HandleInputEvent(event);
}
void ChromotingInstance::SetDesktopSize(const webrtc::DesktopSize& size,
const webrtc::DesktopVector& dpi) {
mouse_input_filter_.set_output_size(size);
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetInteger("width", size.width());
data->SetInteger("height", size.height());
if (dpi.x())
data->SetInteger("x_dpi", dpi.x());
if (dpi.y())
data->SetInteger("y_dpi", dpi.y());
PostChromotingMessage("onDesktopSize", data.Pass());
}
void ChromotingInstance::SetDesktopShape(const webrtc::DesktopRegion& shape) {
if (desktop_shape_ && shape.Equals(*desktop_shape_))
return;
desktop_shape_.reset(new webrtc::DesktopRegion(shape));
scoped_ptr<base::ListValue> rects_value(new base::ListValue());
for (webrtc::DesktopRegion::Iterator i(shape); !i.IsAtEnd(); i.Advance()) {
const webrtc::DesktopRect& rect = i.rect();
scoped_ptr<base::ListValue> rect_value(new base::ListValue());
rect_value->AppendInteger(rect.left());
rect_value->AppendInteger(rect.top());
rect_value->AppendInteger(rect.width());
rect_value->AppendInteger(rect.height());
rects_value->Append(rect_value.release());
}
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->Set("rects", rects_value.release());
PostChromotingMessage("onDesktopShape", data.Pass());
}
void ChromotingInstance::OnConnectionState(
protocol::ConnectionToHost::State state,
protocol::ErrorCode error) {
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetString("state", ConnectionStateToString(state));
data->SetString("error", ConnectionErrorToString(error));
PostChromotingMessage("onConnectionStatus", data.Pass());
}
void ChromotingInstance::FetchThirdPartyToken(
const GURL& token_url,
const std::string& host_public_key,
const std::string& scope,
base::WeakPtr<PepperTokenFetcher> pepper_token_fetcher) {
// Once the Session object calls this function, it won't continue the
// authentication until the callback is called (or connection is canceled).
// So, it's impossible to reach this with a callback already registered.
DCHECK(!pepper_token_fetcher_.get());
pepper_token_fetcher_ = pepper_token_fetcher;
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetString("tokenUrl", token_url.spec());
data->SetString("hostPublicKey", host_public_key);
data->SetString("scope", scope);
PostChromotingMessage("fetchThirdPartyToken", data.Pass());
}
void ChromotingInstance::OnConnectionReady(bool ready) {
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetBoolean("ready", ready);
PostChromotingMessage("onConnectionReady", data.Pass());
}
void ChromotingInstance::SetCapabilities(const std::string& capabilities) {
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetString("capabilities", capabilities);
PostChromotingMessage("setCapabilities", data.Pass());
}
void ChromotingInstance::SetPairingResponse(
const protocol::PairingResponse& pairing_response) {
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetString("clientId", pairing_response.client_id());
data->SetString("sharedSecret", pairing_response.shared_secret());
PostChromotingMessage("pairingResponse", data.Pass());
}
void ChromotingInstance::DeliverHostMessage(
const protocol::ExtensionMessage& message) {
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetString("type", message.type());
data->SetString("data", message.data());
PostChromotingMessage("extensionMessage", data.Pass());
}
void ChromotingInstance::FetchSecretFromDialog(
bool pairing_supported,
const protocol::SecretFetchedCallback& secret_fetched_callback) {
// Once the Session object calls this function, it won't continue the
// authentication until the callback is called (or connection is canceled).
// So, it's impossible to reach this with a callback already registered.
DCHECK(secret_fetched_callback_.is_null());
secret_fetched_callback_ = secret_fetched_callback;
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetBoolean("pairingSupported", pairing_supported);
PostChromotingMessage("fetchPin", data.Pass());
}
void ChromotingInstance::FetchSecretFromString(
const std::string& shared_secret,
bool pairing_supported,
const protocol::SecretFetchedCallback& secret_fetched_callback) {
secret_fetched_callback.Run(shared_secret);
}
protocol::ClipboardStub* ChromotingInstance::GetClipboardStub() {
// TODO(sergeyu): Move clipboard handling to a separate class.
// crbug.com/138108
return this;
}
protocol::CursorShapeStub* ChromotingInstance::GetCursorShapeStub() {
// TODO(sergeyu): Move cursor shape code to a separate class.
// crbug.com/138108
return this;
}
scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
ChromotingInstance::GetTokenFetcher(const std::string& host_public_key) {
return scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>(
new PepperTokenFetcher(weak_factory_.GetWeakPtr(), host_public_key));
}
void ChromotingInstance::InjectClipboardEvent(
const protocol::ClipboardEvent& event) {
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetString("mimeType", event.mime_type());
data->SetString("item", event.data());
PostChromotingMessage("injectClipboardItem", data.Pass());
}
void ChromotingInstance::SetCursorShape(
const protocol::CursorShapeInfo& cursor_shape) {
COMPILE_ASSERT(sizeof(uint32_t) == kBytesPerPixel, rgba_pixels_are_32bit);
// pp::MouseCursor requires image to be in the native format.
if (pp::ImageData::GetNativeImageDataFormat() !=
PP_IMAGEDATAFORMAT_BGRA_PREMUL) {
LOG(WARNING) << "Unable to set cursor shape - native image format is not"
" premultiplied BGRA";
return;
}
int width = cursor_shape.width();
int height = cursor_shape.height();
int hotspot_x = cursor_shape.hotspot_x();
int hotspot_y = cursor_shape.hotspot_y();
int bytes_per_row = width * kBytesPerPixel;
int src_stride = width;
const uint32_t* src_row_data = reinterpret_cast<const uint32_t*>(
cursor_shape.data().data());
const uint32_t* src_row_data_end = src_row_data + src_stride * height;
scoped_ptr<pp::ImageData> cursor_image;
pp::Point cursor_hotspot;
// Check if the cursor is visible.
if (IsVisibleRow(src_row_data, src_row_data_end)) {
// If the cursor exceeds the size permitted by PPAPI then crop it, keeping
// the hotspot as close to the center of the new cursor shape as possible.
if (height > kMaxCursorHeight) {
int y = hotspot_y - (kMaxCursorHeight / 2);
y = std::max(y, 0);
y = std::min(y, height - kMaxCursorHeight);
src_row_data += src_stride * y;
height = kMaxCursorHeight;
hotspot_y -= y;
}
if (width > kMaxCursorWidth) {
int x = hotspot_x - (kMaxCursorWidth / 2);
x = std::max(x, 0);
x = std::min(x, height - kMaxCursorWidth);
src_row_data += x;
width = kMaxCursorWidth;
bytes_per_row = width * kBytesPerPixel;
hotspot_x -= x;
}
cursor_image.reset(new pp::ImageData(this, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
pp::Size(width, height), false));
cursor_hotspot = pp::Point(hotspot_x, hotspot_y);
uint8* dst_row_data = reinterpret_cast<uint8*>(cursor_image->data());
for (int row = 0; row < height; row++) {
memcpy(dst_row_data, src_row_data, bytes_per_row);
src_row_data += src_stride;
dst_row_data += cursor_image->stride();
}
}
input_handler_.SetMouseCursor(cursor_image.Pass(), cursor_hotspot);
}
void ChromotingInstance::OnFirstFrameReceived() {
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
PostChromotingMessage("onFirstFrameReceived", data.Pass());
}
void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) {
ClientConfig config;
std::string local_jid;
std::string auth_methods;
if (!data.GetString("hostJid", &config.host_jid) ||
!data.GetString("hostPublicKey", &config.host_public_key) ||
!data.GetString("localJid", &local_jid) ||
!data.GetString("authenticationMethods", &auth_methods) ||
!ParseAuthMethods(auth_methods, &config) ||
!data.GetString("authenticationTag", &config.authentication_tag)) {
LOG(ERROR) << "Invalid connect() data.";
return;
}
data.GetString("clientPairingId", &config.client_pairing_id);
data.GetString("clientPairedSecret", &config.client_paired_secret);
if (use_async_pin_dialog_) {
config.fetch_secret_callback =
base::Bind(&ChromotingInstance::FetchSecretFromDialog,
weak_factory_.GetWeakPtr());
} else {
std::string shared_secret;
if (!data.GetString("sharedSecret", &shared_secret)) {
LOG(ERROR) << "sharedSecret not specified in connect().";
return;
}
config.fetch_secret_callback =
base::Bind(&ChromotingInstance::FetchSecretFromString, shared_secret);
}
// Read the list of capabilities, if any.
if (data.HasKey("capabilities")) {
if (!data.GetString("capabilities", &config.capabilities)) {
LOG(ERROR) << "Invalid connect() data.";
return;
}
}
ConnectWithConfig(config, local_jid);
}
void ChromotingInstance::ConnectWithConfig(const ClientConfig& config,
const std::string& local_jid) {
DCHECK(plugin_task_runner_->BelongsToCurrentThread());
jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
view_.reset(new PepperView(this, &context_));
view_weak_factory_.reset(
new base::WeakPtrFactory<FrameConsumer>(view_.get()));
// RectangleUpdateDecoder runs on a separate thread so for now we wrap
// PepperView with a ref-counted proxy object.
scoped_refptr<FrameConsumerProxy> consumer_proxy =
new FrameConsumerProxy(plugin_task_runner_,
view_weak_factory_->GetWeakPtr());
host_connection_.reset(new protocol::ConnectionToHost(true));
scoped_ptr<AudioPlayer> audio_player(new PepperAudioPlayer(this));
client_.reset(new ChromotingClient(config, &context_,
host_connection_.get(), this,
consumer_proxy, audio_player.Pass()));
view_->Initialize(client_->GetFrameProducer());
if (!plugin_view_.is_null()) {
view_->SetView(plugin_view_);
}
// Connect the input pipeline to the protocol stub & initialize components.
mouse_input_filter_.set_input_stub(host_connection_->input_stub());
mouse_input_filter_.set_input_size(view_->get_view_size_dips());
VLOG(0) << "Connecting to " << config.host_jid
<< ". Local jid: " << local_jid << ".";
// Setup the signal strategy.
signal_strategy_.reset(new DelegatingSignalStrategy(
local_jid, base::Bind(&ChromotingInstance::SendOutgoingIq,
weak_factory_.GetWeakPtr())));
scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator(
PepperPortAllocator::Create(this));
scoped_ptr<protocol::TransportFactory> transport_factory(
new protocol::LibjingleTransportFactory(
signal_strategy_.get(), port_allocator.Pass(),
NetworkSettings(NetworkSettings::NAT_TRAVERSAL_ENABLED)));
// Kick off the connection.
client_->Start(signal_strategy_.get(), transport_factory.Pass());
// Start timer that periodically sends perf stats.
plugin_task_runner_->PostDelayedTask(
FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats,
weak_factory_.GetWeakPtr()),
base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
}
void ChromotingInstance::HandleDisconnect(const base::DictionaryValue& data) {
DCHECK(plugin_task_runner_->BelongsToCurrentThread());
// PepperView must be destroyed before the client.
view_weak_factory_.reset();
view_.reset();
VLOG(0) << "Disconnecting from host.";
client_.reset();
// Disconnect the input pipeline and teardown the connection.
mouse_input_filter_.set_input_stub(NULL);
host_connection_.reset();
}
void ChromotingInstance::HandleOnIncomingIq(const base::DictionaryValue& data) {
std::string iq;
if (!data.GetString("iq", &iq)) {
LOG(ERROR) << "Invalid incomingIq() data.";
return;
}
// Just ignore the message if it's received before Connect() is called. It's
// likely to be a leftover from a previous session, so it's safe to ignore it.
if (signal_strategy_)
signal_strategy_->OnIncomingMessage(iq);
}
void ChromotingInstance::HandleReleaseAllKeys(
const base::DictionaryValue& data) {
if (IsConnected())
input_tracker_.ReleaseAll();
}
void ChromotingInstance::HandleInjectKeyEvent(
const base::DictionaryValue& data) {
int usb_keycode = 0;
bool is_pressed = false;
if (!data.GetInteger("usbKeycode", &usb_keycode) ||
!data.GetBoolean("pressed", &is_pressed)) {
LOG(ERROR) << "Invalid injectKeyEvent.";
return;
}
protocol::KeyEvent event;
event.set_usb_keycode(usb_keycode);
event.set_pressed(is_pressed);
// Inject after the KeyEventMapper, so the event won't get mapped or trapped.
if (IsConnected())
input_tracker_.InjectKeyEvent(event);
}
void ChromotingInstance::HandleRemapKey(const base::DictionaryValue& data) {
int from_keycode = 0;
int to_keycode = 0;
if (!data.GetInteger("fromKeycode", &from_keycode) ||
!data.GetInteger("toKeycode", &to_keycode)) {
LOG(ERROR) << "Invalid remapKey.";
return;
}
key_mapper_.RemapKey(from_keycode, to_keycode);
}
void ChromotingInstance::HandleTrapKey(const base::DictionaryValue& data) {
int keycode = 0;
bool trap = false;
if (!data.GetInteger("keycode", &keycode) ||
!data.GetBoolean("trap", &trap)) {
LOG(ERROR) << "Invalid trapKey.";
return;
}
key_mapper_.TrapKey(keycode, trap);
}
void ChromotingInstance::HandleSendClipboardItem(
const base::DictionaryValue& data) {
std::string mime_type;
std::string item;
if (!data.GetString("mimeType", &mime_type) ||
!data.GetString("item", &item)) {
LOG(ERROR) << "Invalid sendClipboardItem data.";
return;
}
if (!IsConnected()) {
return;
}
protocol::ClipboardEvent event;
event.set_mime_type(mime_type);
event.set_data(item);
host_connection_->clipboard_stub()->InjectClipboardEvent(event);
}
void ChromotingInstance::HandleNotifyClientResolution(
const base::DictionaryValue& data) {
int width = 0;
int height = 0;
int x_dpi = kDefaultDPI;
int y_dpi = kDefaultDPI;
if (!data.GetInteger("width", &width) ||
!data.GetInteger("height", &height) ||
!data.GetInteger("x_dpi", &x_dpi) ||
!data.GetInteger("y_dpi", &y_dpi) ||
width <= 0 || height <= 0 ||
x_dpi <= 0 || y_dpi <= 0) {
LOG(ERROR) << "Invalid notifyClientResolution.";
return;
}
if (!IsConnected()) {
return;
}
protocol::ClientResolution client_resolution;
client_resolution.set_width(width);
client_resolution.set_height(height);
client_resolution.set_x_dpi(x_dpi);
client_resolution.set_y_dpi(y_dpi);
// Include the legacy width & height in DIPs for use by older hosts.
client_resolution.set_dips_width((width * kDefaultDPI) / x_dpi);
client_resolution.set_dips_height((height * kDefaultDPI) / y_dpi);
host_connection_->host_stub()->NotifyClientResolution(client_resolution);
}
void ChromotingInstance::HandlePauseVideo(const base::DictionaryValue& data) {
bool pause = false;
if (!data.GetBoolean("pause", &pause)) {
LOG(ERROR) << "Invalid pauseVideo.";
return;
}
if (!IsConnected()) {
return;
}
protocol::VideoControl video_control;
video_control.set_enable(!pause);
host_connection_->host_stub()->ControlVideo(video_control);
}
void ChromotingInstance::HandlePauseAudio(const base::DictionaryValue& data) {
bool pause = false;
if (!data.GetBoolean("pause", &pause)) {
LOG(ERROR) << "Invalid pauseAudio.";
return;
}
if (!IsConnected()) {
return;
}
protocol::AudioControl audio_control;
audio_control.set_enable(!pause);
host_connection_->host_stub()->ControlAudio(audio_control);
}
void ChromotingInstance::HandleOnPinFetched(const base::DictionaryValue& data) {
std::string pin;
if (!data.GetString("pin", &pin)) {
LOG(ERROR) << "Invalid onPinFetched.";
return;
}
if (!secret_fetched_callback_.is_null()) {
secret_fetched_callback_.Run(pin);
secret_fetched_callback_.Reset();
} else {
LOG(WARNING) << "Ignored OnPinFetched received without a pending fetch.";
}
}
void ChromotingInstance::HandleOnThirdPartyTokenFetched(
const base::DictionaryValue& data) {
std::string token;
std::string shared_secret;
if (!data.GetString("token", &token) ||
!data.GetString("sharedSecret", &shared_secret)) {
LOG(ERROR) << "Invalid onThirdPartyTokenFetched data.";
return;
}
if (pepper_token_fetcher_.get()) {
pepper_token_fetcher_->OnTokenFetched(token, shared_secret);
pepper_token_fetcher_.reset();
} else {
LOG(WARNING) << "Ignored OnThirdPartyTokenFetched without a pending fetch.";
}
}
void ChromotingInstance::HandleRequestPairing(
const base::DictionaryValue& data) {
std::string client_name;
if (!data.GetString("clientName", &client_name)) {
LOG(ERROR) << "Invalid requestPairing";
return;
}
if (!IsConnected()) {
return;
}
protocol::PairingRequest pairing_request;
pairing_request.set_client_name(client_name);
host_connection_->host_stub()->RequestPairing(pairing_request);
}
void ChromotingInstance::HandleExtensionMessage(
const base::DictionaryValue& data) {
std::string type;
std::string message_data;
if (!data.GetString("type", &type) ||
!data.GetString("data", &message_data)) {
LOG(ERROR) << "Invalid extensionMessage.";
return;
}
if (!IsConnected()) {
return;
}
protocol::ExtensionMessage message;
message.set_type(type);
message.set_data(message_data);
host_connection_->host_stub()->DeliverClientMessage(message);
}
void ChromotingInstance::HandleAllowMouseLockMessage() {
input_handler_.AllowMouseLock();
}
ChromotingStats* ChromotingInstance::GetStats() {
if (!client_.get())
return NULL;
return client_->GetStats();
}
void ChromotingInstance::PostChromotingMessage(
const std::string& method,
scoped_ptr<base::DictionaryValue> data) {
scoped_ptr<base::DictionaryValue> message(new base::DictionaryValue());
message->SetString("method", method);
message->Set("data", data.release());
std::string message_json;
base::JSONWriter::Write(message.get(), &message_json);
PostMessage(pp::Var(message_json));
}
void ChromotingInstance::SendTrappedKey(uint32 usb_keycode, bool pressed) {
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetInteger("usbKeycode", usb_keycode);
data->SetBoolean("pressed", pressed);
PostChromotingMessage("trappedKeyEvent", data.Pass());
}
void ChromotingInstance::SendOutgoingIq(const std::string& iq) {
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetString("iq", iq);
PostChromotingMessage("sendOutgoingIq", data.Pass());
}
void ChromotingInstance::SendPerfStats() {
if (!client_.get()) {
return;
}
plugin_task_runner_->PostDelayedTask(
FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats,
weak_factory_.GetWeakPtr()),
base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
ChromotingStats* stats = client_->GetStats();
data->SetDouble("videoBandwidth", stats->video_bandwidth()->Rate());
data->SetDouble("videoFrameRate", stats->video_frame_rate()->Rate());
data->SetDouble("captureLatency", stats->video_capture_ms()->Average());
data->SetDouble("encodeLatency", stats->video_encode_ms()->Average());
data->SetDouble("decodeLatency", stats->video_decode_ms()->Average());
data->SetDouble("renderLatency", stats->video_paint_ms()->Average());
data->SetDouble("roundtripLatency", stats->round_trip_ms()->Average());
PostChromotingMessage("onPerfStats", data.Pass());
}
// static
void ChromotingInstance::RegisterLogMessageHandler() {
base::AutoLock lock(g_logging_lock.Get());
VLOG(1) << "Registering global log handler";
// Record previous handler so we can call it in a chain.
g_logging_old_handler = logging::GetLogMessageHandler();
// Set up log message handler.
// This is not thread-safe so we need it within our lock.
logging::SetLogMessageHandler(&LogToUI);
}
void ChromotingInstance::RegisterLoggingInstance() {
base::AutoLock lock(g_logging_lock.Get());
// Register this instance as the one that will handle all logging calls
// and display them to the user.
// If multiple plugins are run, then the last one registered will handle all
// logging for all instances.
g_logging_instance.Get() = weak_factory_.GetWeakPtr();
g_logging_task_runner.Get() = plugin_task_runner_;
g_has_logging_instance = true;
}
void ChromotingInstance::UnregisterLoggingInstance() {
base::AutoLock lock(g_logging_lock.Get());
// Don't unregister unless we're the currently registered instance.
if (this != g_logging_instance.Get().get())
return;
// Unregister this instance for logging.
g_has_logging_instance = false;
g_logging_instance.Get().reset();
g_logging_task_runner.Get() = NULL;
VLOG(1) << "Unregistering global log handler";
}
// static
bool ChromotingInstance::LogToUI(int severity, const char* file, int line,
size_t message_start,
const std::string& str) {
// Note that we're reading |g_has_logging_instance| outside of a lock.
// This lockless read is done so that we don't needlessly slow down global
// logging with a lock for each log message.
//
// This lockless read is safe because:
//
// Misreading a false value (when it should be true) means that we'll simply
// skip processing a few log messages.
//
// Misreading a true value (when it should be false) means that we'll take
// the lock and check |g_logging_instance| unnecessarily. This is not
// problematic because we always set |g_logging_instance| inside a lock.
if (g_has_logging_instance) {
scoped_refptr<base::SingleThreadTaskRunner> logging_task_runner;
base::WeakPtr<ChromotingInstance> logging_instance;
{
base::AutoLock lock(g_logging_lock.Get());
// If we're on the logging thread and |g_logging_to_plugin| is set then
// this LOG message came from handling a previous LOG message and we
// should skip it to avoid an infinite loop of LOG messages.
if (!g_logging_task_runner.Get()->BelongsToCurrentThread() ||
!g_logging_to_plugin) {
logging_task_runner = g_logging_task_runner.Get();
logging_instance = g_logging_instance.Get();
}
}
if (logging_task_runner.get()) {
std::string message = remoting::GetTimestampString();
message += (str.c_str() + message_start);
logging_task_runner->PostTask(
FROM_HERE, base::Bind(&ChromotingInstance::ProcessLogToUI,
logging_instance, message));
}
}
if (g_logging_old_handler)
return (g_logging_old_handler)(severity, file, line, message_start, str);
return false;
}
void ChromotingInstance::ProcessLogToUI(const std::string& message) {
DCHECK(plugin_task_runner_->BelongsToCurrentThread());
// This flag (which is set only here) is used to prevent LogToUI from posting
// new tasks while we're in the middle of servicing a LOG call. This can
// happen if the call to LogDebugInfo tries to LOG anything.
// Since it is read on the plugin thread, we don't need to lock to set it.
g_logging_to_plugin = true;
scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
data->SetString("message", message);
PostChromotingMessage("logDebugMessage", data.Pass());
g_logging_to_plugin = false;
}
bool ChromotingInstance::IsCallerAppOrExtension() {
const pp::URLUtil_Dev* url_util = pp::URLUtil_Dev::Get();
if (!url_util)
return false;
PP_URLComponents_Dev url_components;
pp::Var url_var = url_util->GetDocumentURL(this, &url_components);
if (!url_var.is_string())
return false;
std::string url = url_var.AsString();
std::string url_scheme = url.substr(url_components.scheme.begin,
url_components.scheme.len);
return url_scheme == kChromeExtensionUrlScheme;
}
bool ChromotingInstance::IsConnected() {
return host_connection_.get() &&
(host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
}
} // namespace remoting