diff --git a/ppapi/api/pp_completion_callback.idl b/ppapi/api/pp_completion_callback.idl
index 0dff263..6db9e2eb 100644
--- a/ppapi/api/pp_completion_callback.idl
+++ b/ppapi/api/pp_completion_callback.idl
@@ -32,7 +32,13 @@
    * without blocking.
    *
    * The method taking such callback will always return PP_OK_COMPLETIONPENDING.
-   * The callback will be invoked on the main thread of PPAPI execution.
+   * The callback will be invoked on the same thread on which the method was
+   * invoked.
+   *
+   * NOTE: If the method taking the callback is invoked on a background
+   * thread that has no valid PPB_MessageLoop resource attached, the system has
+   * no way to run the callback on the correct thread. In this case, a log
+   * message will be emitted and the plugin will be made to crash.
    */
   PP_COMPLETIONCALLBACK_FLAG_NONE = 0 << 0,
   /**
@@ -44,32 +50,70 @@
    * On synchronous method completion, the completion result will be returned
    * by the method itself. Otherwise, the method will return
    * PP_OK_COMPLETIONPENDING, and the callback will be invoked asynchronously on
-   * the main thread of PPAPI execution.
+   * the same thread on which the method was invoked. If there is no valid
+   * PPB_MessageLoop attached to that thread, and the callback would normally
+   * run asynchronously, the invoked method will return
+   * PP_ERROR_NO_MESSAGE_LOOP.
    */
   PP_COMPLETIONCALLBACK_FLAG_OPTIONAL = 1 << 0
 };
 
 
 /**
- * Any method that takes a <code>PP_CompletionCallback</code> has the option of
- * completing asynchronously if the operation would block.  Such a method
- * should return <code>PP_OK_COMPLETIONPENDING</code> to indicate that the
- * method will complete asynchronously and notify the caller and will always be
- * invoked from the main thread of PPAPI execution.  If the completion callback
- * is NULL, then the operation will block if necessary to complete its work.
- * <code>PP_BlockUntilComplete()</code> provides a convenient way to specify
- * blocking behavior. Refer to <code>PP_BlockUntilComplete</code> for more
- * information.
+ * <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 <code>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.
  *
- * 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).
+ *               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).
+ *
+ *               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.
+ *
+ *               <code>PP_BlockUntilComplete()</code> provides a convenient way
+ *               to specify blocking behavior. Refer to
+ *                <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).
  */
 [passByValue] struct PP_CompletionCallback {
   /**
-   * This value is a callback function that will be called.
+   * This value is a callback function that will be called, or NULL if this is
+   * a blocking completion callback.
    */
   PP_CompletionCallback_Func func;
   /**
@@ -95,7 +139,13 @@
  * PP_MakeCompletionCallback() is used to create a
  * <code>PP_CompletionCallback</code>.
  *
- * <strong>Example:</strong>
+ * <strong>Example, creating a Required callback:</strong>
+ *
+ * <code>
+ * struct PP_CompletionCallback cc = PP_MakeCompletionCallback(Foo, NULL);
+ * </code>
+ *
+ * <strong>Example, creating an Optional callback:</strong>
  *
  * <code>
  * struct PP_CompletionCallback cc = PP_MakeCompletionCallback(Foo, NULL);
diff --git a/ppapi/c/pp_completion_callback.h b/ppapi/c/pp_completion_callback.h
index 911302ff..6619ca4 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 Wed Oct  5 14:06:02 2011. */
+/* From pp_completion_callback.idl modified Wed Nov  7 11:20:18 2012. */
 
 #ifndef PPAPI_C_PP_COMPLETION_CALLBACK_H_
 #define PPAPI_C_PP_COMPLETION_CALLBACK_H_
@@ -51,7 +51,13 @@
    * without blocking.
    *
    * The method taking such callback will always return PP_OK_COMPLETIONPENDING.
-   * The callback will be invoked on the main thread of PPAPI execution.
+   * The callback will be invoked on the same thread on which the method was
+   * invoked.
+   *
+   * NOTE: If the method taking the callback is invoked on a background
+   * thread that has no valid PPB_MessageLoop resource attached, the system has
+   * no way to run the callback on the correct thread. In this case, a log
+   * message will be emitted and the plugin will be made to crash.
    */
   PP_COMPLETIONCALLBACK_FLAG_NONE = 0 << 0,
   /**
@@ -63,7 +69,10 @@
    * On synchronous method completion, the completion result will be returned
    * by the method itself. Otherwise, the method will return
    * PP_OK_COMPLETIONPENDING, and the callback will be invoked asynchronously on
-   * the main thread of PPAPI execution.
+   * the same thread on which the method was invoked. If there is no valid
+   * PPB_MessageLoop attached to that thread, and the callback would normally
+   * run asynchronously, the invoked method will return
+   * PP_ERROR_NO_MESSAGE_LOOP.
    */
   PP_COMPLETIONCALLBACK_FLAG_OPTIONAL = 1 << 0
 } PP_CompletionCallback_Flag;
@@ -77,25 +86,60 @@
  * @{
  */
 /**
- * Any method that takes a <code>PP_CompletionCallback</code> has the option of
- * completing asynchronously if the operation would block.  Such a method
- * should return <code>PP_OK_COMPLETIONPENDING</code> to indicate that the
- * method will complete asynchronously and notify the caller and will always be
- * invoked from the main thread of PPAPI execution.  If the completion callback
- * is NULL, then the operation will block if necessary to complete its work.
- * <code>PP_BlockUntilComplete()</code> provides a convenient way to specify
- * blocking behavior. Refer to <code>PP_BlockUntilComplete</code> for more
- * information.
+ * <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 <code>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.
  *
- * 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).
+ *               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).
+ *
+ *               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.
+ *
+ *               <code>PP_BlockUntilComplete()</code> provides a convenient way
+ *               to specify blocking behavior. Refer to
+ *                <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 {
   /**
-   * This value is a callback function that will be called.
+   * This value is a callback function that will be called, or NULL if this is
+   * a blocking completion callback.
    */
   PP_CompletionCallback_Func func;
   /**
@@ -122,7 +166,13 @@
  * PP_MakeCompletionCallback() is used to create a
  * <code>PP_CompletionCallback</code>.
  *
- * <strong>Example:</strong>
+ * <strong>Example, creating a Required callback:</strong>
+ *
+ * <code>
+ * struct PP_CompletionCallback cc = PP_MakeCompletionCallback(Foo, NULL);
+ * </code>
+ *
+ * <strong>Example, creating an Optional callback:</strong>
  *
  * <code>
  * struct PP_CompletionCallback cc = PP_MakeCompletionCallback(Foo, NULL);
diff --git a/ppapi/cpp/completion_callback.h b/ppapi/cpp/completion_callback.h
index 2391a3a..ec892f6f 100644
--- a/ppapi/cpp/completion_callback.h
+++ b/ppapi/cpp/completion_callback.h
@@ -99,7 +99,7 @@
   /// On synchronous method completion, the completion result will be returned
   /// by the method itself. Otherwise, the method will return
   /// PP_OK_COMPLETIONPENDING, and the callback will be invoked asynchronously
-  /// on the main thread of Pepper execution.
+  /// on the same thread where the PPB method was invoked.
   ///
   /// @return true if this callback is optional, otherwise false.
   bool IsOptional() const {
@@ -150,6 +150,7 @@
   int32_t MayForce(int32_t result) const {
     if (result == PP_OK_COMPLETIONPENDING || IsOptional())
       return result;
+    // FIXME(dmichael): Use pp::MessageLoop here once it's out of Dev.
     Module::Get()->core()->CallOnMainThread(0, *this, result);
     return PP_OK_COMPLETIONPENDING;
   }
diff --git a/ppapi/cpp/resource.h b/ppapi/cpp/resource.h
index f214672..8f5a92d2e 100644
--- a/ppapi/cpp/resource.h
+++ b/ppapi/cpp/resource.h
@@ -91,4 +91,8 @@
   return lhs.pp_resource() == rhs.pp_resource();
 }
 
+inline bool operator!=(const pp::Resource& lhs, const pp::Resource& rhs) {
+  return !(lhs == rhs);
+}
+
 #endif // PPAPI_CPP_RESOURCE_H_
diff --git a/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c b/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c
index 9c63608..7dc2ff3 100644
--- a/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c
+++ b/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c
@@ -3,7 +3,7 @@
  * found in the LICENSE file.
  */
 
-/* Last generated from IDL: Wed Nov  7 13:45:01 2012. */
+/* Last generated from IDL: Thu Nov  8 08:56:35 2012. */
 #include "ppapi/generators/pnacl_shim.h"
 
 #include "ppapi/c/ppb.h"
diff --git a/ppapi/ppapi_shared.gypi b/ppapi/ppapi_shared.gypi
index fffc465..1205f09 100644
--- a/ppapi/ppapi_shared.gypi
+++ b/ppapi/ppapi_shared.gypi
@@ -70,6 +70,8 @@
           'shared_impl/ppb_instance_shared.cc',
           'shared_impl/ppb_instance_shared.h',
           'shared_impl/ppb_memory_shared.cc',
+          'shared_impl/ppb_message_loop_shared.cc',
+          'shared_impl/ppb_message_loop_shared.h',
           'shared_impl/ppb_network_list_private_shared.cc',
           'shared_impl/ppb_network_list_private_shared.h',
           'shared_impl/ppb_opengles2_shared.cc',
diff --git a/ppapi/proxy/plugin_globals.cc b/ppapi/proxy/plugin_globals.cc
index 4932d32b..75369d0 100644
--- a/ppapi/proxy/plugin_globals.cc
+++ b/ppapi/proxy/plugin_globals.cc
@@ -105,6 +105,10 @@
   LogWithSource(0, level, source, value);
 }
 
+MessageLoopShared* PluginGlobals::GetCurrentMessageLoop() {
+  return MessageLoopResource::GetCurrent();
+}
+
 MessageLoopResource* PluginGlobals::loop_for_main_thread() {
   return loop_for_main_thread_.get();
 }
diff --git a/ppapi/proxy/plugin_globals.h b/ppapi/proxy/plugin_globals.h
index 2bbc3f9..215ad63 100644
--- a/ppapi/proxy/plugin_globals.h
+++ b/ppapi/proxy/plugin_globals.h
@@ -56,6 +56,7 @@
                                       PP_LogLevel_Dev level,
                                       const std::string& source,
                                       const std::string& value) OVERRIDE;
+  virtual MessageLoopShared* GetCurrentMessageLoop() OVERRIDE;
 
   // Getters for the plugin-specific versions.
   PluginResourceTracker* plugin_resource_tracker() {
diff --git a/ppapi/proxy/ppb_message_loop_proxy.cc b/ppapi/proxy/ppb_message_loop_proxy.cc
index 916002d..b86ecf0 100644
--- a/ppapi/proxy/ppb_message_loop_proxy.cc
+++ b/ppapi/proxy/ppb_message_loop_proxy.cc
@@ -27,15 +27,15 @@
 }
 
 MessageLoopResource::MessageLoopResource(PP_Instance instance)
-    : Resource(OBJECT_IS_PROXY, instance),
+    : MessageLoopShared(instance),
       nested_invocations_(0),
       destroyed_(false),
       should_destroy_(false),
       is_main_thread_loop_(false) {
 }
 
-MessageLoopResource::MessageLoopResource(ForMainThread)
-    : Resource(Resource::Untracked()),
+MessageLoopResource::MessageLoopResource(ForMainThread for_main_thread)
+    : MessageLoopShared(for_main_thread),
       nested_invocations_(0),
       destroyed_(false),
       should_destroy_(false),
@@ -80,7 +80,7 @@
     if (slot->Get())
       return PP_ERROR_INPROGRESS;
   }
-  // TODO(brettw) check that the current thread can support a message loop.
+  // TODO(dmichael) check that the current thread can support a message loop.
 
   // Take a ref to the MessageLoop on behalf of the TLS. Note that this is an
   // internal ref and not a plugin ref so the plugin can't accidentally
@@ -140,20 +140,24 @@
   if (PP_ToBool(should_destroy))
     should_destroy_ = true;
 
-  if (IsCurrent())
+  if (IsCurrent() && nested_invocations_ > 0)
     loop_->Quit();
   else
     PostClosure(FROM_HERE, MessageLoop::QuitClosure(), 0);
   return PP_OK;
 }
 
-void MessageLoopResource::DetachFromThread() {
-  // Never detach the main thread from its loop resource. Other plugin instances
-  // might need it.
-  if (is_main_thread_loop_)
-    return;
+// static
+MessageLoopResource* MessageLoopResource::GetCurrent() {
+  PluginGlobals* globals = PluginGlobals::Get();
+  if (!globals->msg_loop_slot())
+    return NULL;
+  return reinterpret_cast<MessageLoopResource*>(
+      globals->msg_loop_slot()->Get());
+}
 
-  // Note that the message loop must be destroyed on the thread is was created
+void MessageLoopResource::DetachFromThread() {
+  // Note that the message loop must be destroyed on the thread it was created
   // on.
   loop_proxy_ = NULL;
   loop_.reset();
@@ -208,12 +212,10 @@
 }
 
 PP_Resource GetCurrent() {
-  PluginGlobals* globals = PluginGlobals::Get();
-  if (!globals->msg_loop_slot())
-    return 0;
-  MessageLoopResource* loop = reinterpret_cast<MessageLoopResource*>(
-      globals->msg_loop_slot()->Get());
-  return loop->GetReference();
+  Resource* resource = MessageLoopResource::GetCurrent();
+  if (resource)
+    return resource->GetReference();
+  return 0;
 }
 
 int32_t AttachToCurrentThread(PP_Resource message_loop) {
diff --git a/ppapi/proxy/ppb_message_loop_proxy.h b/ppapi/proxy/ppb_message_loop_proxy.h
index 325be78..689e439 100644
--- a/ppapi/proxy/ppb_message_loop_proxy.h
+++ b/ppapi/proxy/ppb_message_loop_proxy.h
@@ -11,7 +11,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "ppapi/proxy/interface_proxy.h"
-#include "ppapi/shared_impl/resource.h"
+#include "ppapi/shared_impl/ppb_message_loop_shared.h"
 #include "ppapi/thunk/ppb_message_loop_api.h"
 
 struct PPB_MessageLoop_Dev_0_1;
@@ -19,13 +19,12 @@
 namespace ppapi {
 namespace proxy {
 
-class MessageLoopResource : public Resource, public thunk::PPB_MessageLoop_API {
+class MessageLoopResource : public MessageLoopShared {
  public:
   explicit MessageLoopResource(PP_Instance instance);
   // Construct the one MessageLoopResource for the main thread. This must be
   // invoked on the main thread.
-  struct ForMainThread {};
-  MessageLoopResource(ForMainThread);
+  explicit MessageLoopResource(ForMainThread);
   virtual ~MessageLoopResource();
 
   // Resource overrides.
@@ -38,6 +37,7 @@
                            int64_t delay_ms) OVERRIDE;
   virtual int32_t PostQuit(PP_Bool should_destroy) OVERRIDE;
 
+  static MessageLoopResource* GetCurrent();
   void DetachFromThread();
   bool is_main_thread_loop() const {
     return is_main_thread_loop_;
@@ -58,9 +58,9 @@
   // NOTE: The given closure will be run *WITHOUT* acquiring the Proxy lock.
   //       This only makes sense for user code and completely thread-safe
   //       proxy operations (e.g., MessageLoop::QuitClosure).
-  void PostClosure(const tracked_objects::Location& from_here,
-                   const base::Closure& closure,
-                   int64 delay_ms);
+  virtual void PostClosure(const tracked_objects::Location& from_here,
+                           const base::Closure& closure,
+                           int64 delay_ms) OVERRIDE;
 
   // TLS destructor function.
   static void ReleaseMessageLoop(void* value);
diff --git a/ppapi/proxy/ppb_testing_proxy.cc b/ppapi/proxy/ppb_testing_proxy.cc
index b8c9ce0..576302f 100644
--- a/ppapi/proxy/ppb_testing_proxy.cc
+++ b/ppapi/proxy/ppb_testing_proxy.cc
@@ -53,12 +53,14 @@
 
 void RunMessageLoop(PP_Instance instance) {
   MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
-  // TODO(dmichael): We should probably assert that this is the main thread.
+  CHECK(PpapiGlobals::Get()->GetMainThreadMessageLoop()->
+            BelongsToCurrentThread());
   MessageLoop::current()->Run();
 }
 
 void QuitMessageLoop(PP_Instance instance) {
-  // TODO(dmichael): We should probably assert that this is the main thread.
+  CHECK(PpapiGlobals::Get()->GetMainThreadMessageLoop()->
+            BelongsToCurrentThread());
   MessageLoop::current()->QuitNow();
 }
 
diff --git a/ppapi/shared_impl/ppapi_globals.cc b/ppapi/shared_impl/ppapi_globals.cc
index 0336e0c..270d7e8 100644
--- a/ppapi/shared_impl/ppapi_globals.cc
+++ b/ppapi/shared_impl/ppapi_globals.cc
@@ -23,12 +23,12 @@
 PpapiGlobals::PpapiGlobals() {
   DCHECK(!ppapi_globals_);
   ppapi_globals_ = this;
-  message_loop_proxy_ = base::MessageLoopProxy::current();
+  main_loop_proxy_ = base::MessageLoopProxy::current();
 }
 
 PpapiGlobals::PpapiGlobals(ForTest) {
   DCHECK(!ppapi_globals_);
-  message_loop_proxy_ = base::MessageLoopProxy::current();
+  main_loop_proxy_ = base::MessageLoopProxy::current();
 }
 
 PpapiGlobals::~PpapiGlobals() {
@@ -45,7 +45,7 @@
 }
 
 base::MessageLoopProxy* PpapiGlobals::GetMainThreadMessageLoop() {
-  return message_loop_proxy_.get();
+  return main_loop_proxy_.get();
 }
 
 bool PpapiGlobals::IsHostGlobals() const {
diff --git a/ppapi/shared_impl/ppapi_globals.h b/ppapi/shared_impl/ppapi_globals.h
index e95cf48..b03d35c 100644
--- a/ppapi/shared_impl/ppapi_globals.h
+++ b/ppapi/shared_impl/ppapi_globals.h
@@ -24,6 +24,7 @@
 namespace ppapi {
 
 class CallbackTracker;
+class MessageLoopShared;
 class ResourceTracker;
 class VarTracker;
 
@@ -35,6 +36,7 @@
 // Abstract base class
 class PPAPI_SHARED_EXPORT PpapiGlobals {
  public:
+  // Must be created on the main thread.
   PpapiGlobals();
 
   // This constructor is to be used only for making a PpapiGlobal for testing
@@ -42,7 +44,7 @@
   // tests that use this feature, the "test" PpapiGlobals should be constructed
   // using this method. See SetPpapiGlobalsOnThreadForTest for more information.
   struct ForTest {};
-  PpapiGlobals(ForTest);
+  explicit PpapiGlobals(ForTest);
 
   virtual ~PpapiGlobals();
 
@@ -71,6 +73,7 @@
   virtual VarTracker* GetVarTracker() = 0;
   virtual CallbackTracker* GetCallbackTrackerForInstance(
       PP_Instance instance) = 0;
+
   virtual base::Lock* GetProxyLock() = 0;
 
   // Logs the given string to the JS console. If "source" is empty, the name of
@@ -103,11 +106,15 @@
   // failure.
   virtual PP_Module GetModuleForInstance(PP_Instance instance) = 0;
 
-  // Returns the base::MessageLoopProxy for the main thread. Note that this must
-  // be called on the main thread the first time so that it can initialize
-  // its static data.
+  // Returns the base::MessageLoopProxy for the main thread. This is set in the
+  // constructor, so PpapiGlobals must be created on the main thread.
   base::MessageLoopProxy* GetMainThreadMessageLoop();
 
+  // Return the MessageLoopShared of the current thread, if any. This will
+  // always return NULL on the host side, where PPB_MessageLoop is not
+  // supported.
+  virtual MessageLoopShared* GetCurrentMessageLoop() = 0;
+
   // Returns the command line for the process.
   virtual std::string GetCmdLine() = 0;
 
@@ -127,7 +134,7 @@
 
   static PpapiGlobals* ppapi_globals_;
 
-  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+  scoped_refptr<base::MessageLoopProxy> main_loop_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(PpapiGlobals);
 };
diff --git a/ppapi/shared_impl/ppb_message_loop_shared.cc b/ppapi/shared_impl/ppb_message_loop_shared.cc
new file mode 100644
index 0000000..9c0c92d8
--- /dev/null
+++ b/ppapi/shared_impl/ppb_message_loop_shared.cc
@@ -0,0 +1,20 @@
+// 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.
+
+#include "ppapi/shared_impl/ppb_message_loop_shared.h"
+
+namespace ppapi {
+
+MessageLoopShared::MessageLoopShared(PP_Instance instance)
+    : Resource(OBJECT_IS_PROXY, instance) {
+}
+
+MessageLoopShared::MessageLoopShared(ForMainThread)
+    : Resource(Resource::Untracked()) {
+}
+
+MessageLoopShared::~MessageLoopShared() {
+}
+
+}  // namespace ppapi
diff --git a/ppapi/shared_impl/ppb_message_loop_shared.h b/ppapi/shared_impl/ppb_message_loop_shared.h
new file mode 100644
index 0000000..fd6d1618
--- /dev/null
+++ b/ppapi/shared_impl/ppb_message_loop_shared.h
@@ -0,0 +1,52 @@
+// 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_SHARED_IMPL_PPB_MESSAGE_LOOP_SHARED_H_
+#define PPAPI_SHARED_IMPL_PPB_MESSAGE_LOOP_SHARED_H_
+
+#include "base/basictypes.h"
+#include "base/callback_forward.h"
+#include "base/location.h"
+#include "ppapi/c/pp_instance.h"
+#include "ppapi/shared_impl/ppapi_shared_export.h"
+#include "ppapi/shared_impl/resource.h"
+#include "ppapi/thunk/ppb_message_loop_api.h"
+
+namespace tracked_objects {
+class Location;
+}
+
+namespace ppapi {
+
+// MessageLoopShared doesn't really do anything interesting. It exists so that
+// shared code (in particular, TrackedCallback) can keep a pointer to a
+// MessageLoop resource. In the host side, there is not a concrete class that
+// implements this. So pointers to MessageLoopShared can only really be valid
+// on the plugin side.
+class PPAPI_SHARED_EXPORT MessageLoopShared
+    : public Resource,
+      public thunk::PPB_MessageLoop_API {
+ public:
+  explicit MessageLoopShared(PP_Instance instance);
+  // Construct the one MessageLoopShared for the main thread. This must be
+  // invoked on the main thread.
+  struct ForMainThread {};
+  explicit MessageLoopShared(ForMainThread);
+  virtual ~MessageLoopShared();
+
+  // Handles posting to the message loop if there is one, or the pending queue
+  // if there isn't.
+  // NOTE: The given closure will be run *WITHOUT* acquiring the Proxy lock.
+  //       This only makes sense for user code and completely thread-safe
+  //       proxy operations (e.g., MessageLoop::QuitClosure).
+  virtual void PostClosure(const tracked_objects::Location& from_here,
+                           const base::Closure& closure,
+                           int64 delay_ms) = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(MessageLoopShared);
+};
+
+}  // namespace ppapi
+
+#endif  // PPAPI_SHARED_IMPL_PPB_MESSAGE_LOOP_SHARED_H_
diff --git a/ppapi/shared_impl/test_globals.cc b/ppapi/shared_impl/test_globals.cc
index f8997dc..b1dc0fe0 100644
--- a/ppapi/shared_impl/test_globals.cc
+++ b/ppapi/shared_impl/test_globals.cc
@@ -69,4 +69,14 @@
                                          const std::string& value) {
 }
 
+MessageLoopShared* TestGlobals::GetCurrentMessageLoop() {
+  return NULL;
+}
+
+bool TestGlobals::IsHostGlobals() const {
+  // Pretend to be the host-side, for code that expects one or the other.
+  // TODO(dmichael): just make it settable which one we're pretending to be?
+  return true;
+}
+
 }  // namespace ppapi
diff --git a/ppapi/shared_impl/test_globals.h b/ppapi/shared_impl/test_globals.h
index 3675347..ca67e77 100644
--- a/ppapi/shared_impl/test_globals.h
+++ b/ppapi/shared_impl/test_globals.h
@@ -53,6 +53,10 @@
                                       PP_LogLevel_Dev level,
                                       const std::string& source,
                                       const std::string& value) OVERRIDE;
+  virtual MessageLoopShared* GetCurrentMessageLoop() OVERRIDE;
+
+  // PpapiGlobals overrides:
+  virtual bool IsHostGlobals() const OVERRIDE;
 
  private:
   ResourceTracker resource_tracker_;
diff --git a/ppapi/shared_impl/tracked_callback.cc b/ppapi/shared_impl/tracked_callback.cc
index 65d94be..bd011dfc 100644
--- a/ppapi/shared_impl/tracked_callback.cc
+++ b/ppapi/shared_impl/tracked_callback.cc
@@ -14,11 +14,21 @@
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/callback_tracker.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
+#include "ppapi/shared_impl/ppb_message_loop_shared.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource.h"
 
 namespace ppapi {
 
+namespace {
+
+bool IsMainThread() {
+  return
+      PpapiGlobals::Get()->GetMainThreadMessageLoop()->BelongsToCurrentThread();
+}
+
+}  // namespace
+
 // TrackedCallback -------------------------------------------------------------
 
 // Note: don't keep a Resource* since it may go out of scope before us.
@@ -30,7 +40,12 @@
       completed_(false),
       aborted_(false),
       callback_(callback),
+      target_loop_(PpapiGlobals::Get()->GetCurrentMessageLoop()),
       result_for_blocked_callback_(PP_OK) {
+  // Note that target_loop_ may be NULL at this point, if the plugin has not
+  // attached a loop to this thread, or if this is an in-process plugin.
+  // The Enter class should handle checking this for us.
+
   // TODO(dmichael): Add tracking at the instance level, for callbacks that only
   // have an instance (e.g. for MouseLock).
   if (resource) {
@@ -40,19 +55,27 @@
   }
 
   base::Lock* proxy_lock = PpapiGlobals::Get()->GetProxyLock();
-  // We only need a ConditionVariable if the lock is valid (i.e., we're out-of-
-  // process) and the callback is blocking.
-  if (proxy_lock && is_blocking())
-    operation_completed_condvar_.reset(new base::ConditionVariable(proxy_lock));
+  if (proxy_lock) {
+    // If the proxy_lock is valid, we're running out-of-process, and locking
+    // is enabled.
+    if (is_blocking()) {
+      // This is a blocking completion callback, so we will need a condition
+      // variable for blocking & signalling the calling thread.
+      operation_completed_condvar_.reset(
+          new base::ConditionVariable(proxy_lock));
+    } else {
+      // It's a non-blocking callback, so we should have a MessageLoopResource
+      // to dispatch to. Note that we don't error check here, though. Later,
+      // EnterResource::SetResult will check to make sure the callback is valid
+      // and take appropriate action.
+    }
+  }
 }
 
 TrackedCallback::~TrackedCallback() {
 }
 
 void TrackedCallback::Abort() {
-  // It doesn't make sense to abort a callback that's not associated with a
-  // resource.
-  DCHECK(resource_id_);
   Run(PP_ERROR_ABORTED);
 }
 
@@ -71,12 +94,10 @@
   if (result == PP_ERROR_ABORTED)
     aborted_ = true;
 
-  // Copy |callback_| and look at |aborted()| now, since |MarkAsCompleted()|
-  // may delete us.
-  PP_CompletionCallback callback = callback_;
   // Note that this call of Run() may have been scheduled prior to Abort() or
   // PostAbort() being called. If we have been told to Abort, that always
-  // trumps a result that was scheduled before.
+  // trumps a result that was scheduled before, so we should make sure to pass
+  // PP_ERROR_ABORTED.
   if (aborted())
     result = PP_ERROR_ABORTED;
 
@@ -100,6 +121,15 @@
     // Wait()s.
     operation_completed_condvar_->Signal();
   } else {
+    // If there's a target_loop_, and we're not on the right thread, we need to
+    // post to target_loop_.
+    if (target_loop_ &&
+        target_loop_ != PpapiGlobals::Get()->GetCurrentMessageLoop()) {
+      PostRun(result);
+      return;
+    }
+    // Copy |callback_| now, since |MarkAsCompleted()| may delete us.
+    PP_CompletionCallback callback = callback_;
     // Do this before running the callback in case of reentrancy (which
     // shouldn't happen, but avoid strange failures).
     MarkAsCompleted();
@@ -122,7 +152,15 @@
 
   base::Closure callback_closure(
       RunWhileLocked(base::Bind(&TrackedCallback::Run, this, result)));
-  MessageLoop::current()->PostTask(FROM_HERE, callback_closure);
+  if (!target_loop_) {
+    // We must be running in-process and on the main thread (the Enter
+    // classes protect against having a null target_loop_ otherwise).
+    DCHECK(IsMainThread());
+    DCHECK(PpapiGlobals::Get()->IsHostGlobals());
+    MessageLoop::current()->PostTask(FROM_HERE, callback_closure);
+  } else {
+    target_loop_->PostClosure(FROM_HERE, callback_closure, 0);
+  }
   is_scheduled_ = true;
 }
 
diff --git a/ppapi/shared_impl/tracked_callback.h b/ppapi/shared_impl/tracked_callback.h
index 1fa7b1bc..03bf1626 100644
--- a/ppapi/shared_impl/tracked_callback.h
+++ b/ppapi/shared_impl/tracked_callback.h
@@ -16,10 +16,12 @@
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/shared_impl/ppapi_shared_export.h"
+#include "ppapi/shared_impl/ppb_message_loop_shared.h"
 
 namespace ppapi {
 
 class CallbackTracker;
+class MessageLoopShared;
 class Resource;
 
 namespace thunk {
@@ -76,7 +78,6 @@
   // Run() will invoke the call immediately, if invoked from the target thread
   // (as determined by target_loop_). If invoked on a different thread, the
   // callback will be scheduled to run later on target_loop_.
-  // TODO(dmichael): Make the above part about different threads actually true.
   void Run(int32_t result);
   // PostRun is like Run(), except it guarantees that the callback will be run
   // later. In particular, if you invoke PostRun on the same thread on which the
@@ -116,6 +117,9 @@
     return (callback_.func &&
             (callback_.flags & PP_COMPLETIONCALLBACK_FLAG_OPTIONAL));
   }
+  bool has_null_target_loop() const {
+    return target_loop_ == NULL;
+  }
 
  private:
   // TrackedCallback and EnterBase manage dealing with how to invoke callbacks
@@ -146,6 +150,10 @@
   bool aborted_;
   PP_CompletionCallback callback_;
 
+  // The MessageLoopShared on which this callback should be run. This will be
+  // NULL if we're in-process.
+  scoped_refptr<MessageLoopShared> target_loop_;
+
   int32_t result_for_blocked_callback_;
   // Used for pausing/waking the blocked thread if this is a blocking completion
   // callback. Note that in-process, there is no lock, blocking callbacks are
diff --git a/ppapi/tests/test_case.h b/ppapi/tests/test_case.h
index 2cf2ddf..aa35046e 100644
--- a/ppapi/tests/test_case.h
+++ b/ppapi/tests/test_case.h
@@ -122,11 +122,12 @@
              "Chrome, use the --enable-pepper-testing flag.";
     }
     // These tests are only valid if running out-of-process (threading is not
-    // supported in-process). Just consider it a pass.
+    // supported in-process). For in-process, just consider it a pass.
     if (!testing_interface_->IsOutOfProcess())
       return std::string();
+    pp::MessageLoop_Dev background_loop(instance_);
     ThreadedTestRunner<T> runner(instance_->pp_instance(),
-        static_cast<T*>(this), test_to_run);
+        static_cast<T*>(this), test_to_run, background_loop);
     RunOnThreadInternal(&ThreadedTestRunner<T>::ThreadFunction, &runner,
                         testing_interface_);
     return runner.result();
@@ -162,10 +163,12 @@
     typedef std::string(T::*TestMethodType)();
     ThreadedTestRunner(PP_Instance instance,
                        T* test_case,
-                       TestMethodType test_to_run)
+                       TestMethodType test_to_run,
+                       pp::MessageLoop_Dev loop)
         : instance_(instance),
           test_case_(test_case),
-          test_to_run_(test_to_run) {
+          test_to_run_(test_to_run),
+          loop_(loop) {
     }
     const std::string& result() { return result_; }
     static void ThreadFunction(void* runner) {
@@ -174,9 +177,11 @@
 
    private:
     void Run() {
-      // TODO(dmichael): Create and attach a pp::MessageLoop for this thread so
-      //                 nested loops work.
+      PP_DCHECK(PP_OK == loop_.AttachToCurrentThread());
       result_ = (test_case_->*test_to_run_)();
+      // Now give the loop a chance to clean up.
+      loop_.PostQuit(true /* should_destroy */);
+      loop_.Run();
       // Tell the main thread to quit its nested message loop, now that the test
       // is complete.
       TestCase::QuitMainMessageLoop(instance_);
@@ -186,6 +191,7 @@
     PP_Instance instance_;
     T* test_case_;
     TestMethodType test_to_run_;
+    pp::MessageLoop_Dev loop_;
   };
 
   // The internals for RunOnThread. This allows us to avoid including
@@ -275,6 +281,12 @@
         CheckResourcesAndVars(RunOnThread(&test_case::Test##name))); \
   }
 
+#define RUN_TEST_BACKGROUND(test_case, name, test_filter) \
+  if (MatchesFilter(#name, test_filter)) { \
+    instance_->LogTest(#name"Background", \
+        CheckResourcesAndVars(RunOnThread(&test_case::Test##name))); \
+  }
+
 #define RUN_TEST_FORCEASYNC_AND_NOT(name, test_filter) \
   do { \
     RUN_TEST_FORCEASYNC(name, test_filter); \
@@ -287,6 +299,7 @@
     RUN_TEST_FORCEASYNC(name, test_filter); \
     RUN_TEST(name, test_filter); \
     RUN_TEST_BLOCKING(test_case, name, test_filter); \
+    RUN_TEST_BACKGROUND(test_case, name, test_filter); \
   } while (false)
 
 #define RUN_TEST_WITH_REFERENCE_CHECK(name, test_filter) \
diff --git a/ppapi/tests/test_utils.cc b/ppapi/tests/test_utils.cc
index 9776e34..20a8a81 100644
--- a/ppapi/tests/test_utils.cc
+++ b/ppapi/tests/test_utils.cc
@@ -13,6 +13,7 @@
 #endif
 
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/cpp/dev/message_loop_dev.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/var.h"
 
@@ -138,7 +139,7 @@
   errors_.clear();
   if (!have_result_) {
     post_quit_task_ = true;
-    GetTestingInterface()->RunMessageLoop(instance_);
+    RunMessageLoop();
   }
   return result_;
 }
@@ -150,7 +151,7 @@
   if (result == PP_OK_COMPLETIONPENDING) {
     if (!have_result_) {
       post_quit_task_ = true;
-      GetTestingInterface()->RunMessageLoop(instance_);
+      RunMessageLoop();
     }
     if (callback_type_ == PP_BLOCKING) {
       errors_.assign(
@@ -200,6 +201,7 @@
     return pp::CompletionCallback();
   else if (callback_type_ == PP_OPTIONAL)
     flags = PP_COMPLETIONCALLBACK_FLAG_OPTIONAL;
+  target_loop_ = pp::MessageLoop_Dev::GetCurrent();
   return pp::CompletionCallback(&TestCompletionCallback::Handler,
                                 const_cast<TestCompletionCallback*>(this),
                                 flags);
@@ -229,7 +231,36 @@
     callback->delegate_->OnCallback(user_data, result);
   if (callback->post_quit_task_) {
     callback->post_quit_task_ = false;
-    GetTestingInterface()->QuitMessageLoop(callback->instance_);
+    callback->QuitMessageLoop();
+  }
+  if (callback->target_loop_ != pp::MessageLoop_Dev::GetCurrent()) {
+    // Note, in-process, loop_ and GetCurrent() will both be NULL, so should
+    // still be equal.
+    callback->errors_.assign(
+        ReportError("TestCompletionCallback: Callback ran on the wrong message "
+                    "loop!",
+                    result));
   }
 }
 
+void TestCompletionCallback::RunMessageLoop() {
+  pp::MessageLoop_Dev loop(pp::MessageLoop_Dev::GetCurrent());
+  // If we don't have a message loop, we're probably running in process, where
+  // PPB_MessageLoop is not supported. Just use the Testing message loop.
+  if (loop.is_null() || loop == pp::MessageLoop_Dev::GetForMainThread())
+    GetTestingInterface()->RunMessageLoop(instance_);
+  else
+    loop.Run();
+}
+
+void TestCompletionCallback::QuitMessageLoop() {
+  pp::MessageLoop_Dev loop(pp::MessageLoop_Dev::GetCurrent());
+  // If we don't have a message loop, we're probably running in process, where
+  // PPB_MessageLoop is not supported. Just use the Testing message loop.
+  if (loop.is_null() || loop == pp::MessageLoop_Dev::GetForMainThread()) {
+    GetTestingInterface()->QuitMessageLoop(instance_);
+  } else {
+    const bool should_quit = false;
+    loop.PostQuit(should_quit);
+  }
+}
diff --git a/ppapi/tests/test_utils.h b/ppapi/tests/test_utils.h
index ab87dd3..60f7fc4 100644
--- a/ppapi/tests/test_utils.h
+++ b/ppapi/tests/test_utils.h
@@ -11,6 +11,7 @@
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/dev/message_loop_dev.h"
 #include "ppapi/utility/completion_callback_factory.h"
 
 // Timeout to wait for some action to complete.
@@ -152,6 +153,8 @@
 
  private:
   static void Handler(void* user_data, int32_t result);
+  void RunMessageLoop();
+  void QuitMessageLoop();
 
   // Used to check that WaitForResult is only called once for each usage of the
   // callback.
@@ -166,6 +169,7 @@
   unsigned run_count_;
   PP_Instance instance_;
   Delegate* delegate_;
+  pp::MessageLoop_Dev target_loop_;
 };
 
 // Verifies that the callback didn't record any errors. If the callback is run
diff --git a/ppapi/thunk/enter.cc b/ppapi/thunk/enter.cc
index c89c969..296a8b4 100644
--- a/ppapi/thunk/enter.cc
+++ b/ppapi/thunk/enter.cc
@@ -87,8 +87,6 @@
     // The function completed synchronously.
     if (callback_->is_required()) {
       // This is a required callback, so we must issue it asynchronously.
-      // TODO(dmichael) make this work so that a call from a background thread
-      // goes back to that thread.
       callback_->PostRun(result);
       retval_ = PP_OK_COMPLETIONPENDING;
     } else {
@@ -108,25 +106,54 @@
 }
 
 void EnterBase::SetStateForCallbackError(bool report_error) {
-  if (!CallbackIsValid()) {
-    callback_->MarkAsCompleted();
-    callback_ = NULL;
-    retval_ = PP_ERROR_BLOCKS_MAIN_THREAD;
-    if (report_error) {
-      std::string message(
-          "Blocking callbacks are not allowed on the main thread.");
-      PpapiGlobals::Get()->BroadcastLogWithSource(0, PP_LOGLEVEL_ERROR,
-                                                  std::string(), message);
+  if (PpapiGlobals::Get()->IsHostGlobals()) {
+    // In-process plugins can't make PPAPI calls off the main thread.
+    CHECK(IsMainThread());
+  }
+  if (callback_) {
+    if (callback_->is_blocking() && IsMainThread()) {
+      // Blocking callbacks are never allowed on the main thread.
+      callback_->MarkAsCompleted();
+      callback_ = NULL;
+      retval_ = PP_ERROR_BLOCKS_MAIN_THREAD;
+      if (report_error) {
+        std::string message(
+            "Blocking callbacks are not allowed on the main thread.");
+        PpapiGlobals::Get()->BroadcastLogWithSource(0, PP_LOGLEVEL_ERROR,
+                                                    std::string(), message);
+      }
+    } else if (!IsMainThread() &&
+               callback_->has_null_target_loop() &&
+               !callback_->is_blocking()) {
+      // On a non-main thread, there must be a valid target loop for non-
+      // blocking callbacks, or we will have no place to run them.
+
+      // If the callback is required, there's no nice way to tell the plugin.
+      // We can't run their callback asynchronously without a message loop, and
+      // the plugin won't expect any return code other than
+      // PP_OK_COMPLETIONPENDING. So we crash to make the problem more obvious.
+      if (callback_->is_required()) {
+        std::string message("Attempted to use a required callback, but there"
+                            "is no attached message loop on which to run the"
+                            "callback.");
+        PpapiGlobals::Get()->BroadcastLogWithSource(0, PP_LOGLEVEL_ERROR,
+                                                    std::string(), message);
+        LOG(FATAL) << message;
+      }
+
+      callback_->MarkAsCompleted();
+      callback_ = NULL;
+      retval_ = PP_ERROR_NO_MESSAGE_LOOP;
+      if (report_error) {
+        std::string message(
+            "The calling thread must have a message loop attached.");
+        PpapiGlobals::Get()->BroadcastLogWithSource(0, PP_LOGLEVEL_ERROR,
+                                                    std::string(), message);
+      }
     }
   }
 }
 
-bool EnterBase::CallbackIsValid() const {
-  // A callback is only considered invalid if it is blocking and we're on the
-  // main thread.
-  return !callback_ || !callback_->is_blocking() || !IsMainThread();
-}
-
 void EnterBase::ClearCallback() {
   callback_ = NULL;
 }
@@ -145,8 +172,6 @@
     return;  // Everything worked.
 
   if (callback_ && callback_->is_required()) {
-    // TODO(dmichael) make this work so that a call from a background thread
-    // goes back to that thread.
     callback_->PostRun(static_cast<int32_t>(PP_ERROR_BADRESOURCE));
     callback_ = NULL;
     retval_ = PP_OK_COMPLETIONPENDING;
diff --git a/ppapi/thunk/ppb_message_loop_api.h b/ppapi/thunk/ppb_message_loop_api.h
index 52660cad..efc1862 100644
--- a/ppapi/thunk/ppb_message_loop_api.h
+++ b/ppapi/thunk/ppb_message_loop_api.h
@@ -9,6 +9,7 @@
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_stdint.h"
+#include "ppapi/thunk/ppapi_thunk_export.h"
 
 namespace ppapi {
 
@@ -16,7 +17,7 @@
 
 namespace thunk {
 
-class PPB_MessageLoop_API {
+class PPAPI_THUNK_EXPORT PPB_MessageLoop_API {
  public:
   virtual ~PPB_MessageLoop_API() {}
 
diff --git a/webkit/plugins/ppapi/host_globals.cc b/webkit/plugins/ppapi/host_globals.cc
index 643ea8c..7ab611d 100644
--- a/webkit/plugins/ppapi/host_globals.cc
+++ b/webkit/plugins/ppapi/host_globals.cc
@@ -178,6 +178,10 @@
      (*i)->element().document().frame()->addMessageToConsole(message);
 }
 
+::ppapi::MessageLoopShared* HostGlobals::GetCurrentMessageLoop() {
+  return NULL;
+}
+
 PP_Module HostGlobals::AddModule(PluginModule* module) {
 #ifndef NDEBUG
   // Make sure we're not adding one more than once.
diff --git a/webkit/plugins/ppapi/host_globals.h b/webkit/plugins/ppapi/host_globals.h
index fb46d70..2cc98c7 100644
--- a/webkit/plugins/ppapi/host_globals.h
+++ b/webkit/plugins/ppapi/host_globals.h
@@ -54,6 +54,7 @@
                                       PP_LogLevel_Dev level,
                                       const std::string& source,
                                       const std::string& value) OVERRIDE;
+  virtual ::ppapi::MessageLoopShared* GetCurrentMessageLoop() OVERRIDE;
 
   HostVarTracker* host_var_tracker() {
     return &host_var_tracker_;