[PPAPI] Fix a bunch of spelling mistakes

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 Thu Jan 17 12:04:14 2013. */
+/* From ppb_message_loop.idl modified Thu Mar 28 11:08:46 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 17 matching lines @@
  * allows you to post work to the message loop for a thread.
  *
  * To process work posted to the message loop, as well as completion callbacks
  * for asynchronous operations, you must run the message loop via Run().
  *
  * Note the system manages the lifetime of the instance (and all associated
  * resources). If the instance is deleted from the page, background threads may
  * suddenly see their PP_Resource handles become invalid. In this case, calls
  * will fail with PP_ERROR_BADRESOURCE. If you need to access data associated
  * with your instance, you will probably want to create some kind of threadsafe
- * proxy object that can handle asynchonous destruction of the instance object.
+ * proxy object that can handle asynchronous destruction of the instance object.
  *
  * Typical usage:
  *   On the main thread:
  *    - 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 callacks should look like this:
+ *   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...
  *      }
  * For a C++ example, see ppapi/utility/threading/simple_thread.h
  *
  * (You can also create the message loop resource on the background thread,
@@ skipping 144 matching lines @@
   int32_t (*Run)(PP_Resource message_loop);
   /**
    * Schedules work to run on the given message loop. This may be called from
    * any thread. Posted work will be executed in the order it was posted when
    * the message loop is Run().
    *
    * @param message_loop The message loop resource.
    *
    * @param callback The completion callback to execute from the message loop.
    *
-   * @param delay_ms The number of millseconds to delay execution of the given
+   * @param delay_ms The number of milliseconds to delay execution of the given
    * completion callback. Passing 0 means it will get queued normally and
    * executed in order.
    *
    *
    * The completion callback will be called with PP_OK as the "result" parameter
    * if it is run normally. It is good practice to check for PP_OK and return
    * early otherwise.
    *
    * The "required" flag on the completion callback is ignored. If there is an
    * error posting your callback, the error will be returned from PostWork and
    * the callback will never be run (because there is no appropriate place to
    * run your callback with an error without causing unexpected threading
    * problems). If you associate memory with the completion callback (for
    * example, you're using the C++ CompletionCallbackFactory), you will need to
-   * free this or manually run the callback. See "Desctruction and error
+   * free this or manually run the callback. See "Destruction and error
    * handling" above.
    *
    *
    * You can call this function before the message loop has started and the
    * work will get queued until the message loop is run. You can also post
    * work after the message loop has exited as long as should_destroy was
    * PP_FALSE. It will be queued until the next invocation of Run().
    *
    * @return
    *   - PP_OK: The work was posted to the message loop's queue. As described
@@ skipping 32 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_ */