From 38d035e33fc2fac4f5c23819c6974afe2caff47b Mon Sep 17 00:00:00 2001 From: "dmichael@chromium.org" Date: Wed, 20 Jul 2011 18:53:59 +0000 Subject: Revert 93223 - Reland http://codereview.chromium.org/7452002/ Update chromoting input events. (Clang caught this. Thanks, Clang!) Note I'm leaving in temporary backwards-compatibility. brettw, just need a rubber-stamp. This is the same as the last CL. awong/garykac/sergeyu, looking for someone on chromoting team to glance at my changes and make sure I didn't do anything you don't like. This is a high priority for 14, so please look if you can. BUG=None TEST=ppapi tests Review URL: http://codereview.chromium.org/7466002 TBR=dmichael@chromium.org Review URL: http://codereview.chromium.org/7471006 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@93229 0039d316-1c4b-4281-b951-d872f2087c98 --- ppapi/api/ppp_instance.idl | 45 ++++++++++++++++++++++++----- ppapi/c/pp_input_event.h | 38 ++++++++++++++++++++++++ ppapi/c/ppp_instance.h | 45 ++++++++++++++++++++++------- ppapi/cpp/instance.cc | 4 +++ ppapi/cpp/instance.h | 5 +++- ppapi/cpp/module.cc | 12 ++++++++ ppapi/examples/2d/graphics_2d_example.c | 7 +++++ ppapi/examples/2d/paint_manager_example.cc | 22 +++++++------- ppapi/examples/file_chooser/file_chooser.cc | 15 ++++------ ppapi/proxy/dispatcher.cc | 2 +- ppapi/proxy/ppapi_messages.h | 4 +++ ppapi/proxy/ppapi_param_traits.cc | 24 +++++++++++++++ ppapi/proxy/ppapi_param_traits.h | 9 ++++++ ppapi/proxy/ppp_instance_proxy.cc | 34 ++++++++++++++++++---- ppapi/proxy/ppp_instance_proxy.h | 8 +++-- ppapi/proxy/ppp_instance_proxy_test.cc | 35 ++++++++++++++++++---- ppapi/shared_impl/ppp_instance_combined.cc | 14 +-------- ppapi/shared_impl/ppp_instance_combined.h | 42 +-------------------------- 18 files changed, 257 insertions(+), 108 deletions(-) (limited to 'ppapi') diff --git a/ppapi/api/ppp_instance.idl b/ppapi/api/ppp_instance.idl index aeb95b1..da8f7a9 100644 --- a/ppapi/api/ppp_instance.idl +++ b/ppapi/api/ppp_instance.idl @@ -9,7 +9,7 @@ */ label Chrome { - M14 = 1.0 + M14 = 0.5 }; /** @@ -161,13 +161,11 @@ interface PPP_Instance { * An instance's default condition is that it will not have focus. * * Note:Clicks on instances will give focus only if you - * handle the click event. Return true from - * HandleInputEvent in PPP_InputEvent (or use - * unfiltered events) to signal that the click event was handled. Otherwise, - * the browser will bubble the event and give focus to the element on the page - * that actually did end up consuming it. If you're not getting focus, check - * to make sure you're returning true from the mouse click in - * HandleInputEvent. + * handle the click event. Return true from HandleInputEvent to + * signal that the click event was handled. Otherwise the browser will bubble + * the event and give focus to the element on the page that actually did end + * up consuming it. If you're not getting focus, check to make sure you're + * returning true from the mouse click in HandleInputEvent. * * @param[in] instance A PP_Instance indentifying the instance * receiving the input event. @@ -181,6 +179,37 @@ interface PPP_Instance { [in] PP_Bool has_focus); /** + * HandleInputEvent() handles input events, such as keyboard events. This + * function returns PP_TRUE if the event was handled or + * PP_FALSE if it was not. + * + * If the event was handled, it will not be forwarded to the web page or + * browser. If it was not handled, it will bubble according to the normal + * rules. So it is important that a module respond accurately with whether + * event propagation should continue. + * + * Event propagation also controls focus. If you handle an event like a mouse + * event, typically the instance will be given focus. Returning false means + * that the click will be given to a lower part of the page and your module + * will not receive focus. This allows an instance to be partially + * transparent, where clicks on the transparent areas will behave like clicks + * to the underlying page. + * + * @param[in] instance A PP_Instance indentifying one instance + * of a module. + * + * @param[in] event The input event. + * + * @return PP_TRUE if event was handled, + * PP_FALSE otherwise. + */ + PP_Bool HandleInputEvent( + /* A PP_Instance indentifying one instance of a module. */ + [in] PP_Instance instance, + /* The event. */ + [in] PP_InputEvent event); + + /** * HandleDocumentLoad() is called after initialize for a full-frame * module that was instantiated based on the MIME type of a DOMWindow * navigation. This situation only applies to modules that are pre-registered diff --git a/ppapi/c/pp_input_event.h b/ppapi/c/pp_input_event.h index c3defc9..0c7854c 100644 --- a/ppapi/c/pp_input_event.h +++ b/ppapi/c/pp_input_event.h @@ -192,6 +192,44 @@ struct PP_InputEvent_Wheel { PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_InputEvent_Wheel, 24); /** + * The PP_InputEventData union represents all input event data types. + */ +union PP_InputEventData { + struct PP_InputEvent_Key key; + struct PP_InputEvent_Character character; + struct PP_InputEvent_Mouse mouse; + struct PP_InputEvent_Wheel wheel; + /** + * This value allows new events to be added without changing the size of + * this struct. + */ + char padding[64]; +}; + +/** + * The PP_InputEvent struct represents all input events. + */ +struct PP_InputEvent { + /** This value represents the type of the event. */ + PP_InputEvent_Type type; + /** This value ensure the time_stamp is aligned on an 8-byte boundary + * relative to the start of the struct. Some compilers align doubles + * on 8-byte boundaries for 32-bit x86, and some align on 4-byte boundaries. + */ + int32_t padding; + /** + * This value represents the time that this event was generated. This value + * is not relative to any particular epoch; the most you can do is compare + * time stamps. + */ + PP_TimeTicks time_stamp; + /** + * This value represents the event type and its specific data. + */ + union PP_InputEventData u; +}; +PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_InputEvent, 80); +/** * @} */ diff --git a/ppapi/c/ppp_instance.h b/ppapi/c/ppp_instance.h index 31f93a3..f38f0ae 100644 --- a/ppapi/c/ppp_instance.h +++ b/ppapi/c/ppp_instance.h @@ -38,8 +38,8 @@ * to handle events such as change of focus or input events (keyboard/mouse) * events. */ -#define PPP_INSTANCE_INTERFACE_1_0 "PPP_Instance;1.0" -#define PPP_INSTANCE_INTERFACE PPP_INSTANCE_INTERFACE_1_0 +#define PPP_INSTANCE_INTERFACE_0_5 "PPP_Instance;0.5" +#define PPP_INSTANCE_INTERFACE PPP_INSTANCE_INTERFACE_0_5 struct PPP_Instance { /** @@ -154,13 +154,11 @@ struct PPP_Instance { * An instance's default condition is that it will not have focus. * * Note:Clicks on instances will give focus only if you - * handle the click event. Return true from - * HandleInputEvent in PPP_InputEvent (or use - * unfiltered events) to signal that the click event was handled. Otherwise, - * the browser will bubble the event and give focus to the element on the page - * that actually did end up consuming it. If you're not getting focus, check - * to make sure you're returning true from the mouse click in - * HandleInputEvent. + * handle the click event. Return true from HandleInputEvent to + * signal that the click event was handled. Otherwise the browser will bubble + * the event and give focus to the element on the page that actually did end + * up consuming it. If you're not getting focus, check to make sure you're + * returning true from the mouse click in HandleInputEvent. * * @param[in] instance A PP_Instance indentifying the instance * receiving the input event. @@ -169,6 +167,33 @@ struct PPP_Instance { */ void (*DidChangeFocus)(PP_Instance instance, PP_Bool has_focus); /** + * HandleInputEvent() handles input events, such as keyboard events. This + * function returns PP_TRUE if the event was handled or + * PP_FALSE if it was not. + * + * If the event was handled, it will not be forwarded to the web page or + * browser. If it was not handled, it will bubble according to the normal + * rules. So it is important that a module respond accurately with whether + * event propagation should continue. + * + * Event propagation also controls focus. If you handle an event like a mouse + * event, typically the instance will be given focus. Returning false means + * that the click will be given to a lower part of the page and your module + * will not receive focus. This allows an instance to be partially + * transparent, where clicks on the transparent areas will behave like clicks + * to the underlying page. + * + * @param[in] instance A PP_Instance indentifying one instance + * of a module. + * + * @param[in] event The input event. + * + * @return PP_TRUE if event was handled, + * PP_FALSE otherwise. + */ + PP_Bool (*HandleInputEvent)(PP_Instance instance, + const struct PP_InputEvent* event); + /** * HandleDocumentLoad() is called after initialize for a full-frame * module that was instantiated based on the MIME type of a DOMWindow * navigation. This situation only applies to modules that are pre-registered @@ -202,7 +227,7 @@ struct PPP_Instance { */ -typedef struct PPP_Instance PPP_Instance_1_0; +typedef struct PPP_Instance PPP_Instance_0_5; #endif /* PPAPI_C_PPP_INSTANCE_H_ */ diff --git a/ppapi/cpp/instance.cc b/ppapi/cpp/instance.cc index 9bb77dc..75e9a1f 100644 --- a/ppapi/cpp/instance.cc +++ b/ppapi/cpp/instance.cc @@ -67,6 +67,10 @@ bool Instance::HandleDocumentLoad(const URLLoader& /*url_loader*/) { return false; } +bool Instance::HandleInputEvent(const PP_InputEvent& /*event*/) { + return false; +} + bool Instance::HandleInputEvent(const InputEvent& /*event*/) { return false; } diff --git a/ppapi/cpp/instance.h b/ppapi/cpp/instance.h index f08c2d5..abf441f 100644 --- a/ppapi/cpp/instance.h +++ b/ppapi/cpp/instance.h @@ -154,7 +154,10 @@ class Instance { /// @param[in] event The input event. /// /// @return true if @a event was handled, false otherwise. - virtual bool HandleInputEvent(const pp::InputEvent& event); + virtual bool HandleInputEvent(const PP_InputEvent& event); + + /// @see InputEvent for an example + virtual bool HandleInputEvent(const InputEvent& event); /// Notification of a data stream available after an instance was created /// based on the MIME type of a DOMWindow navigation. This only applies to diff --git a/ppapi/cpp/module.cc b/ppapi/cpp/module.cc index b727e46..927710a 100644 --- a/ppapi/cpp/module.cc +++ b/ppapi/cpp/module.cc @@ -110,6 +110,17 @@ void Instance_DidChangeFocus(PP_Instance pp_instance, PP_Bool has_focus) { instance->DidChangeFocus(PP_ToBool(has_focus)); } +PP_Bool Instance_HandleInputEvent(PP_Instance pp_instance, + const PP_InputEvent* event) { + Module* module_singleton = Module::Get(); + if (!module_singleton) + return PP_FALSE; + Instance* instance = module_singleton->InstanceForPPInstance(pp_instance); + if (!instance) + return PP_FALSE; + return PP_FromBool(instance->HandleInputEvent(*event)); +} + PP_Bool Instance_HandleDocumentLoad(PP_Instance pp_instance, PP_Resource pp_url_loader) { Module* module_singleton = Module::Get(); @@ -126,6 +137,7 @@ static PPP_Instance instance_interface = { &Instance_DidDestroy, &Instance_DidChangeView, &Instance_DidChangeFocus, + &Instance_HandleInputEvent, &Instance_HandleDocumentLoad }; diff --git a/ppapi/examples/2d/graphics_2d_example.c b/ppapi/examples/2d/graphics_2d_example.c index 6495cdc..ccec9a1 100644 --- a/ppapi/examples/2d/graphics_2d_example.c +++ b/ppapi/examples/2d/graphics_2d_example.c @@ -157,6 +157,12 @@ void Instance_DidChangeView(PP_Instance pp_instance, void Instance_DidChangeFocus(PP_Instance pp_instance, PP_Bool has_focus) { } +PP_Bool Instance_HandleInputEvent(PP_Instance pp_instance, + const struct PP_InputEvent* event) { + /* We don't handle any events. */ + return PP_FALSE; +} + PP_Bool Instance_HandleDocumentLoad(PP_Instance pp_instance, PP_Resource pp_url_loader) { return PP_FALSE; @@ -167,6 +173,7 @@ static struct PPP_Instance instance_interface = { &Instance_DidDestroy, &Instance_DidChangeView, &Instance_DidChangeFocus, + &Instance_HandleInputEvent, &Instance_HandleDocumentLoad }; diff --git a/ppapi/examples/2d/paint_manager_example.cc b/ppapi/examples/2d/paint_manager_example.cc index c129f07..8a5a2f5 100644 --- a/ppapi/examples/2d/paint_manager_example.cc +++ b/ppapi/examples/2d/paint_manager_example.cc @@ -5,7 +5,6 @@ #include "ppapi/c/pp_input_event.h" #include "ppapi/cpp/graphics_2d.h" #include "ppapi/cpp/image_data.h" -#include "ppapi/cpp/input_event.h" #include "ppapi/cpp/instance.h" #include "ppapi/cpp/module.h" #include "ppapi/cpp/paint_manager.h" @@ -42,26 +41,25 @@ class MyInstance : public pp::Instance, public pp::PaintManager::Client { last_x_(0), last_y_(0) { paint_manager_.Initialize(this, this, false); - RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE); } - virtual bool HandleInputEvent(const pp::InputEvent& event) { - switch (event.GetType()) { + virtual bool HandleInputEvent(const PP_InputEvent& event) { + switch (event.type) { case PP_INPUTEVENT_TYPE_MOUSEDOWN: { - pp::MouseInputEvent mouse_event(event); + const PP_InputEvent_Mouse& mouse_event = event.u.mouse; // Update the square on a mouse down. - if (mouse_event.GetMouseButton() == PP_INPUTEVENT_MOUSEBUTTON_LEFT) { - UpdateSquare(static_cast(mouse_event.GetMousePosition().x()), - static_cast(mouse_event.GetMousePosition().y())); + if (mouse_event.button == PP_INPUTEVENT_MOUSEBUTTON_LEFT) { + UpdateSquare(static_cast(mouse_event.x), + static_cast(mouse_event.y)); } return true; } case PP_INPUTEVENT_TYPE_MOUSEMOVE: { - pp::MouseInputEvent mouse_event(event); + const PP_InputEvent_Mouse& mouse_event = event.u.mouse; // Update the square on a drag. - if (mouse_event.GetMouseButton() == PP_INPUTEVENT_MOUSEBUTTON_LEFT) { - UpdateSquare(static_cast(mouse_event.GetMousePosition().x()), - static_cast(mouse_event.GetMousePosition().y())); + if (mouse_event.button == PP_INPUTEVENT_MOUSEBUTTON_LEFT) { + UpdateSquare(static_cast(mouse_event.x), + static_cast(mouse_event.y)); } return true; } diff --git a/ppapi/examples/file_chooser/file_chooser.cc b/ppapi/examples/file_chooser/file_chooser.cc index e1eb6bd..598095f 100644 --- a/ppapi/examples/file_chooser/file_chooser.cc +++ b/ppapi/examples/file_chooser/file_chooser.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2010 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. @@ -7,7 +7,6 @@ #include "ppapi/cpp/completion_callback.h" #include "ppapi/cpp/dev/file_chooser_dev.h" #include "ppapi/cpp/file_ref.h" -#include "ppapi/cpp/input_event.h" #include "ppapi/cpp/module.h" #include "ppapi/cpp/private/instance_private.h" #include "ppapi/cpp/private/var_private.h" @@ -17,17 +16,15 @@ class MyInstance : public pp::InstancePrivate { MyInstance(PP_Instance instance) : pp::InstancePrivate(instance) { callback_factory_.Initialize(this); - RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE); } - virtual bool HandleInputEvent(const pp::InputEvent& event) { - switch (event.GetType()) { + virtual bool HandleInputEvent(const PP_InputEvent& event) { + switch (event.type) { case PP_INPUTEVENT_TYPE_MOUSEDOWN: { - pp::MouseInputEvent mouse_event(event); - if (mouse_event.GetMouseButton() == PP_INPUTEVENT_MOUSEBUTTON_LEFT) + const PP_InputEvent_Mouse& mouse_event = event.u.mouse; + if (mouse_event.button == PP_INPUTEVENT_MOUSEBUTTON_LEFT) ShowFileChooser(false); - else if (mouse_event.GetMouseButton() - == PP_INPUTEVENT_MOUSEBUTTON_RIGHT) + else if (mouse_event.button == PP_INPUTEVENT_MOUSEBUTTON_RIGHT) ShowFileChooser(true); else return false; diff --git a/ppapi/proxy/dispatcher.cc b/ppapi/proxy/dispatcher.cc index 5de70c0..69e16ac 100644 --- a/ppapi/proxy/dispatcher.cc +++ b/ppapi/proxy/dispatcher.cc @@ -165,7 +165,7 @@ InterfaceList::InterfaceList() { AddPPP(PPP_Graphics3D_Proxy::GetInfo()); AddPPP(PPP_InputEvent_Proxy::GetInfo()); AddPPP(PPP_Instance_Private_Proxy::GetInfo()); - AddPPP(PPP_Instance_Proxy::GetInfo1_0()); + AddPPP(PPP_Instance_Proxy::GetInfo0_5()); } void InterfaceList::AddPPP(const InterfaceProxy::Info* info) { diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h index f4739e8..41853ae 100644 --- a/ppapi/proxy/ppapi_messages.h +++ b/ppapi/proxy/ppapi_messages.h @@ -293,6 +293,10 @@ IPC_MESSAGE_ROUTED4(PpapiMsg_PPPInstance_DidChangeView, IPC_MESSAGE_ROUTED2(PpapiMsg_PPPInstance_DidChangeFocus, PP_Instance /* instance */, PP_Bool /* has_focus */) +IPC_SYNC_MESSAGE_ROUTED2_1(PpapiMsg_PPPInstance_HandleInputEvent, + PP_Instance /* instance */, + PP_InputEvent /* event */, + PP_Bool /* result */) IPC_SYNC_MESSAGE_ROUTED2_1(PpapiMsg_PPPInstance_HandleDocumentLoad, PP_Instance /* instance */, pp::proxy::HostResource /* url_loader */, diff --git a/ppapi/proxy/ppapi_param_traits.cc b/ppapi/proxy/ppapi_param_traits.cc index 29e51bb..87c253b 100644 --- a/ppapi/proxy/ppapi_param_traits.cc +++ b/ppapi/proxy/ppapi_param_traits.cc @@ -171,6 +171,30 @@ void ParamTraits::Log(const param_type& p, l->append(" bytes)>"); } +// PP_InputEvent --------------------------------------------------------------- + +// static +void ParamTraits::Write(Message* m, const param_type& p) { + // PP_InputEvent is just POD so we can just memcpy it. + m->WriteData(reinterpret_cast(&p), sizeof(PP_InputEvent)); +} + +// static +bool ParamTraits::Read(const Message* m, + void** iter, + param_type* r) { + const char* data; + int data_size; + if (!m->ReadData(iter, &data, &data_size)) + return false; + memcpy(r, data, sizeof(PP_InputEvent)); + return true; +} + +// static +void ParamTraits::Log(const param_type& p, std::string* l) { +} + // PP_ObjectProperty ----------------------------------------------------------- // static diff --git a/ppapi/proxy/ppapi_param_traits.h b/ppapi/proxy/ppapi_param_traits.h index 736120f..0db47cd 100644 --- a/ppapi/proxy/ppapi_param_traits.h +++ b/ppapi/proxy/ppapi_param_traits.h @@ -11,6 +11,7 @@ #include "ipc/ipc_message_utils.h" #include "ipc/ipc_platform_file.h" #include "ppapi/c/pp_completion_callback.h" +#include "ppapi/c/pp_input_event.h" #include "ppapi/c/pp_rect.h" #include "ppapi/c/pp_var.h" @@ -61,6 +62,14 @@ struct ParamTraits { }; template<> +struct ParamTraits { + typedef PP_InputEvent param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, void** iter, param_type* r); + static void Log(const param_type& p, std::string* l); +}; + +template<> struct ParamTraits { typedef PP_ObjectProperty param_type; static void Write(Message* m, const param_type& p); diff --git a/ppapi/proxy/ppp_instance_proxy.cc b/ppapi/proxy/ppp_instance_proxy.cc index cc2f9db..99dcaab 100644 --- a/ppapi/proxy/ppp_instance_proxy.cc +++ b/ppapi/proxy/ppp_instance_proxy.cc @@ -65,6 +65,21 @@ void DidChangeFocus(PP_Instance instance, PP_Bool has_focus) { instance, has_focus)); } +PP_Bool HandleInputEvent(PP_Instance instance, + const PP_InputEvent* event) { + PP_Bool result = PP_FALSE; + IPC::Message* msg = new PpapiMsg_PPPInstance_HandleInputEvent( + INTERFACE_ID_PPP_INSTANCE, instance, *event, &result); + // Make this message not unblock, to avoid re-entrancy problems when the + // plugin does a synchronous call to the renderer. This will force any + // synchronous calls from the plugin to complete before processing this + // message. We avoid deadlock by never un-setting the unblock flag on messages + // from the plugin to the renderer. + msg->set_unblock(false); + HostDispatcher::GetForInstance(instance)->Send(msg); + return result; +} + PP_Bool HandleDocumentLoad(PP_Instance instance, PP_Resource url_loader) { PP_Bool result = PP_FALSE; @@ -97,11 +112,12 @@ PP_Bool HandleDocumentLoad(PP_Instance instance, return result; } -static const PPP_Instance_1_0 instance_interface_1_0 = { +static const PPP_Instance_0_5 instance_interface_0_5 = { &DidCreate, &DidDestroy, &DidChangeView, &DidChangeFocus, + &HandleInputEvent, &HandleDocumentLoad }; @@ -119,13 +135,13 @@ PPP_Instance_Proxy::~PPP_Instance_Proxy() { } // static -const InterfaceProxy::Info* PPP_Instance_Proxy::GetInfo1_0() { +const InterfaceProxy::Info* PPP_Instance_Proxy::GetInfo0_5() { static const Info info = { - &instance_interface_1_0, - PPP_INSTANCE_INTERFACE_1_0, + &instance_interface_0_5, + PPP_INSTANCE_INTERFACE_0_5, INTERFACE_ID_PPP_INSTANCE, false, - &CreateInstanceProxy, + &CreateInstanceProxy, }; return &info; } @@ -141,6 +157,8 @@ bool PPP_Instance_Proxy::OnMessageReceived(const IPC::Message& msg) { OnMsgDidChangeView) IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_DidChangeFocus, OnMsgDidChangeFocus) + IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_HandleInputEvent, + OnMsgHandleInputEvent) IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_HandleDocumentLoad, OnMsgHandleDocumentLoad) IPC_MESSAGE_UNHANDLED(handled = false) @@ -206,6 +224,12 @@ void PPP_Instance_Proxy::OnMsgDidChangeFocus(PP_Instance instance, combined_interface_->DidChangeFocus(instance, has_focus); } +void PPP_Instance_Proxy::OnMsgHandleInputEvent(PP_Instance instance, + const PP_InputEvent& event, + PP_Bool* result) { + *result = combined_interface_->HandleInputEvent(instance, &event); +} + void PPP_Instance_Proxy::OnMsgHandleDocumentLoad(PP_Instance instance, const HostResource& url_loader, PP_Bool* result) { diff --git a/ppapi/proxy/ppp_instance_proxy.h b/ppapi/proxy/ppp_instance_proxy.h index b246c5c..9448332 100644 --- a/ppapi/proxy/ppp_instance_proxy.h +++ b/ppapi/proxy/ppp_instance_proxy.h @@ -16,6 +16,7 @@ #include "ppapi/proxy/interface_proxy.h" #include "ppapi/shared_impl/ppp_instance_combined.h" +struct PP_InputEvent; struct PP_Rect; namespace pp { @@ -34,8 +35,8 @@ class PPP_Instance_Proxy : public InterfaceProxy { } virtual ~PPP_Instance_Proxy(); - // Return the info for the 1.0 (latest, canonical) version of the interface. - static const Info* GetInfo1_0(); + // Return the info for the 0.5 (latest, canonical) version of the interface. + static const Info* GetInfo0_5(); ::ppapi::PPP_Instance_Combined* ppp_instance_target() const { return combined_interface_.get(); @@ -56,6 +57,9 @@ class PPP_Instance_Proxy : public InterfaceProxy { const PP_Rect& clip, PP_Bool fullscreen); void OnMsgDidChangeFocus(PP_Instance instance, PP_Bool has_focus); + void OnMsgHandleInputEvent(PP_Instance instance, + const PP_InputEvent& event, + PP_Bool* result); void OnMsgHandleDocumentLoad(PP_Instance instance, const HostResource& url_loader, PP_Bool* result); diff --git a/ppapi/proxy/ppp_instance_proxy_test.cc b/ppapi/proxy/ppp_instance_proxy_test.cc index c49f1a2..00d776b 100644 --- a/ppapi/proxy/ppp_instance_proxy_test.cc +++ b/ppapi/proxy/ppp_instance_proxy_test.cc @@ -60,6 +60,13 @@ void DidChangeFocus(PP_Instance instance, PP_Bool has_focus) { did_change_focus_called.Signal(); } +PP_InputEvent received_event; +PP_Bool HandleInputEvent(PP_Instance instance, const PP_InputEvent* event) { + received_instance = instance; + memcpy(&received_event, event, sizeof(*event));; + return bool_to_return; +} + PP_Bool HandleDocumentLoad(PP_Instance instance, PP_Resource url_loader) { // This one requires use of the PPB_URLLoader proxy and PPB_Core, plus a // resource tracker for the url_loader resource. @@ -85,13 +92,15 @@ void ResetReceived() { memset(&received_position, 0, sizeof(received_position)); memset(&received_clip, 0, sizeof(received_clip)); received_has_focus = PP_FALSE; + memset(&received_event, 0, sizeof(received_event)); } -PPP_Instance_1_0 ppp_instance_1_0 = { +PPP_Instance_0_5 ppp_instance_0_5 = { &DidCreate, &DidDestroy, &DidChangeView, &DidChangeFocus, + &HandleInputEvent, &HandleDocumentLoad }; @@ -111,15 +120,15 @@ class PPP_Instance_ProxyTest : public TwoWayTest { } }; -TEST_F(PPP_Instance_ProxyTest, PPPInstance1_0) { - plugin().RegisterTestInterface(PPP_INSTANCE_INTERFACE_1_0, &ppp_instance_1_0); +TEST_F(PPP_Instance_ProxyTest, PPPInstance0_5) { + plugin().RegisterTestInterface(PPP_INSTANCE_INTERFACE_0_5, &ppp_instance_0_5); host().RegisterTestInterface(PPB_FULLSCREEN_DEV_INTERFACE, &ppb_fullscreen_dev); - // Grab the host-side proxy for the 1.0 interface. - const PPP_Instance_1_0* ppp_instance = static_cast( + // Grab the host-side proxy for the 0.5 interface. + const PPP_Instance_0_5* ppp_instance = static_cast( host().host_dispatcher()->GetProxiedInterface( - PPP_INSTANCE_INTERFACE_1_0)); + PPP_INSTANCE_INTERFACE_0_5)); // Call each function in turn, make sure we get the expected values and // returns. @@ -174,6 +183,20 @@ TEST_F(PPP_Instance_ProxyTest, PPPInstance1_0) { EXPECT_EQ(received_instance, expected_instance); EXPECT_EQ(received_has_focus, expected_has_focus); + PP_InputEvent expected_event = { PP_INPUTEVENT_TYPE_KEYDOWN, // type + 0, // padding + 1.0, // time_stamp + { { 2, 3 } } }; // u (as PP_InputEvent_Key) + ResetReceived(); + EXPECT_EQ(bool_to_return, + ppp_instance->HandleInputEvent(expected_instance, &expected_event)); + EXPECT_EQ(received_instance, expected_instance); + ASSERT_EQ(received_event.type, expected_event.type); + // Ignore padding; it's okay if it's not serialized. + EXPECT_EQ(received_event.time_stamp, expected_event.time_stamp); + EXPECT_EQ(received_event.u.key.modifier, expected_event.u.key.modifier); + EXPECT_EQ(received_event.u.key.key_code, expected_event.u.key.key_code); + // TODO(dmichael): Need to mock out a resource Tracker to be able to test // HandleResourceLoad. It also requires // PPB_Core.AddRefResource and for PPB_URLLoader to be diff --git a/ppapi/shared_impl/ppp_instance_combined.cc b/ppapi/shared_impl/ppp_instance_combined.cc index ffb96a4..ce3d2c4 100644 --- a/ppapi/shared_impl/ppp_instance_combined.cc +++ b/ppapi/shared_impl/ppp_instance_combined.cc @@ -7,20 +7,8 @@ namespace ppapi { PPP_Instance_Combined::PPP_Instance_Combined( - const PPP_Instance_1_0& instance_if) - : PPP_Instance_1_0(instance_if), - HandleInputEvent_0_5(NULL) { -} - -PPP_Instance_Combined::PPP_Instance_Combined( const PPP_Instance_0_5& instance_if) - : PPP_Instance_1_0(), - HandleInputEvent_0_5(instance_if.HandleInputEvent) { - DidCreate = instance_if.DidCreate; - DidDestroy = instance_if.DidDestroy; - DidChangeView = instance_if.DidChangeView; - DidChangeFocus = instance_if.DidChangeFocus; - HandleDocumentLoad = instance_if.HandleDocumentLoad; + : PPP_Instance_0_5(instance_if) { } } // namespace ppapi diff --git a/ppapi/shared_impl/ppp_instance_combined.h b/ppapi/shared_impl/ppp_instance_combined.h index 57b5beb..33548d5 100644 --- a/ppapi/shared_impl/ppp_instance_combined.h +++ b/ppapi/shared_impl/ppp_instance_combined.h @@ -8,51 +8,11 @@ #include "base/basictypes.h" #include "ppapi/c/ppp_instance.h" -// TODO(dmichael): This is here only for temporary backwards compatibility so -// that NaCl and other plugins aren't broken while the change propagates. This -// needs to be deleted in 14, because we don't intend to support PPP_Instance. -// HandleInputEvent. -// --- Begin backwards compatibility code. -union PP_InputEventData { - struct PP_InputEvent_Key key; - struct PP_InputEvent_Character character; - struct PP_InputEvent_Mouse mouse; - struct PP_InputEvent_Wheel wheel; - char padding[64]; -}; -struct PP_InputEvent { - PP_InputEvent_Type type; - int32_t padding; - PP_TimeTicks time_stamp; - union PP_InputEventData u; -}; -PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_InputEvent, 80); - -#define PPP_INSTANCE_INTERFACE_0_5 "PPP_Instance;0.5" - -struct PPP_Instance_0_5 { - PP_Bool (*DidCreate)(PP_Instance instance, - uint32_t argc, - const char* argn[], - const char* argv[]); - void (*DidDestroy)(PP_Instance instance); - void (*DidChangeView)(PP_Instance instance, - const struct PP_Rect* position, - const struct PP_Rect* clip); - void (*DidChangeFocus)(PP_Instance instance, PP_Bool has_focus); - PP_Bool (*HandleInputEvent)(PP_Instance instance, - const struct PP_InputEvent* event); - PP_Bool (*HandleDocumentLoad)(PP_Instance instance, PP_Resource url_loader); -}; -// --- End backwards compatibility code. namespace ppapi { -struct PPP_Instance_Combined : public PPP_Instance_1_0 { +struct PPP_Instance_Combined : public PPP_Instance_0_5 { public: - explicit PPP_Instance_Combined(const PPP_Instance_1_0& instance_if); explicit PPP_Instance_Combined(const PPP_Instance_0_5& instance_if); - PP_Bool (*HandleInputEvent_0_5)(PP_Instance instance, - const struct PP_InputEvent* event); DISALLOW_COPY_AND_ASSIGN(PPP_Instance_Combined); }; -- cgit v1.1