Instrument pepper plugin load failures.

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 99 matching lines @@
            << "~PpapiPluginProcessHost()";
   CancelRequests();
 }
 
 // static
 PpapiPluginProcessHost* PpapiPluginProcessHost::CreatePluginHost(
     const PepperPluginInfo& info,
     const base::FilePath& profile_data_directory) {
   PpapiPluginProcessHost* plugin_host = new PpapiPluginProcessHost(
       info, profile_data_directory);
+  CHECK(plugin_host);

[piman, 2013/12/09 22:39:06]

nit: DCHECK

[Scott Hess - ex-Googler, 2013/12/09 23:47:45]

Wouldn't NULL be obvious from the crash reports anyhow?

[ilja, 2013/12/10 05:55:31]

Done.

[ilja, 2013/12/10 05:55:31]

It has virtuals, so it should crash when accessing it in the next line. I guess
it isn't really needed, but I am keeping it a DCHECK just in case.

   if (plugin_host->Init(info))
     return plugin_host;
 
   NOTREACHED();  // Init is not expected to fail.
   return NULL;
 }
 
 // static
 PpapiPluginProcessHost* PpapiPluginProcessHost::CreateBrokerHost(
     const PepperPluginInfo& info) {
@@ skipping 116 matching lines @@
 
 bool PpapiPluginProcessHost::Init(const PepperPluginInfo& info) {
   plugin_path_ = info.path;
   if (info.name.empty()) {
     process_->SetName(plugin_path_.BaseName().LossyDisplayName());
   } else {
     process_->SetName(UTF8ToUTF16(info.name));
   }
 
   std::string channel_id = process_->GetHost()->CreateChannel();
-  if (channel_id.empty())
+  if (channel_id.empty()) {
+    LOG(ERROR) << "Could not create pepper host channel.";
     return false;
+  }
 
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   CommandLine::StringType plugin_launcher =
       browser_command_line.GetSwitchValueNative(switches::kPpapiPluginLauncher);
 
 #if defined(OS_LINUX)
   int flags = plugin_launcher.empty() ? ChildProcessHost::CHILD_ALLOW_SELF :
                                         ChildProcessHost::CHILD_NORMAL;
 #else
   int flags = ChildProcessHost::CHILD_NORMAL;
 #endif
   base::FilePath exe_path = ChildProcessHost::GetChildPath(flags);
-  if (exe_path.empty())
+  if (exe_path.empty()) {
+    LOG(ERROR) << "Pepper plugin exe path is empty.";
     return false;
+  }
 
   CommandLine* cmd_line = new CommandLine(exe_path);
   cmd_line->AppendSwitchASCII(switches::kProcessType,
                               is_broker_ ? switches::kPpapiBrokerProcess
                                          : switches::kPpapiPluginProcess);
   cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id);
 
   // These switches are forwarded to both plugin and broker pocesses.
   static const char* kCommonForwardSwitches[] = {
     switches::kVModule
@@ skipping 72 matching lines @@
   } else {
     client->OnPpapiChannelOpened(IPC::ChannelHandle(), base::kNullProcessId, 0);
   }
 }
 
 void PpapiPluginProcessHost::OnProcessLaunched() {
   host_impl_->set_plugin_process_handle(process_->GetHandle());
 }
 
 void PpapiPluginProcessHost::OnProcessCrashed(int exit_code) {
+  LOG(WARNING) << "ppapi plugin process crashed.";
   PluginServiceImpl::GetInstance()->RegisterPluginCrash(plugin_path_);
 }
 
 bool PpapiPluginProcessHost::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PpapiPluginProcessHost, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_ChannelCreated,
                         OnRendererPluginChannelCreated)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 10 matching lines @@
 
   // Process all pending channel requests from the renderers.
   for (size_t i = 0; i < pending_requests_.size(); i++)
     RequestPluginChannel(pending_requests_[i]);
   pending_requests_.clear();
 }
 
 // Called when the browser <--> plugin channel has an error. This normally
 // means the plugin has crashed.
 void PpapiPluginProcessHost::OnChannelError() {
+  LOG(WARNING) << "ppapi plugin channel error.";
   DVLOG(1) << "PpapiPluginProcessHost" << (is_broker_ ? "[broker]" : "")
            << "::OnChannelError()";
   // We don't need to notify the renderers that were communicating with the
   // plugin since they have their own channels which will go into the error
   // 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() {
@@ skipping 22 matching lines @@
   // sent_requests_ queue should be the one that the plugin just created.
   Client* client = sent_requests_.front();
   sent_requests_.pop();
 
   const ChildProcessData& data = process_->GetData();
   client->OnPpapiChannelOpened(channel_handle, base::GetProcId(data.handle),
                                data.id);
 }
 
 }  // namespace content