More trivial cleanupi of ppapi/c headers

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_
 
 #include "ppapi/c/pp_bool.h"
+#include "ppapi/c/pp_input_event.h"
 #include "ppapi/c/pp_instance.h"
+#include "ppapi/c/pp_macros.h"
+#include "ppapi/c/pp_point.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_resource.h"
-
-struct PP_InputEvent;
-
-#define PPP_INSTANCE_INTERFACE_0_5 "PPP_Instance;0.5"
-#define PPP_INSTANCE_INTERFACE PPP_INSTANCE_INTERFACE_0_5
+#include "ppapi/c/pp_size.h"
+#include "ppapi/c/pp_stdint.h"
+#include "ppapi/c/pp_time.h"
+#include "ppapi/c/ppb_input_event.h"
 
 /**
  * @file
  * This file defines the <code>PPP_Instance</code> structure - a series of
  * pointers to methods that you must implement in your module.
  */
 
-/** @addtogroup Interfaces
+
+/**
+ * @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_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 25 matching lines @@
    * argument values: "nacl_module" and "2".  The indices of these values match
    * the indices of the corresponding names in <code>argn</code>.
    *
    * @return <code>PP_TRUE</code> on success or <code>PP_FALSE</code> on
    * failure.
    */
   PP_Bool (*DidCreate)(PP_Instance instance,
                        uint32_t argc,
                        const char* argn[],
                        const char* argv[]);
-
   /**
    * DidDestroy() is an instance destruction handler. This function is called
    * in many cases (see below) when a module instance is destroyed. It will be
    * called even if DidCreate() returned failure.
    *
    * Generally you will handle this call by deallocating the tracking
    * information and the <code>PP_Instance</code> mapping you created in the
    * DidCreate() call. You can also free resources associated with this
    * instance but this isn't required; all resources associated with the deleted
    * instance will be automatically freed when this function returns.
    *
    * The instance identifier will still be valid during this call so the module
    * can perform cleanup-related tasks. Once this function returns, the
    * <code>PP_Instance</code> handle will be invalid. This means that you can't
    * do any asynchronous operations like network requests or file writes from
    * this function since they will be immediately canceled.
    *
    * <strong>Note:</strong> This function may be skipped in certain
    * circumstances when Chrome does "fast shutdown". Fast shutdown will happen
    * in some cases when all module instances are being deleted, and no cleanup
    * functions will be called. The module will just be unloaded and the process
    * terminated.
    *
    * @param[in] instance A <code>PP_Instance</code> indentifying one instance
    * of a module.
    */
   void (*DidDestroy)(PP_Instance instance);
-
   /**
    * DidChangeView() is called when the position, the size, of the clip
    * rectangle of the element in the browser that corresponds to this
    * instance has changed.
    *
    * A typical implementation will check the size of the <code>position</code>
    * argument and reallocate the graphics context when a different size is
    * received. Note that this function will be called for scroll events where
    * the size doesn't change, so you should always check that the size is
    * actually different before doing any reallocations.
@@ skipping 16 matching lines @@
    * not usually worthwhile, however, to generate partial updates according to
    * the clip when the instance is partially visible. Instead, update the entire
    * region. The time saved doing partial paints is usually not significant and
    * it can create artifacts when scrolling (this notification is sent
    * asynchronously from scolling so there can be flashes of old content in the
    * exposed regions).
    */
   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 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>.
    * The reference count for the URL loader is not incremented automatically on
    * behalf of the module. You need to increment the reference count yourself
    * if you are going to keep a reference to it.
    *
    * This method returns <code>PP_FALSE</code> if the module cannot handle the
    * data. In response to this method, the module should call
    * ReadResponseBody() to read the incoming data.
    *
    * @param[in] instance A <code>PP_Instance</code> indentifying the instance
    * that should do the load.
    *
    * @param[in] url_loader An open <code>PPB_URLLoader</code> instance.
    *
    * @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_0_5;
 
 #endif  /* PPAPI_C_PPP_INSTANCE_H_ */