PPAPI: Disallow blocking callbacks while handling a blocking message

ppapi/proxy/ppb_message_loop_proxy.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/proxy/ppb_message_loop_proxy.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 13 matching lines @@
 
 namespace {
 typedef thunk::EnterResource<PPB_MessageLoop_API> EnterMessageLoop;
 }
 
 MessageLoopResource::MessageLoopResource(PP_Instance instance)
     : MessageLoopShared(instance),
       nested_invocations_(0),
       destroyed_(false),
       should_destroy_(false),
-      is_main_thread_loop_(false) {
+      is_main_thread_loop_(false),
+      currently_handling_blocking_message_(false) {
 }
 
 MessageLoopResource::MessageLoopResource(ForMainThread for_main_thread)
     : MessageLoopShared(for_main_thread),
       nested_invocations_(0),
       destroyed_(false),
       should_destroy_(false),
-      is_main_thread_loop_(true) {
+      is_main_thread_loop_(true),
+      currently_handling_blocking_message_(false) {
   // We attach the main thread immediately. We can't use AttachToCurrentThread,
   // because the MessageLoop already exists.
 
   // This must be called only once, so the slot must be empty.
   CHECK(!PluginGlobals::Get()->msg_loop_slot());
   // We don't add a reference for TLS here, so we don't release it. Instead,
   // this loop is owned by PluginGlobals. Contrast with AttachToCurrentThread
   // where we register ReleaseMessageLoop with TLS and call AddRef.
   base::ThreadLocalStorage::Slot* slot = new base::ThreadLocalStorage::Slot();
   PluginGlobals::Get()->set_msg_loop_slot(slot);
@@ skipping 133 matching lines @@
     info.closure = closure;
     info.delay_ms = delay_ms;
     pending_tasks_.push_back(info);
   }
 }
 
 base::MessageLoopProxy* MessageLoopResource::GetMessageLoopProxy() {
   return loop_proxy_.get();
 }
 
+bool MessageLoopResource::CurrentlyHandlingBlockingMessage() {
+  return currently_handling_blocking_message_;
+}
+
 // static
 void MessageLoopResource::ReleaseMessageLoop(void* value) {
   static_cast<MessageLoopResource*>(value)->DetachFromThread();
 }
 
 // -----------------------------------------------------------------------------
 
 PP_Resource Create(PP_Instance instance) {
   ProxyAutoLock lock;
   // Validate the instance.
@@ skipping 63 matching lines @@
 PPB_MessageLoop_Proxy::~PPB_MessageLoop_Proxy() {
 }
 
 // static
 const PPB_MessageLoop_1_0* PPB_MessageLoop_Proxy::GetInterface() {
   return &ppb_message_loop_interface;
 }
 
 }  // namespace proxy
 }  // namespace ppapi