Generate dumps for relevant renderers when users kill a hung pepper plugin.

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"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/proxy/host_var_serialization_rules.h"
 #include "ppapi/proxy/interface_list.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/resource_creation_proxy.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
+#include "ppapi/shared_impl/ppapi_message_tracker.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 typedef std::map<PP_Instance, HostDispatcher*> InstanceToDispatcherMap;
 InstanceToDispatcherMap* g_instance_to_dispatcher = NULL;
 
 typedef std::map<PP_Module, HostDispatcher*> ModuleToDispatcherMap;
@@ skipping 98 matching lines @@
       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) {
+  ScopedTrackPpapiMessage track_ppapi_message;
+
   TRACE_EVENT2("ppapi proxy", "HostDispatcher::Send",
                "Class", IPC_MESSAGE_ID_CLASS(msg->type()),
                "Line", IPC_MESSAGE_ID_LINE(msg->type()));
 
   // 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_)
@@ skipping 18 matching lines @@
   } 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) {
+  ScopedTrackPpapiMessage track_ppapi_message;
+
   TRACE_EVENT2("ppapi proxy", "HostDispatcher::OnMessageReceived",
                "Class", IPC_MESSAGE_ID_CLASS(msg.type()),
                "Line", IPC_MESSAGE_ID_LINE(msg.type()));
   // 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_);
@@ skipping 76 matching lines @@
   }
 }
 
 ScopedModuleReference::~ScopedModuleReference() {
   if (dispatcher_)
     dispatcher_->ppb_proxy()->ReleaseModule(dispatcher_->pp_module());
 }
 
 }  // namespace proxy
 }  // namespace ppapi