Add a hang monitor for Pepper plugins

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 <map>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 45 matching lines @@
   }
  private:
   bool* var_;
   bool old_value_;
 };
 
 }  // namespace
 
 HostDispatcher::HostDispatcher(base::ProcessHandle remote_process_handle,
                                PP_Module module,
-                               GetInterfaceFunc local_get_interface)
+                               GetInterfaceFunc local_get_interface,
+                               SyncMessageStatusReceiver* sync_status)
     : Dispatcher(remote_process_handle, local_get_interface),
+      sync_status_(sync_status),
       pp_module_(module),
       ppb_proxy_(NULL),
       allow_plugin_reentrancy_(false) {
   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,
     const IPC::ChannelHandle& channel_handle,
     bool is_client,
     const ppapi::Preferences& preferences) {
   if (!Dispatcher::InitWithChannel(delegate, 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 40 matching lines @@
   if (msg->is_sync()) {
     // 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);
-    return Dispatcher::Send(msg);
+
+    sync_status_->BeginBlockOnSyncMessage();
+    bool result = Dispatcher::Send(msg);
+    sync_status_->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);
   }
 }
 
 bool HostDispatcher::OnMessageReceived(const IPC::Message& msg) {
@@ skipping 78 matching lines @@
   dispatcher_ = static_cast<HostDispatcher*>(dispatcher);
   dispatcher_->ppb_proxy()->AddRefModule(dispatcher_->pp_module());
 }
 
 ScopedModuleReference::~ScopedModuleReference() {
   dispatcher_->ppb_proxy()->ReleaseModule(dispatcher_->pp_module());
 }
 
 }  // namespace proxy
 }  // namespace ppapi