Prevent Pepper plugin reentrncy for synchronous messages.

ppapi/proxy/host_dispatcher.cc

 // Copyright (c) 2010 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/host_dispatcher.h"
 
 #include <map>
 
 #include "base/logging.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
@@ skipping 23 matching lines @@
     NOTREACHED();
     return PP_TRUE;
   }
 
   bool usable = true;
   if (!found->second->Send(new PpapiMsg_ReserveInstanceId(instance, &usable)))
     return PP_TRUE;
   return BoolToPPBool(usable);
 }
 
+// Saves the state of the given bool and puts it back when it goes out of
+// scope.
+class BoolRestorer {
+ public:
+  BoolRestorer(bool* var) : var_(var), old_value_(*var) {
+  }
+  ~BoolRestorer() {
+    *var_ = old_value_;
+  }
+ private:
+  bool* var_;
+  bool old_value_;
+};
+
 }  // namespace
 
 HostDispatcher::HostDispatcher(base::ProcessHandle remote_process_handle,
                                PP_Module module,
                                GetInterfaceFunc local_get_interface)
     : Dispatcher(remote_process_handle, local_get_interface),
       pp_module_(module),
       ppb_proxy_(NULL) {
   if (!g_module_to_dispatcher)
     g_module_to_dispatcher = new ModuleToDispatcherMap;
@@ skipping 44 matching lines @@
   InstanceToDispatcherMap::iterator found = g_instance_to_dispatcher->find(
       instance);
   if (found != g_instance_to_dispatcher->end())
     g_instance_to_dispatcher->erase(found);
 }
 
 bool HostDispatcher::IsPlugin() const {
   return false;
 }
 
+bool HostDispatcher::Send(IPC::Message* msg) {
+  // Normal sync messages are set to unblock, which would normally cause the
+  // plugin to be reentered to process them. We only want to do this when we
+  // know the plugin is in a state to accept reentrancy. Since the plugin side
+  // never clears this flag on messages it sends, we can't get deadlock, but we
+  // may still get reentrancy in the host as a result.
+  if (!allow_plugin_reentrancy_)
+    msg->set_unblock(false);
+  return Dispatcher::Send(msg);
+}
+
 bool HostDispatcher::OnMessageReceived(const IPC::Message& msg) {
+  // We only want to allow reentrancy when the most recent message from the
+  // plugin was a scripting message. We save the old state of the flag on the
+  // stack in case we're (we are the host) being reentered ourselves. The flag
+  // is set to false here for all messages, and then the scripting API will
+  // explicitly set it to true during processing of those messages that can be
+  // reentered.
+  BoolRestorer restorer(&allow_plugin_reentrancy_);
+  allow_plugin_reentrancy_ = false;
+
   // Handle common control messages.
   if (Dispatcher::OnMessageReceived(msg))
     return true;
 
   if (msg.routing_id() <= 0 && msg.routing_id() >= INTERFACE_ID_COUNT) {
     NOTREACHED();
     // TODO(brettw): kill the plugin if it starts sending invalid messages?
     return true;
   }
 
@@ skipping 76 matching lines @@
   }
 
   InterfaceProxy* proxy = info->create_proxy(this, local_interface);
   target_proxies_[info->id].reset(proxy);
   return proxy;
 }
 
 }  // namespace proxy
 }  // namespace pp