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 55 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) {
+  // Clear the unblock flag for all messages from the host to the plugin.
+  //
+  // This prevents reentrancy in the plugin when both sides send sync messages.
+  // Since the plugin dispatcher does NOT do this, we won't get a deadlock,
+  // but can get reentrancy in the host.
+  //
+  // This is a temporary workaround until all plugin messages can be made
+  // non-blocking (which is a much better solution). It's preferrable to the
+  // alternatives because in general plugin -> host sync messages interact with
+  // the pepper implementation which is reasonably reentrant. On the other

[piman, 2011/03/07 21:01:29]

Well, technically the browser side needs to be reentrant in all cases because
that's exactly what happens in the non-proxy case.

+  // hand, the plugin will not expect an input event from inside a call to
+  // CreateResource.
+  msg->set_unblock(false);

[piman, 2011/03/07 21:01:29]

So, this is in general ok, and what we want, but there are a few cases where we
actually need to re-enter the plugin and explicitly not delay the messages.
Basically when the plugin needs to be re-entered. This happens for var
scripting. I think that's the only case.
So really what we should do is make set_unblock(false) the default, but have a
way for incoming plugin->browser messages to change it to true, but change it
again to false when we do re-enter into the plugin.
That way we should handle correctly the case:

browser unsets the reentrant flag
browser sends HandleEvent to the plugin
{
  plugin sends var.Call to the browser
  {
    browser sets the reentrant flag
    [ javascript ] 
    javascript needs to call into the plugin
    browser unsets the reentrant flag
    browser sends var.Call to the plugin
    {
      plugin sends font.Render to the browser
      {
        // browser doesn't set the reentrant flag
        // pending DidChangeView from browser gets delayed
      }
    }
  }
}

+  return Dispatcher::Send(msg);
+}
+
 bool HostDispatcher::OnMessageReceived(const IPC::Message& msg) {
   // 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 85 matching lines @@
   }
 
   InterfaceProxy* proxy = info->create_proxy(this, local_interface);
   target_proxies_[info->id].reset(proxy);
   return proxy;
 }
 
 }  // namespace proxy
 }  // namespace pp