PPAPI: Make CompletionCallbacks work right on background threads.

ppapi/thunk/enter.cc

 // 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/thunk/enter.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
@@ skipping 69 matching lines @@
       retval_ = callback_->BlockUntilComplete();
     } else {
       // The callback is not blocking and the operation will complete
       // asynchronously, so there's nothing to do.
       retval_ = result;
     }
   } else {
     // 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 {
       // The callback is blocking or optional, so all we need to do is mark
       // the callback as completed so that it won't be issued later.
       callback_->MarkAsCompleted();
       retval_ = result;
     }
   }
   callback_ = NULL;
   return retval_;
 }
 
 // static
 Resource* EnterBase::GetResource(PP_Resource resource) {
   return PpapiGlobals::Get()->GetResourceTracker()->GetResource(resource);
 }
 
 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;
 }
 
 void EnterBase::SetStateForResourceError(PP_Resource pp_resource,
                                          Resource* resource_base,
                                          void* object,
                                          bool report_error) {
   // Check for callback errors. If we get any, SetStateForCallbackError will
   // emit a log message. But we also want to check for resource errors. If there
   // are both kinds of errors, we'll emit two log messages and return
   // PP_ERROR_BADRESOURCE.
   SetStateForCallbackError(report_error);
 
   if (object)
     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;
   } else {
     if (callback_)
       callback_->MarkAsCompleted();
     callback_ = NULL;
     retval_ = PP_ERROR_BADRESOURCE;
   }
 
@@ skipping 105 matching lines @@
     : EnterBase(),
       functions_(PpapiGlobals::Get()->GetResourceCreationAPI(instance)) {
   SetStateForFunctionError(instance, functions_, true);
 }
 
 EnterResourceCreationNoLock::~EnterResourceCreationNoLock() {
 }
 
 }  // namespace thunk
 }  // namespace ppapi