Add the page url to plugin crashes to aid debugging.

chrome/plugin/npobject_stub.cc

 // Copyright (c) 2006-2008 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 "chrome/plugin/npobject_stub.h"
 
+#include "chrome/common/child_process_logging.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/plugin/npobject_util.h"
 #include "chrome/plugin/plugin_channel_base.h"
 #include "chrome/renderer/webplugin_delegate_proxy.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
 NPObjectStub::NPObjectStub(
     NPObject* npobject,
     PluginChannelBase* channel,
     int route_id,
-    base::WaitableEvent* modal_dialog_event)
+    base::WaitableEvent* modal_dialog_event,
+    const GURL& page_url)
     : npobject_(npobject),
       channel_(channel),
       route_id_(route_id),
       valid_(true),
       web_plugin_delegate_proxy_(NULL),
-      modal_dialog_event_(modal_dialog_event) {
+      modal_dialog_event_(modal_dialog_event),
+      page_url_(page_url) {
   channel_->AddRoute(route_id, this, true);
 
   // We retain the object just as PluginHost does if everything was in-process.
   NPN_RetainObject(npobject_);
 }
 
 NPObjectStub::~NPObjectStub() {
   if (web_plugin_delegate_proxy_)
     web_plugin_delegate_proxy_->DropWindowScriptObject();
 
   channel_->RemoveRoute(route_id_);
   if (npobject_ && valid_)
     NPN_ReleaseObject(npobject_);
 }
 
 bool NPObjectStub::Send(IPC::Message* msg) {
   return channel_->Send(msg);
 }
 
 void NPObjectStub::OnMessageReceived(const IPC::Message& msg) {
+  child_process_logging::ScopedActiveURLSetter url_setter(page_url_);
+
   if (!valid_) {
     if (msg.is_sync()) {
       // The object could be garbage because the frame has gone away, so
       // just send an error reply to the caller.
       IPC::Message* reply = IPC::SyncMessage::GenerateReply(&msg);
       reply->set_reply_error();
       Send(reply);
     }
 
     return;
@@ skipping 55 matching lines @@
   bool return_value = false;
   NPVariant_Param result_param;
   NPVariant result_var;
 
   VOID_TO_NPVARIANT(result_var);
 
   int arg_count = static_cast<int>(args.size());
   NPVariant* args_var = new NPVariant[arg_count];
   for (int i = 0; i < arg_count; ++i) {
     CreateNPVariant(
-        args[i], local_channel, &(args_var[i]), modal_dialog_event_);
+        args[i], local_channel, &(args_var[i]), modal_dialog_event_,
+        page_url_);
   }
 
   if (is_default) {
     if (IsPluginProcess()) {
       if (npobject_->_class->invokeDefault) {
         return_value = npobject_->_class->invokeDefault(
             npobject_, args_var, arg_count, &result_var);
       } else {
         return_value = false;
       }
@@ skipping 15 matching lines @@
           0, npobject_, id, args_var, arg_count, &result_var);
     }
   }
 
   for (int i = 0; i < arg_count; ++i)
     NPN_ReleaseVariantValue(&(args_var[i]));
 
   delete[] args_var;
 
   CreateNPVariantParam(
-      result_var, local_channel, &result_param, true, modal_dialog_event_);
+      result_var, local_channel, &result_param, true, modal_dialog_event_,
+      page_url_);
   NPObjectMsg_Invoke::WriteReplyParams(reply_msg, result_param, return_value);
   local_channel->Send(reply_msg);
 }
 
 void NPObjectStub::OnHasProperty(const NPIdentifier_Param& name,
                                  bool* result) {
   NPIdentifier id = CreateNPIdentifier(name);
   if (IsPluginProcess()) {
     if (npobject_->_class->hasProperty) {
       *result = npobject_->_class->hasProperty(npobject_, id);
@@ skipping 16 matching lines @@
     if (npobject_->_class->getProperty) {
       *result = npobject_->_class->getProperty(npobject_, id, &result_var);
     } else {
       *result = false;
     }
   } else {
     *result = NPN_GetProperty(0, npobject_, id, &result_var);
   }
 
   CreateNPVariantParam(
-      result_var, channel_, property, true, modal_dialog_event_);
+      result_var, channel_, property, true, modal_dialog_event_, page_url_);
 }
 
 void NPObjectStub::OnSetProperty(const NPIdentifier_Param& name,
                                  const NPVariant_Param& property,
                                  bool* result) {
   NPVariant result_var;
   VOID_TO_NPVARIANT(result_var);
   NPIdentifier id = CreateNPIdentifier(name);
   NPVariant property_var;
-  CreateNPVariant(property, channel_, &property_var, modal_dialog_event_);
+  CreateNPVariant(
+      property, channel_, &property_var, modal_dialog_event_, page_url_);
 
   if (IsPluginProcess()) {
     if (npobject_->_class->setProperty) {
       *result = npobject_->_class->setProperty(npobject_, id, &property_var);
     } else {
       *result = false;
     }
   } else {
     *result = NPN_SetProperty(0, npobject_, id, &property_var);
   }
@@ skipping 60 matching lines @@
   bool return_value = false;
   NPVariant_Param result_param;
   NPVariant result_var;
 
   VOID_TO_NPVARIANT(result_var);
 
   int arg_count = static_cast<int>(args.size());
   NPVariant* args_var = new NPVariant[arg_count];
   for (int i = 0; i < arg_count; ++i) {
     CreateNPVariant(
-        args[i], local_channel, &(args_var[i]), modal_dialog_event_);
+        args[i], local_channel, &(args_var[i]), modal_dialog_event_, page_url_);
   }
 
   if (IsPluginProcess()) {
     if (npobject_->_class->construct) {
       return_value = npobject_->_class->construct(
           npobject_, args_var, arg_count, &result_var);
     } else {
       return_value = false;
     }
   } else {
     return_value = NPN_Construct(
         0, npobject_, args_var, arg_count, &result_var);
   }
 
   for (int i = 0; i < arg_count; ++i)
     NPN_ReleaseVariantValue(&(args_var[i]));
 
   delete[] args_var;
 
   CreateNPVariantParam(
-      result_var, local_channel, &result_param, true, modal_dialog_event_);
+      result_var, local_channel, &result_param, true, modal_dialog_event_,
+      page_url_);
   NPObjectMsg_Invoke::WriteReplyParams(reply_msg, result_param, return_value);
   local_channel->Send(reply_msg);
 }
 
 void NPObjectStub::OnEvaluate(const std::string& script,
                               bool popups_allowed,
                               IPC::Message* reply_msg) {
   if (IsPluginProcess()) {
     NOTREACHED() << "Should only be called on NPObjects in the renderer";
     return;
   }
 
   // Grab a reference to the underlying channel, as the NPObjectStub
   // instance can be destroyed in the context of NPN_Evaluate. This
   // can happen if the containing plugin instance is destroyed in
   // NPN_Evaluate.
   scoped_refptr<PluginChannelBase> local_channel = channel_;
 
   NPVariant result_var;
   NPString script_string;
   script_string.UTF8Characters = script.c_str();
   script_string.UTF8Length = static_cast<unsigned int>(script.length());
 
   bool return_value = NPN_EvaluateHelper(0, popups_allowed, npobject_,
                                          &script_string, &result_var);
 
   NPVariant_Param result_param;
   CreateNPVariantParam(
-      result_var, local_channel, &result_param, true, modal_dialog_event_);
+      result_var, local_channel, &result_param, true, modal_dialog_event_,
+      page_url_);
   NPObjectMsg_Evaluate::WriteReplyParams(reply_msg, result_param, return_value);
   local_channel->Send(reply_msg);
 }
 
 void NPObjectStub::OnSetException(const std::string& message) {
   if (IsPluginProcess()) {
     NOTREACHED() << "Should only be called on NPObjects in the renderer";
     return;
   }
 
   NPN_SetException(npobject_, message.c_str());
 }