Clean up formatting to simplify post-Doxygen processing.

ppapi/c/ppb_message_loop.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 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_
 
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_macros.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_stdint.h"
@@ skipping 31 matching lines @@
  *    - Create the thread yourself (using pthreads).
  *    - Create the message loop resource.
  *    - Pass the message loop resource to your thread's main function.
  *    - Call PostWork() on the message loop to run functions on the thread.
  *
  *   From the background thread's main function:
  *    - Call AttachToCurrentThread() with the message loop resource.
  *    - 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,
  * but then the main thread will have no reference to it should you want to
  * call PostWork()).
  *
  *
  * THREAD HANDLING
  *
  * The main thread has an implicitly created message loop. The main thread is
@@ skipping 50 matching lines @@
  *
  * If you post a callback to a message loop that's been destroyed, or to an
  * invalid message loop, PostWork will return an error and will not run the
  * callback. This is true even for callbacks with the "required" flag set,
  * since the system may not even know what thread to issue the error callback
  * on.
  *
  * 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.
  */
 struct PPB_MessageLoop_1_0 {
   /**
    * Creates a message loop resource.
    *
    * This may be called from any thread. After your thread starts but before
    * issuing any other PPAPI calls on it, you must associate it with a message
@@ skipping 129 matching lines @@
   int32_t (*PostQuit)(PP_Resource message_loop, PP_Bool should_destroy);
 };
 
 typedef struct PPB_MessageLoop_1_0 PPB_MessageLoop;
 /**
  * @}
  */
 
 #endif  /* PPAPI_C_PPB_MESSAGE_LOOP_H_ */