#include "base/memory/ref_counted.h"
#include "build/build_config.h"
+#include "media/base/limits.h"
#include "ppapi/c/pp_errors.h"
#include "ppapi/c/pp_time.h"
#include "ppapi/c/pp_var.h"
#include "ppapi/proxy/browser_font_singleton_resource.h"
#include "ppapi/proxy/content_decryptor_private_serializer.h"
#include "ppapi/proxy/enter_proxy.h"
-#include "ppapi/proxy/extensions_common_resource.h"
#include "ppapi/proxy/file_mapping_resource.h"
#include "ppapi/proxy/flash_clipboard_resource.h"
#include "ppapi/proxy/flash_file_resource.h"
#include "ppapi/proxy/gamepad_resource.h"
#include "ppapi/proxy/host_dispatcher.h"
#include "ppapi/proxy/isolated_file_system_private_resource.h"
+#include "ppapi/proxy/message_handler.h"
#include "ppapi/proxy/network_proxy_resource.h"
#include "ppapi/proxy/pdf_resource.h"
#include "ppapi/proxy/plugin_dispatcher.h"
#include "ppapi/proxy/serialized_var.h"
#include "ppapi/proxy/truetype_font_singleton_resource.h"
#include "ppapi/proxy/uma_private_resource.h"
+#include "ppapi/shared_impl/array_var.h"
#include "ppapi/shared_impl/ppapi_globals.h"
#include "ppapi/shared_impl/ppb_url_util_shared.h"
#include "ppapi/shared_impl/ppb_view_shared.h"
+#include "ppapi/shared_impl/scoped_pp_var.h"
#include "ppapi/shared_impl/var.h"
#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_compositor_api.h"
#include "ppapi/thunk/ppb_graphics_2d_api.h"
#include "ppapi/thunk/ppb_graphics_3d_api.h"
#include "ppapi/thunk/thunk.h"
using ppapi::thunk::EnterInstanceNoLock;
using ppapi::thunk::EnterResourceNoLock;
+using ppapi::thunk::PPB_Compositor_API;
using ppapi::thunk::PPB_Graphics2D_API;
using ppapi::thunk::PPB_Graphics3D_API;
using ppapi::thunk::PPB_Instance_API;
OnHostMsgNumberOfFindResultsChanged)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SelectFindResultChanged,
OnHostMsgSelectFindResultChanged)
+ IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetTickmarks,
+ OnHostMsgSetTickmarks)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PostMessage,
OnHostMsgPostMessage)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetFullscreen,
OnHostMsgRequestInputEvents)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ClearInputEvents,
OnHostMsgClearInputEvents)
+ IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_StartTrackingLatency,
+ OnHostMsgStartTrackingLatency)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_LockMouse,
OnHostMsgLockMouse)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UnlockMouse,
OnHostMsgGetPluginInstanceURL)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginReferrerURL,
OnHostMsgGetPluginReferrerURL)
- IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionCreated,
- OnHostMsgSessionCreated)
+ IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseResolved,
+ OnHostMsgPromiseResolved)
+ IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseResolvedWithSession,
+ OnHostMsgPromiseResolvedWithSession)
+ IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseResolvedWithKeyIds,
+ OnHostMsgPromiseResolvedWithKeyIds)
+ IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseRejected,
+ OnHostMsgPromiseRejected)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionMessage,
OnHostMsgSessionMessage)
+ IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionKeysChange,
+ OnHostMsgSessionKeysChange)
+ IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionExpirationChange,
+ OnHostMsgSessionExpirationChange)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionReady,
OnHostMsgSessionReady)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionClosed,
PP_Resource device) {
// If device is 0, pass a null HostResource. This signals the host to unbind
// all devices.
- HostResource host_resource;
PP_Resource pp_resource = 0;
if (device) {
Resource* resource =
PpapiGlobals::Get()->GetResourceTracker()->GetResource(device);
if (!resource || resource->pp_instance() != instance)
return PP_FALSE;
- host_resource = resource->host_resource();
- pp_resource = resource->pp_resource();
- } else {
- // Passing 0 means unbinding all devices.
- dispatcher()->Send(new PpapiHostMsg_PPBInstance_BindGraphics(
- API_ID_PPB_INSTANCE, instance, 0));
- return PP_TRUE;
+ // We need to pass different resource to Graphics 2D, 3D and Compositor
+ // right now. Once 3D is migrated to the new design, we should be able to
+ // unify this.
+ if (resource->AsPPB_Graphics3D_API()) {
+ pp_resource = resource->host_resource().host_resource();
+ } else if (resource->AsPPB_Graphics2D_API() ||
+ resource->AsPPB_Compositor_API()) {
+ pp_resource = resource->pp_resource();
+ } else {
+ // A bad resource.
+ return PP_FALSE;
+ }
}
-
- // We need to pass different resource to Graphics 2D and 3D right now. Once
- // 3D is migrated to the new design, we should be able to unify this.
- EnterResourceNoLock<PPB_Graphics2D_API> enter_2d(device, false);
- EnterResourceNoLock<PPB_Graphics3D_API> enter_3d(device, false);
- if (enter_2d.succeeded()) {
- dispatcher()->Send(new PpapiHostMsg_PPBInstance_BindGraphics(
+ dispatcher()->Send(new PpapiHostMsg_PPBInstance_BindGraphics(
API_ID_PPB_INSTANCE, instance, pp_resource));
- return PP_TRUE;
- } else if (enter_3d.succeeded()) {
- dispatcher()->Send(new PpapiHostMsg_PPBInstance_BindGraphics(
- API_ID_PPB_INSTANCE, instance, host_resource.host_resource()));
- return PP_TRUE;
- }
- return PP_FALSE;
+ return PP_TRUE;
}
PP_Bool PPB_Instance_Proxy::IsFullFrame(PP_Instance instance) {
API_ID_PPB_INSTANCE, instance, index));
}
+void PPB_Instance_Proxy::SetTickmarks(PP_Instance instance,
+ const PP_Rect* tickmarks,
+ uint32_t count) {
+ dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetTickmarks(
+ API_ID_PPB_INSTANCE, instance,
+ std::vector<PP_Rect>(tickmarks, tickmarks + count)));
+}
+
PP_Bool PPB_Instance_Proxy::IsFullscreen(PP_Instance instance) {
InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
GetInstanceData(instance);
case BROKER_SINGLETON_ID:
new_singleton = new BrokerResource(connection, instance);
break;
- case EXTENSIONS_COMMON_SINGLETON_ID:
- new_singleton = new ExtensionsCommonResource(connection, instance);
- break;
case FILE_MAPPING_SINGLETON_ID:
new_singleton = new FileMappingResource(connection, instance);
break;
API_ID_PPB_INSTANCE, instance, event_classes));
}
+void PPB_Instance_Proxy::StartTrackingLatency(PP_Instance instance) {
+ dispatcher()->Send(new PpapiHostMsg_PPBInstance_StartTrackingLatency(
+ API_ID_PPB_INSTANCE, instance));
+}
+
void PPB_Instance_Proxy::ZoomChanged(PP_Instance instance,
double factor) {
// Not proxied yet.
PP_Var PPB_Instance_Proxy::GetDocumentURL(PP_Instance instance,
PP_URLComponents_Dev* components) {
ReceiveSerializedVarReturnValue result;
- PP_URLComponents_Dev url_components;
+ PP_URLComponents_Dev url_components = {{0}};
dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetDocumentURL(
API_ID_PPB_INSTANCE, instance, &url_components, &result));
if (components)
components);
}
-void PPB_Instance_Proxy::SessionCreated(PP_Instance instance,
- uint32_t session_id,
- PP_Var web_session_id) {
- dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionCreated(
+void PPB_Instance_Proxy::PromiseResolved(PP_Instance instance,
+ uint32 promise_id) {
+ dispatcher()->Send(new PpapiHostMsg_PPBInstance_PromiseResolved(
+ API_ID_PPB_INSTANCE, instance, promise_id));
+}
+
+void PPB_Instance_Proxy::PromiseResolvedWithSession(PP_Instance instance,
+ uint32 promise_id,
+ PP_Var web_session_id_var) {
+ dispatcher()->Send(new PpapiHostMsg_PPBInstance_PromiseResolvedWithSession(
API_ID_PPB_INSTANCE,
instance,
- session_id,
- SerializedVarSendInput(dispatcher(), web_session_id)));
+ promise_id,
+ SerializedVarSendInput(dispatcher(), web_session_id_var)));
+}
+
+void PPB_Instance_Proxy::PromiseResolvedWithKeyIds(PP_Instance instance,
+ uint32 promise_id,
+ PP_Var key_ids_var) {
+ ArrayVar* key_ids_array = ArrayVar::FromPPVar(key_ids_var);
+ if (!key_ids_array ||
+ key_ids_array->GetLength() > media::limits::kMaxKeyIds) {
+ NOTREACHED();
+ return;
+ }
+
+ std::vector<std::vector<uint8_t> > key_ids;
+ for (size_t i = 0; i < key_ids_array->GetLength(); ++i) {
+ ArrayBufferVar* key_id = ArrayBufferVar::FromPPVar(key_ids_array->Get(i));
+ if (!key_id || key_id->ByteLength() < media::limits::kMinKeyIdLength ||
+ key_id->ByteLength() > media::limits::kMaxKeyIdLength) {
+ NOTREACHED();
+ continue;
+ }
+
+ const uint8_t* key_id_ptr = static_cast<const uint8_t*>(key_id->Map());
+ const uint32_t key_id_size = key_id->ByteLength();
+ std::vector<uint8_t> key_id_vector(key_id_ptr, key_id_ptr + key_id_size);
+ key_ids.push_back(key_id_vector);
+ }
+
+ dispatcher()->Send(new PpapiHostMsg_PPBInstance_PromiseResolvedWithKeyIds(
+ API_ID_PPB_INSTANCE, instance, promise_id, key_ids));
+}
+
+void PPB_Instance_Proxy::PromiseRejected(PP_Instance instance,
+ uint32 promise_id,
+ PP_CdmExceptionCode exception_code,
+ uint32 system_code,
+ PP_Var error_description_var) {
+ dispatcher()->Send(new PpapiHostMsg_PPBInstance_PromiseRejected(
+ API_ID_PPB_INSTANCE,
+ instance,
+ promise_id,
+ exception_code,
+ system_code,
+ SerializedVarSendInput(dispatcher(), error_description_var)));
}
void PPB_Instance_Proxy::SessionMessage(PP_Instance instance,
- uint32_t session_id,
- PP_Var message,
- PP_Var destination_url) {
+ PP_Var web_session_id_var,
+ PP_Var message_var,
+ PP_Var destination_url_var) {
dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionMessage(
API_ID_PPB_INSTANCE,
instance,
- session_id,
- SerializedVarSendInput(dispatcher(), message),
- SerializedVarSendInput(dispatcher(), destination_url)));
+ SerializedVarSendInput(dispatcher(), web_session_id_var),
+ SerializedVarSendInput(dispatcher(), message_var),
+ SerializedVarSendInput(dispatcher(), destination_url_var)));
+}
+
+void PPB_Instance_Proxy::SessionKeysChange(PP_Instance instance,
+ PP_Var web_session_id_var,
+ PP_Bool has_additional_usable_key) {
+ StringVar* session_id = StringVar::FromPPVar(web_session_id_var);
+ if (!session_id ||
+ session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
+ NOTREACHED();
+ return;
+ }
+
+ dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionKeysChange(
+ API_ID_PPB_INSTANCE,
+ instance,
+ session_id->value(),
+ has_additional_usable_key));
+}
+
+void PPB_Instance_Proxy::SessionExpirationChange(PP_Instance instance,
+ PP_Var web_session_id_var,
+ PP_Time new_expiry_time) {
+ StringVar* session_id = StringVar::FromPPVar(web_session_id_var);
+ if (!session_id ||
+ session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
+ NOTREACHED();
+ return;
+ }
+
+ dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionExpirationChange(
+ API_ID_PPB_INSTANCE, instance, session_id->value(), new_expiry_time));
}
void PPB_Instance_Proxy::SessionReady(PP_Instance instance,
- uint32_t session_id) {
+ PP_Var web_session_id_var) {
dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionReady(
- API_ID_PPB_INSTANCE, instance, session_id));
+ API_ID_PPB_INSTANCE,
+ instance,
+ SerializedVarSendInput(dispatcher(), web_session_id_var)));
}
void PPB_Instance_Proxy::SessionClosed(PP_Instance instance,
- uint32_t session_id) {
+ PP_Var web_session_id_var) {
dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionClosed(
- API_ID_PPB_INSTANCE, instance, session_id));
+ API_ID_PPB_INSTANCE,
+ instance,
+ SerializedVarSendInput(dispatcher(), web_session_id_var)));
}
void PPB_Instance_Proxy::SessionError(PP_Instance instance,
- uint32_t session_id,
- int32_t media_error,
- uint32_t system_code) {
+ PP_Var web_session_id_var,
+ PP_CdmExceptionCode exception_code,
+ uint32 system_code,
+ PP_Var error_description_var) {
dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionError(
- API_ID_PPB_INSTANCE, instance, session_id, media_error, system_code));
+ API_ID_PPB_INSTANCE,
+ instance,
+ SerializedVarSendInput(dispatcher(), web_session_id_var),
+ exception_code,
+ system_code,
+ SerializedVarSendInput(dispatcher(), error_description_var)));
}
void PPB_Instance_Proxy::DeliverBlock(PP_Instance instance,
instance)));
}
+int32_t PPB_Instance_Proxy::RegisterMessageHandler(
+ PP_Instance instance,
+ void* user_data,
+ const PPP_MessageHandler_0_2* handler,
+ PP_Resource message_loop) {
+ InstanceData* data =
+ static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
+ if (!data)
+ return PP_ERROR_BADARGUMENT;
+
+ int32_t result = PP_ERROR_FAILED;
+ scoped_ptr<MessageHandler> message_handler = MessageHandler::Create(
+ instance, handler, user_data, message_loop, &result);
+ if (message_handler)
+ data->message_handler = message_handler.Pass();
+ return result;
+}
+
+// TODO(dmichael): Remove this. crbug.com/414398
+int32_t PPB_Instance_Proxy::RegisterMessageHandler_1_1_Deprecated(
+ PP_Instance instance,
+ void* user_data,
+ const PPP_MessageHandler_0_1_Deprecated* handler,
+ PP_Resource message_loop) {
+ InstanceData* data =
+ static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
+ if (!data)
+ return PP_ERROR_BADARGUMENT;
+
+ int32_t result = PP_ERROR_FAILED;
+ scoped_ptr<MessageHandler> message_handler = MessageHandler::CreateDeprecated(
+ instance, handler, user_data, message_loop, &result);
+ if (message_handler)
+ data->message_handler = message_handler.Pass();
+ return result;
+}
+
+void PPB_Instance_Proxy::UnregisterMessageHandler(PP_Instance instance) {
+ InstanceData* data =
+ static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
+ if (!data)
+ return;
+ data->message_handler.reset();
+}
+
PP_Bool PPB_Instance_Proxy::SetCursor(PP_Instance instance,
PP_MouseCursor_Type type,
PP_Resource image,
enter.functions()->SelectedFindResultChanged(instance, index);
}
+void PPB_Instance_Proxy::OnHostMsgSetTickmarks(
+ PP_Instance instance,
+ const std::vector<PP_Rect>& tickmarks) {
+ if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
+ return;
+ const PP_Rect* array = tickmarks.empty() ? NULL : &tickmarks[0];
+ EnterInstanceNoLock enter(instance);
+ if (enter.succeeded()) {
+ enter.functions()->SetTickmarks(instance,
+ array,
+ static_cast<uint32_t>(tickmarks.size()));
+ }
+}
+
void PPB_Instance_Proxy::OnHostMsgSetFullscreen(PP_Instance instance,
PP_Bool fullscreen,
PP_Bool* result) {
enter.functions()->ClearInputEventRequest(instance, event_classes);
}
+void PPB_Instance_Proxy::OnHostMsgStartTrackingLatency(PP_Instance instance) {
+ EnterInstanceNoLock enter(instance);
+ if (enter.succeeded())
+ enter.functions()->StartTrackingLatency(instance);
+}
+
void PPB_Instance_Proxy::OnHostMsgPostMessage(
PP_Instance instance,
SerializedVarReceiveInput message) {
}
}
-void PPB_Instance_Proxy::OnHostMsgSessionCreated(
+void PPB_Instance_Proxy::OnHostMsgPromiseResolved(PP_Instance instance,
+ uint32_t promise_id) {
+ if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
+ return;
+ EnterInstanceNoLock enter(instance);
+ if (enter.succeeded()) {
+ enter.functions()->PromiseResolved(instance, promise_id);
+ }
+}
+
+void PPB_Instance_Proxy::OnHostMsgPromiseResolvedWithSession(
PP_Instance instance,
- uint32_t session_id,
+ uint32_t promise_id,
SerializedVarReceiveInput web_session_id) {
if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
return;
EnterInstanceNoLock enter(instance);
if (enter.succeeded()) {
- enter.functions()->SessionCreated(
- instance, session_id, web_session_id.Get(dispatcher()));
+ enter.functions()->PromiseResolvedWithSession(
+ instance, promise_id, web_session_id.Get(dispatcher()));
+ }
+}
+
+void PPB_Instance_Proxy::OnHostMsgPromiseResolvedWithKeyIds(
+ PP_Instance instance,
+ uint32_t promise_id,
+ const std::vector<std::vector<uint8_t> >& key_ids) {
+ if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
+ return;
+ if (key_ids.size() > media::limits::kMaxKeyIds) {
+ NOTREACHED();
+ return;
+ }
+
+ scoped_refptr<ArrayVar> key_ids_array = new ArrayVar();
+ key_ids_array->SetLength(key_ids.size());
+ for (size_t i = 0; i < key_ids.size(); ++i) {
+ const std::vector<uint8_t>& entry = key_ids[i];
+ if (entry.size() < media::limits::kMinKeyIdLength ||
+ entry.size() > media::limits::kMaxKeyIdLength) {
+ NOTREACHED();
+ continue;
+ }
+ key_ids_array->Set(
+ i,
+ PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(entry.size(),
+ &entry[0]));
+ }
+
+ EnterInstanceNoLock enter(instance);
+ if (enter.succeeded()) {
+ ScopedPPVar key_ids_var(ScopedPPVar::PassRef(), key_ids_array->GetPPVar());
+ enter.functions()->PromiseResolvedWithKeyIds(
+ instance, promise_id, key_ids_var.get());
+ }
+}
+
+void PPB_Instance_Proxy::OnHostMsgPromiseRejected(
+ PP_Instance instance,
+ uint32_t promise_id,
+ PP_CdmExceptionCode exception_code,
+ uint32_t system_code,
+ SerializedVarReceiveInput error_description) {
+ if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
+ return;
+ EnterInstanceNoLock enter(instance);
+ if (enter.succeeded()) {
+ enter.functions()->PromiseRejected(instance,
+ promise_id,
+ exception_code,
+ system_code,
+ error_description.Get(dispatcher()));
}
}
void PPB_Instance_Proxy::OnHostMsgSessionMessage(
PP_Instance instance,
- uint32_t session_id,
+ SerializedVarReceiveInput web_session_id,
SerializedVarReceiveInput message,
SerializedVarReceiveInput destination_url) {
if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
EnterInstanceNoLock enter(instance);
if (enter.succeeded()) {
enter.functions()->SessionMessage(instance,
- session_id,
+ web_session_id.Get(dispatcher()),
message.Get(dispatcher()),
destination_url.Get(dispatcher()));
}
}
-void PPB_Instance_Proxy::OnHostMsgSessionReady(PP_Instance instance,
- uint32_t session_id) {
+void PPB_Instance_Proxy::OnHostMsgSessionKeysChange(
+ PP_Instance instance,
+ const std::string& web_session_id,
+ PP_Bool has_additional_usable_key) {
+ if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
+ return;
+ EnterInstanceNoLock enter(instance);
+ if (enter.succeeded()) {
+ ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
+ StringVar::StringToPPVar(web_session_id));
+ enter.functions()->SessionKeysChange(
+ instance, web_session_id_var.get(), has_additional_usable_key);
+ }
+}
+
+void PPB_Instance_Proxy::OnHostMsgSessionExpirationChange(
+ PP_Instance instance,
+ const std::string& web_session_id,
+ PP_Time new_expiry_time) {
+ if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
+ return;
+ EnterInstanceNoLock enter(instance);
+ if (enter.succeeded()) {
+ ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
+ StringVar::StringToPPVar(web_session_id));
+ enter.functions()->SessionExpirationChange(
+ instance, web_session_id_var.get(), new_expiry_time);
+ }
+}
+
+void PPB_Instance_Proxy::OnHostMsgSessionReady(
+ PP_Instance instance,
+ SerializedVarReceiveInput web_session_id) {
if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
return;
EnterInstanceNoLock enter(instance);
if (enter.succeeded()) {
- enter.functions()->SessionReady(instance, session_id);
+ enter.functions()->SessionReady(instance, web_session_id.Get(dispatcher()));
}
}
-void PPB_Instance_Proxy::OnHostMsgSessionClosed(PP_Instance instance,
- uint32_t session_id) {
+void PPB_Instance_Proxy::OnHostMsgSessionClosed(
+ PP_Instance instance,
+ SerializedVarReceiveInput web_session_id) {
if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
return;
EnterInstanceNoLock enter(instance);
if (enter.succeeded()) {
- enter.functions()->SessionClosed(instance, session_id);
+ enter.functions()->SessionClosed(instance,
+ web_session_id.Get(dispatcher()));
}
}
-void PPB_Instance_Proxy::OnHostMsgSessionError(PP_Instance instance,
- uint32_t session_id,
- int32_t media_error,
- uint32_t system_code) {
+void PPB_Instance_Proxy::OnHostMsgSessionError(
+ PP_Instance instance,
+ SerializedVarReceiveInput web_session_id,
+ PP_CdmExceptionCode exception_code,
+ uint32_t system_code,
+ SerializedVarReceiveInput error_description) {
if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
return;
EnterInstanceNoLock enter(instance);
if (enter.succeeded()) {
- enter.functions()->SessionError(
- instance, session_id, media_error, system_code);
+ enter.functions()->SessionError(instance,
+ web_session_id.Get(dispatcher()),
+ exception_code,
+ system_code,
+ error_description.Get(dispatcher()));
}
}
void PPB_Instance_Proxy::OnHostMsgSetTextInputType(PP_Instance instance,
PP_TextInput_Type type) {
- if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
- return;
EnterInstanceNoLock enter(instance);
if (enter.succeeded())
enter.functions()->SetTextInputType(instance, type);
PP_Instance instance,
const PP_Rect& caret,
const PP_Rect& bounding_box) {
- if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
- return;
EnterInstanceNoLock enter(instance);
if (enter.succeeded())
enter.functions()->UpdateCaretPosition(instance, caret, bounding_box);
void PPB_Instance_Proxy::OnHostMsgCancelCompositionText(PP_Instance instance) {
EnterInstanceNoLock enter(instance);
- if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
- return;
if (enter.succeeded())
enter.functions()->CancelCompositionText(instance);
}
const std::string& text,
uint32_t caret,
uint32_t anchor) {
- if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
- return;
EnterInstanceNoLock enter(instance);
if (enter.succeeded()) {
enter.functions()->UpdateSurroundingText(instance, text.c_str(), caret,
projects / platform / framework / web / crosswalk.git / blobdiff