Revert 93202 - Remove HandleInputEvent from PPP_Instance and freeze to 1.0.

ppapi/c/ppp_instance.h

 /* Copyright (c) 2011 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.
  */
 
 /* From ppp_instance.idl modified Sat Jul 16 16:50:26 2011. */
 
 #ifndef PPAPI_C_PPP_INSTANCE_H_
 #define PPAPI_C_PPP_INSTANCE_H_
 
@@ skipping 20 matching lines @@
  * @addtogroup Interfaces
  * @{
  */
 /**
  * The <code>PPP_Instance</code> interface contains pointers to a series of
  * functions that you must implement in your module. These functions can be
  * trivial (simply return the default return value) unless you want your module
  * 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 {
   /**
    * DidCreate() is a creation handler that is called when a new instance is
    * created. This function is called for each instantiation on the page,
    * corresponding to one \<embed\> tag on the page.
    *
    * Generally you would handle this call by initializing the information
    * your module associates with an instance and creating a mapping from the
    * given <code>PP_Instance</code> handle to this data. The
@@ skipping 94 matching lines @@
    */
   void (*DidChangeView)(PP_Instance instance,
                         const struct PP_Rect* position,
                         const struct PP_Rect* clip);
   /**
    * DidChangeFocus() is called when an instance has gained or lost focus.
    * Having focus means that keyboard events will be sent to the 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.
    *
    * @param[in] has_focus Indicates the new focused state of the 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
    * to handle certain MIME types. If you haven't specifically registered to
    * handle a MIME type or aren't positive this applies to you, your
    * implementation of this function can just return <code>PP_FALSE</code>.
    *
    * The given <code>url_loader</code> corresponds to a
    * <code>PPB_URLLoader</code> instance that is already opened. Its response
    * headers may be queried using <code>PPB_URLLoader::GetResponseInfo</code>.
@@ skipping 13 matching lines @@
    * @return <code>PP_TRUE</code> if the data was handled,
    * <code>PP_FALSE</code> otherwise.
    */
   PP_Bool (*HandleDocumentLoad)(PP_Instance instance, PP_Resource url_loader);
 };
 /**
  * @}
  */
 
 
-typedef struct PPP_Instance PPP_Instance_1_0;
+typedef struct PPP_Instance PPP_Instance_0_5;
 
 #endif  /* PPAPI_C_PPP_INSTANCE_H_ */