Clean up formatting to simplify post-Doxygen processing.

ppapi/c/pp_completion_callback.h

 /* Copyright (c) 2012 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 pp_completion_callback.idl modified Thu Mar 28 15:25:03 2013. */
+/* From pp_completion_callback.idl modified Thu May  9 14:59:57 2013. */
 
 #ifndef PPAPI_C_PP_COMPLETION_CALLBACK_H_
 #define PPAPI_C_PP_COMPLETION_CALLBACK_H_
 
 #include "ppapi/c/pp_macros.h"
 #include "ppapi/c/pp_stdint.h"
 
 /**
  * @file
  * This file defines the API to create and run a callback.
@@ skipping 72 matching lines @@
  * <code>PP_CompletionCallback</code> is a common mechanism for supporting
  * potentially asynchronous calls in browser interfaces. Any method that takes a
  * <code>PP_CompletionCallback</code> can be used in one of three different
  * ways:
  *   - Required: The callback will always be invoked asynchronously on the
  *               thread where the associated PPB method was invoked. The method
  *               will always return PP_OK_COMPLETIONPENDING when a required
  *               callback, and the callback will be invoked later (barring
  *               system or thread shutdown; see PPB_MessageLoop for details).
  *               Required callbacks are the default.
- *
+ *               <br /><br />
  *               NOTE: If you use a required callback on a background thread,
  *               you must have created and attached a PPB_MessageLoop.
  *               Otherwise, the system can not run your callback on that thread,
  *               and will instead emit a log message and crash your plugin to
  *               make the problem more obvious.
  *
  *   - Optional: The callback may be invoked asynchronously, or the PPB method
  *               may complete synchronously if it can do so without blocking.
  *               If the method will complete asynchronously, it will return
  *               PP_OK_COMPLETIONPENDING. Otherwise, it will complete
  *               synchronously and return an appropriate code (see below for
  *               more information on the return code). Optional callbacks are
  *               generally more difficult to use correctly than Required
  *               callbacks, but can provide better performance for some APIs
  *               (especially APIs with buffered reads, such as PPB_URLLoader or
  *               PPB_FileIO).
- *
+ *               <br /><br />
  *               NOTE: If you use an optional callback on a background thread,
  *               and you have not created and attached a PPB_MessageLoop, then
  *               the method you invoke will fail without running and return
  *               PP_ERROR_NO_MESSAGE_LOOP.
  *
  *   - Blocking: In this case, the callback's function pointer is NULL, and the
  *               invoked method must complete synchronously. The method will
  *               run to completion and return an appropriate code when finished
  *               (see below for more information). Blocking completion
  *               callbacks are only supported on background threads.
- *
+ *               <br /><br />
  *               <code>PP_BlockUntilComplete()</code> provides a convenient way
  *               to specify blocking behavior. Refer to
- *                <code>PP_BlockUntilComplete</code> for more information.
+ *               <code>PP_BlockUntilComplete</code> for more information.
  *
  * When the callback is run asynchronously, the result parameter passed to
  * <code>func</code> is an int32_t that, if negative indicates an error code
  * whose meaning is specific to the calling method (refer to
  * <code>pp_error.h</code> for further information). A positive or 0 value is a
  * return result indicating success whose meaning depends on the calling method
  * (e.g. number of bytes read).
  */
 struct PP_CompletionCallback {
   /**
@@ skipping 139 matching lines @@
   struct PP_CompletionCallback temp = *cc;
   *cc = PP_BlockUntilComplete();
   PP_RunCompletionCallback(&temp, res);
 }
 /**
  * @}
  */
 
 #endif  /* PPAPI_C_PP_COMPLETION_CALLBACK_H_ */