Clean up formatting to simplify post-Doxygen processing.

BUG=
R=dmichael@chromium.org, noelallen@chromium.org

Review URL: https://codereview.chromium.org/15004017

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@203247 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 58 insertions, 53 deletions

diff --git a/ppapi/api/pp_completion_callback.idl b/ppapi/api/pp_completion_callback.idl
index 46b6342..72aed83 100644
--- a/ppapi/api/pp_completion_callback.idl
+++ b/ppapi/api/pp_completion_callback.idl
@@ -70,7 +70,7 @@ enum PP_CompletionCallback_Flag {
  *               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,
@@ -87,7 +87,7 @@ enum PP_CompletionCallback_Flag {
  *               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
@@ -98,10 +98,10 @@ enum PP_CompletionCallback_Flag {
  *               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
diff --git a/ppapi/api/ppb_message_loop.idl b/ppapi/api/ppb_message_loop.idl
index 83c198f..0adc0b3 100644
--- a/ppapi/api/ppb_message_loop.idl
+++ b/ppapi/api/ppb_message_loop.idl
@@ -37,15 +37,15 @@ label Chrome {
  *    - Call Run() with the message loop resource.
  *
  *   Your callbacks should look like this:
- *      @code
- *      void DoMyWork(void* user_data, int32_t status) {
- *        if (status != PP_OK) {
- *          Cleanup();  // e.g. free user_data.
- *          return;
- *        }
- *        ... do your work...
- *      }
- *      @endcode
+ *   @code
+ *   void DoMyWork(void* user_data, int32_t status) {
+ *     if (status != PP_OK) {
+ *       Cleanup();  // e.g. free user_data.
+ *       return;
+ *     }
+ *     ... do your work...
+ *   }
+ *   @endcode
  * For a C++ example, see ppapi/utility/threading/simple_thread.h
  *
  * (You can also create the message loop resource on the background thread,
@@ -116,12 +116,12 @@ label Chrome {
  * Therefore, you should check for errors from PostWork and destroy any
  * associated memory to avoid leaks. If you're using the C++
  * CompletionCallbackFactory, use the following pattern:
- *
- *   pp::CompletionCallback callback = factory_.NewOptionalCallback(...);
- *   int32_t result = message_loop.PostWork(callback);
- *   if (result != PP_OK)
- *     callback.Run(result);
- *
+ * @code
+ * pp::CompletionCallback callback = factory_.NewOptionalCallback(...);
+ * int32_t result = message_loop.PostWork(callback);
+ * if (result != PP_OK)
+ *   callback.Run(result);
+ * @endcode
  * This will run the callback with an error value, and assumes that the
  * implementation of your callback checks the "result" argument and returns
  * immediately on error.
diff --git a/ppapi/c/pp_completion_callback.h b/ppapi/c/pp_completion_callback.h
index 73dc57e..3790393 100644
--- a/ppapi/c/pp_completion_callback.h
+++ b/ppapi/c/pp_completion_callback.h
@@ -3,7 +3,7 @@
  * 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_
@@ -96,7 +96,7 @@ PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_CompletionCallback_Flag, 4);
  *               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,
@@ -113,7 +113,7 @@ PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_CompletionCallback_Flag, 4);
  *               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
@@ -124,10 +124,10 @@ PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_CompletionCallback_Flag, 4);
  *               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
diff --git a/ppapi/c/ppb_message_loop.h b/ppapi/c/ppb_message_loop.h
index d582abc..0ddce16 100644
--- a/ppapi/c/ppb_message_loop.h
+++ b/ppapi/c/ppb_message_loop.h
@@ -3,7 +3,7 @@
  * found in the LICENSE file.
  */
 
-/* From ppb_message_loop.idl modified Mon Apr  1 12:14:25 2013. */
+/* From ppb_message_loop.idl modified Thu May  9 14:59:57 2013. */
 
 #ifndef PPAPI_C_PPB_MESSAGE_LOOP_H_
 #define PPAPI_C_PPB_MESSAGE_LOOP_H_
@@ -55,15 +55,15 @@
  *    - Call Run() with the message loop resource.
  *
  *   Your callbacks should look like this:
- *      @code
- *      void DoMyWork(void* user_data, int32_t status) {
- *        if (status != PP_OK) {
- *          Cleanup();  // e.g. free user_data.
- *          return;
- *        }
- *        ... do your work...
- *      }
- *      @endcode
+ *   @code
+ *   void DoMyWork(void* user_data, int32_t status) {
+ *     if (status != PP_OK) {
+ *       Cleanup();  // e.g. free user_data.
+ *       return;
+ *     }
+ *     ... do your work...
+ *   }
+ *   @endcode
  * For a C++ example, see ppapi/utility/threading/simple_thread.h
  *
  * (You can also create the message loop resource on the background thread,
@@ -134,12 +134,12 @@
  * Therefore, you should check for errors from PostWork and destroy any
  * associated memory to avoid leaks. If you're using the C++
  * CompletionCallbackFactory, use the following pattern:
- *
- *   pp::CompletionCallback callback = factory_.NewOptionalCallback(...);
- *   int32_t result = message_loop.PostWork(callback);
- *   if (result != PP_OK)
- *     callback.Run(result);
- *
+ * @code
+ * pp::CompletionCallback callback = factory_.NewOptionalCallback(...);
+ * int32_t result = message_loop.PostWork(callback);
+ * if (result != PP_OK)
+ *   callback.Run(result);
+ * @endcode
  * This will run the callback with an error value, and assumes that the
  * implementation of your callback checks the "result" argument and returns
  * immediately on error.
diff --git a/ppapi/cpp/message_loop.h b/ppapi/cpp/message_loop.h
index 9e28b2d..c1e217b 100644
--- a/ppapi/cpp/message_loop.h
+++ b/ppapi/cpp/message_loop.h
@@ -7,6 +7,9 @@
 
 #include "ppapi/cpp/resource.h"
 
+/// @file
+/// This file defines the PPB_MessageLoop API.
+
 namespace pp {
 
 class CompletionCallback;
@@ -39,13 +42,15 @@ class InstanceHandle;
 ///    - Call Run() with the message loop resource.
 ///
 ///   Your callbacks should look like this:
-///      void DoMyWork(void* user_data, int32_t status) {
-///        if (status != PP_OK) {
-///          Cleanup();  // e.g. free user_data.
-///          return;
-///        }
-///        ... do your work...
-///      }
+///   @code
+///   void DoMyWork(void* user_data, int32_t status) {
+///     if (status != PP_OK) {
+///       Cleanup();  // e.g. free user_data.
+///       return;
+///     }
+///     ... do your work...
+///   }
+///   @endcode
 /// For a C++ example, see ppapi/utility/threading/simple_thread.h
 ///
 /// (You can also create the message loop resource on the background thread,
@@ -116,12 +121,12 @@ class InstanceHandle;
 /// Therefore, you should check for errors from PostWork and destroy any
 /// associated memory to avoid leaks. If you're using the C++
 /// CompletionCallbackFactory, use the following pattern:
-///
-///   pp::CompletionCallback callback = factory_.NewOptionalCallback(...);
-///   int32_t result = message_loop.PostWork(callback);
-///   if (result != PP_OK)
-///     callback.Run(result);
-///
+/// @code
+/// pp::CompletionCallback callback = factory_.NewOptionalCallback(...);
+/// int32_t result = message_loop.PostWork(callback);
+/// if (result != PP_OK)
+///   callback.Run(result);
+/// @endcode
 /// This will run the callback with an error value, and assumes that the
 /// implementation of your callback checks the "result" argument and returns
 /// immediately on error.