PPAPI: Take PPB_MessageLoop out of Dev

ppapi/cpp/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.
 
-#ifndef PPAPI_CPP_DEV_MESSAGE_LOOP_DEV_H_
-#define PPAPI_CPP_DEV_MESSAGE_LOOP_DEV_H_
+#ifndef PPAPI_CPP_MESSAGE_LOOP_H_
+#define PPAPI_CPP_MESSAGE_LOOP_H_
 
 #include "ppapi/cpp/resource.h"
 
 namespace pp {
 
 class CompletionCallback;
 class InstanceHandle;
 
 /// A message loop allows PPAPI calls to be issued on a thread. You may not
 /// issue any API calls on a thread without creating a message loop. It also
@@ skipping 100 matching lines @@
 /// CompletionCallbackFactory, use the following pattern:
 ///
 ///   pp::CompletionCallback callback = factory_.NewOptionalCallback(...);
 ///   int32_t result = message_loop.PostWork(callback);
 ///   if (result != PP_OK_COMPLETIONPENDING)
 ///     callback.Run(result);
 ///
 /// 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.
-class MessageLoop_Dev : public Resource {
+class MessageLoop : public Resource {
  public:
   /// Creates an is_null() MessageLoop resource.
-  MessageLoop_Dev();
+  MessageLoop();
 
   /// Creates a message loop associated with the given instance. The resource
   /// will be is_null() on failure.
   ///
   /// 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
   /// loop by calling AttachToCurrentThread.
-  explicit MessageLoop_Dev(const InstanceHandle& instance);
+  explicit MessageLoop(const InstanceHandle& instance);
 
-  MessageLoop_Dev(const MessageLoop_Dev& other);
+  MessageLoop(const MessageLoop& other);
 
   /// Takes an additional ref to the resource.
-  explicit MessageLoop_Dev(PP_Resource pp_message_loop);
+  explicit MessageLoop(PP_Resource pp_message_loop);
 
-  static MessageLoop_Dev GetForMainThread();
-  static MessageLoop_Dev GetCurrent();
+  static MessageLoop GetForMainThread();
+  static MessageLoop GetCurrent();
 
   /// Sets the given message loop resource as being the associated message loop
   /// for the currently running thread.
   ///
   /// You must call this function exactly once on a thread before making any
   /// PPAPI calls. A message loop can only be attached to one thread, and the
   /// message loop can not be changed later. The message loop will be attached
   /// as long as the thread is running or until you quit with should_destroy
   /// set to PP_TRUE.
   ///
@@ skipping 74 matching lines @@
   ///   - PP_ERROR_BADARGUMENT: The function pointer for the completion callback
   ///     is null (this will be the case if you pass PP_BlockUntilComplete()).
   ///   - PP_ERROR_FAILED: The message loop has been destroyed.
   int32_t PostWork(const CompletionCallback& callback,
                    int64_t delay_ms = 0);
 
   /// Posts a quit message to the given message loop's work queue. Work posted
   /// before that point will be processed before quitting.
   ///
   /// This may be called on the message loop registered for the current thread,
-  /// or it may be called on the message loop registered for another thread.
+  /// or it may be called on the message loop registered for another thread. It
+  /// is an error to attempt to quit the main thread loop.
   ///
   /// @param should_destroy Marks the message loop as being in a destroyed
   /// state and prevents further posting of messages.
   ///
   /// If you quit a message loop without setting should_destroy, it will still
   /// be attached to the thread and you can still run it again by calling Run()
   /// again. If you destroy it, it will be detached from the current thread.
   ///
   /// @return
   ///   - PP_OK: The request to quit was successfully posted.
   ///   - PP_ERROR_BADRESOURCE: The message loop was invalid.
   ///   - PP_ERROR_WRONG_THREAD: You are attempting to quit the main thread.
   ///     The main thread's message loop is managed by the system and can't be
   ///     quit.
   int32_t PostQuit(bool should_destroy);
 };
 
 }  // namespace pp
 
-#endif  // PPAPI_CPP_DEV_MESSAGE_LOOP_DEV_H_
+#endif  // PPAPI_CPP_MESSAGE_LOOP_H_