PPAPI: Disallow blocking callbacks while handling a blocking message

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/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/tracked_callback.h"
 #include "ppapi/thunk/ppb_instance_api.h"
 #include "ppapi/thunk/resource_creation_api.h"
 
 namespace ppapi {
 namespace {
 
 bool IsMainThread() {
   return
       PpapiGlobals::Get()->GetMainThreadMessageLoop()->BelongsToCurrentThread();
 }
 
+bool CurrentThreadHandlingBlockingMessage() {
+  ppapi::MessageLoopShared* current =
+      PpapiGlobals::Get()->GetCurrentMessageLoop();
+  return current && current->CurrentlyHandlingBlockingMessage();
+}
+
 }  // namespace
 
 namespace thunk {
 
 namespace subtle {
 
 EnterBase::EnterBase()
     : resource_(NULL),
       retval_(PP_OK) {
   PpapiGlobals::Get()->MarkPluginIsActive();
@@ skipping 98 matching lines @@
       // 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 (callback_->is_blocking() &&
+               CurrentThreadHandlingBlockingMessage()) {
+      // Blocking callbacks are not allowed while handling a blocking message.
+      callback_->MarkAsCompleted();
+      callback_ = NULL;
+      retval_ = PP_ERROR_WOULD_BLOCK_THREAD;
+      if (report_error) {
+        std::string message("Blocking callbacks are not allowed while handling "
+                            "a blocking message from JavaScript.");
+        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.
@@ skipping 155 matching lines @@
     : EnterBase(),
       functions_(PpapiGlobals::Get()->GetResourceCreationAPI(instance)) {
   SetStateForFunctionError(instance, functions_, true);
 }
 
 EnterResourceCreationNoLock::~EnterResourceCreationNoLock() {
 }
 
 }  // namespace thunk
 }  // namespace ppapi