Add a hang monitor for Pepper plugins

content/browser/ppapi_plugin_process_host.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 "content/browser/ppapi_plugin_process_host.h"
 
 #include <string>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
@@ skipping 93 matching lines @@
   }
 
   // We already have an open channel, send a request right away to plugin.
   RequestPluginChannel(client);
 }
 
 PpapiPluginProcessHost::PpapiPluginProcessHost(net::HostResolver* host_resolver)
     : filter_(new PepperMessageFilter(PepperMessageFilter::PLUGIN,
                                       host_resolver)),
       network_observer_(new PluginNetworkObserver(this)),
-      is_broker_(false),
-      process_id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()) {
+      is_broker_(false) {
   process_.reset(new BrowserChildProcessHostImpl(
       content::PROCESS_TYPE_PPAPI_PLUGIN, this));
   process_->GetHost()->AddFilter(filter_.get());
 }
 
 PpapiPluginProcessHost::PpapiPluginProcessHost()
-    : is_broker_(true),
-      process_id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()) {
+    : is_broker_(true) {
   process_.reset(new BrowserChildProcessHostImpl(
       content::PROCESS_TYPE_PPAPI_BROKER, this));
 }
 
 bool PpapiPluginProcessHost::Init(const content::PepperPluginInfo& info) {
   plugin_path_ = info.path;
   if (info.name.empty()) {
     process_->SetName(plugin_path_.BaseName().LossyDisplayName());
   } else {
     process_->SetName(UTF8ToUTF16(info.name));
@@ skipping 66 matching lines @@
 void PpapiPluginProcessHost::RequestPluginChannel(Client* client) {
   base::ProcessHandle process_handle;
   int renderer_id;
   client->GetChannelInfo(&process_handle, &renderer_id);
 
   // We can't send any sync messages from the browser because it might lead to
   // a hang. See the similar code in PluginProcessHost for more description.
   PpapiMsg_CreateChannel* msg = new PpapiMsg_CreateChannel(process_handle,
                                                            renderer_id);
   msg->set_unblock(true);
-  if (Send(msg))
+  if (Send(msg)) {
     sent_requests_.push(client);
-  else
-    client->OnChannelOpened(base::kNullProcessHandle, IPC::ChannelHandle());
+  } else {
+    client->OnChannelOpened(base::kNullProcessHandle, IPC::ChannelHandle(),
+                            process_->GetData().id);

[yzshen1, 2012/04/11 18:30:46]

Should it be 0?

+  }
 }
 
 void PpapiPluginProcessHost::OnProcessLaunched() {
 }
 
 bool PpapiPluginProcessHost::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PpapiPluginProcessHost, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_ChannelCreated,
                         OnRendererPluginChannelCreated)
@@ skipping 26 matching lines @@
   // state at the same time. Instead, we just need to notify any renderers
   // that have requested a connection but have not yet received one.
   CancelRequests();
 }
 
 void PpapiPluginProcessHost::CancelRequests() {
   DVLOG(1) << "PpapiPluginProcessHost" << (is_broker_ ? "[broker]" : "")
            << "CancelRequests()";
   for (size_t i = 0; i < pending_requests_.size(); i++) {
     pending_requests_[i]->OnChannelOpened(base::kNullProcessHandle,
-                                          IPC::ChannelHandle());
+                                          IPC::ChannelHandle(), 0);
   }
   pending_requests_.clear();
 
   while (!sent_requests_.empty()) {
     sent_requests_.front()->OnChannelOpened(base::kNullProcessHandle,
-                                            IPC::ChannelHandle());
+                                            IPC::ChannelHandle(), 0);
     sent_requests_.pop();
   }
 }
 
 // Called when a new plugin <--> renderer channel has been created.
 void PpapiPluginProcessHost::OnRendererPluginChannelCreated(
     const IPC::ChannelHandle& channel_handle) {
   if (sent_requests_.empty())
     return;
 
@@ skipping 11 matching lines @@
 
   base::ProcessHandle renderers_plugin_handle = NULL;
   ::DuplicateHandle(::GetCurrentProcess(), plugin_process,
                     renderer_process, &renderers_plugin_handle,
                     0, FALSE, DUPLICATE_SAME_ACCESS);
 #elif defined(OS_POSIX)
   // Don't need to duplicate anything on POSIX since it's just a PID.
   base::ProcessHandle renderers_plugin_handle = plugin_process;
 #endif
 
-  client->OnChannelOpened(renderers_plugin_handle, channel_handle);
+  client->OnChannelOpened(renderers_plugin_handle, channel_handle,
+                          process_->GetData().id);
 }