PPAPI: Never re-enter JavaScript for PostMessage.

ppapi/proxy/host_dispatcher.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/host_dispatcher.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/c/ppb_var.h"
@@ skipping 43 matching lines @@
   }
  private:
   bool* var_;
   bool old_value_;
 };
 
 }  // namespace
 
 HostDispatcher::HostDispatcher(PP_Module module,
                                PP_GetInterface_Func local_get_interface,
-                               SyncMessageStatusReceiver* sync_status,
                                const PpapiPermissions& permissions)
     : Dispatcher(local_get_interface, permissions),
-      sync_status_(sync_status),
       pp_module_(module),
       ppb_proxy_(NULL),
-      allow_plugin_reentrancy_(false) {
+      allow_plugin_reentrancy_(false),
+      weak_ptr_factory_(this) {
   if (!g_module_to_dispatcher)
     g_module_to_dispatcher = new ModuleToDispatcherMap;
   (*g_module_to_dispatcher)[pp_module_] = this;
 
   SetSerializationRules(new HostVarSerializationRules);
 
   ppb_proxy_ = reinterpret_cast<const PPB_Proxy_Private*>(
       local_get_interface(PPB_PROXY_PRIVATE_INTERFACE));
   DCHECK(ppb_proxy_) << "The proxy interface should always be supported.";
 
   ppb_proxy_->SetReserveInstanceIDCallback(pp_module_, &ReserveInstanceID);
 }
 
 HostDispatcher::~HostDispatcher() {
   g_module_to_dispatcher->erase(pp_module_);
 }
 
 bool HostDispatcher::InitHostWithChannel(
     Delegate* delegate,
     base::ProcessId peer_pid,
     const IPC::ChannelHandle& channel_handle,
     bool is_client,
     const ppapi::Preferences& preferences) {
   if (!Dispatcher::InitWithChannel(delegate, peer_pid, channel_handle,
                                    is_client))
     return false;
-  AddIOThreadMessageFilter(sync_status_.get());
-
   Send(new PpapiMsg_SetPreferences(preferences));
   return true;
 }
 
 // static
 HostDispatcher* HostDispatcher::GetForInstance(PP_Instance instance) {
   if (!g_instance_to_dispatcher)
     return NULL;
   InstanceToDispatcherMap::iterator found = g_instance_to_dispatcher->find(
       instance);
@@ skipping 41 matching lines @@
     // Don't allow sending sync messages during module shutdown. Seee the "else"
     // block below for why.
     CHECK(!PP_ToBool(ppb_proxy()->IsInModuleDestructor(pp_module())));
 
     // Prevent the dispatcher from going away during sync calls. Scenarios
     // where this could happen include a Send for a sync message which while
     // waiting for the reply, dispatches an incoming ExecuteScript call which
     // destroys the plugin module and in turn the dispatcher.
     ScopedModuleReference scoped_ref(this);
 
-    sync_status_->BeginBlockOnSyncMessage();
+    FOR_EACH_OBSERVER(SyncMessageStatusObserver, sync_status_observer_list_,
+                      BeginBlockOnSyncMessage());
     bool result = Dispatcher::Send(msg);
-    sync_status_->EndBlockOnSyncMessage();
+    FOR_EACH_OBSERVER(SyncMessageStatusObserver, sync_status_observer_list_,
+                      EndBlockOnSyncMessage());
 
     return result;
   } else {
     // We don't want to have a scoped ref for async message cases since since
     // async messages are sent during module desruction. In this case, the
     // module will have a 0 refcount and addrefing and releasing it will
     // reenter the destructor and it will crash.
     return Dispatcher::Send(msg);
   }
 }
@@ skipping 60 matching lines @@
     std::pair<PluginSupportedMap::iterator, bool> iter_success_pair;
     iter_success_pair = plugin_supported_.insert(
         PluginSupportedMap::value_type(iface_name, supported));
     iter = iter_success_pair.first;
   }
   if (iter->second)
     return proxied_interface;
   return NULL;
 }
 
+base::Closure HostDispatcher::AddSyncMessageStatusObserver(
+    SyncMessageStatusObserver* obs) {
+  sync_status_observer_list_.AddObserver(obs);
+  return base::Bind(&HostDispatcher::RemoveSyncMessageStatusObserver,
+                    weak_ptr_factory_.GetWeakPtr(),
+                    obs);
+}
+
+void HostDispatcher::RemoveSyncMessageStatusObserver(
+    SyncMessageStatusObserver* obs) {
+  sync_status_observer_list_.RemoveObserver(obs);
+}
+
 void HostDispatcher::AddFilter(IPC::Listener* listener) {
   filters_.push_back(listener);
 }
 
 void HostDispatcher::OnInvalidMessageReceived() {
   // TODO(brettw) bug 95345 kill the plugin when an invalid message is
   // received.
 }
 
 void HostDispatcher::OnHostMsgLogWithSource(PP_Instance instance,
@@ skipping 19 matching lines @@
   }
 }
 
 ScopedModuleReference::~ScopedModuleReference() {
   if (dispatcher_)
     dispatcher_->ppb_proxy()->ReleaseModule(dispatcher_->pp_module());
 }
 
 }  // namespace proxy
 }  // namespace ppapi