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

18 files changed, 257 insertions, 108 deletions

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.
    *
    * <strong>Note:</strong>Clicks on instances will give focus only if you
-   * handle the click event. Return <code>true</code> from
-   * <code>HandleInputEvent</code> in <code>PPP_InputEvent</code> (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
-   * <code>HandleInputEvent</code>.
+   * handle the click event. Return <code>true</code> 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 <code>HandleInputEvent</code>.
    *
    * @param[in] instance A <code>PP_Instance</code> 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 <code>PP_TRUE</code> if the event was handled or
+   * <code>PP_FALSE</code> 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 <code>PP_Instance</code> indentifying one instance
+   * of a module.
+   *
+   * @param[in] event The input event.
+   *
+   * @return <code>PP_TRUE</code> if <code>event</code> was handled,
+   * <code>PP_FALSE</code> 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.
    *
    * <strong>Note:</strong>Clicks on instances will give focus only if you
-   * handle the click event. Return <code>true</code> from
-   * <code>HandleInputEvent</code> in <code>PPP_InputEvent</code> (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
-   * <code>HandleInputEvent</code>.
+   * handle the click event. Return <code>true</code> 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 <code>HandleInputEvent</code>.
    *
    * @param[in] instance A <code>PP_Instance</code> 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 <code>PP_TRUE</code> if the event was handled or
+   * <code>PP_FALSE</code> 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 <code>PP_Instance</code> indentifying one instance
+   * of a module.
+   *
+   * @param[in] event The input event.
+   *
+   * @return <code>PP_TRUE</code> if <code>event</code> was handled,
+   * <code>PP_FALSE</code> 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<int>(mouse_event.GetMousePosition().x()),
-                       static_cast<int>(mouse_event.GetMousePosition().y()));
+        if (mouse_event.button == PP_INPUTEVENT_MOUSEBUTTON_LEFT) {
+          UpdateSquare(static_cast<int>(mouse_event.x),
+                       static_cast<int>(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<int>(mouse_event.GetMousePosition().x()),
-                       static_cast<int>(mouse_event.GetMousePosition().y()));
+        if (mouse_event.button == PP_INPUTEVENT_MOUSEBUTTON_LEFT) {
+          UpdateSquare(static_cast<int>(mouse_event.x),
+                       static_cast<int>(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<PP_Flash_NetAddress>::Log(const param_type& p,
   l->append(" bytes)>");
 }
 
+// PP_InputEvent ---------------------------------------------------------------
+
+// static
+void ParamTraits<PP_InputEvent>::Write(Message* m, const param_type& p) {
+  // PP_InputEvent is just POD so we can just memcpy it.
+  m->WriteData(reinterpret_cast<const char*>(&p), sizeof(PP_InputEvent));
+}
+
+// static
+bool ParamTraits<PP_InputEvent>::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<PP_InputEvent>::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<PP_Flash_NetAddress> {
 };
 
 template<>
+struct ParamTraits<PP_InputEvent> {
+  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<PP_ObjectProperty> {
   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<PPP_Instance_1_0>,
+    &CreateInstanceProxy<PPP_Instance_0_5>,
   };
   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<const PPP_Instance_1_0*>(
+  // Grab the host-side proxy for the 0.5 interface.
+  const PPP_Instance_0_5* ppp_instance = static_cast<const PPP_Instance_0_5*>(
       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);
 };