Add the page url to plugin crashes to aid debugging.

chrome/renderer/webplugin_delegate_proxy.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/renderer/webplugin_delegate_proxy.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <atlbase.h>
 #endif
 
 #include "app/gfx/canvas.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/logging.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "base/gfx/size.h"
 #include "base/gfx/native_widget_types.h"
 #include "chrome/app/chrome_dll_resource.h"
+#include "chrome/common/child_process_logging.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/plugin/npobject_proxy.h"
 #include "chrome/plugin/npobject_stub.h"
 #include "chrome/plugin/npobject_util.h"
 #include "chrome/renderer/render_thread.h"
 #include "chrome/renderer/render_view.h"
-#include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "net/base/mime_util.h"
 #include "printing/native_metafile.h"
 #include "webkit/api/public/WebDragData.h"
 #include "webkit/api/public/WebString.h"
 #include "webkit/api/public/WebVector.h"
 #include "webkit/glue/webframe.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webplugin.h"
 #include "webkit/glue/webview.h"
@@ skipping 123 matching lines @@
                                                RenderView* render_view)
     : render_view_(render_view),
       plugin_(NULL),
       windowless_(false),
       mime_type_(mime_type),
       clsid_(clsid),
       npobject_(NULL),
       window_script_object_(NULL),
       sad_plugin_(NULL),
       invalidate_pending_(false),
-      transparent_(false) {
+      transparent_(false),
+      page_url_(render_view_->webview()->GetMainFrame()->GetURL()) {
 }
 
 WebPluginDelegateProxy::~WebPluginDelegateProxy() {
 }
 
 void WebPluginDelegateProxy::PluginDestroyed() {
   plugin_ = NULL;
 
   if (npobject_) {
     // When we destroy the plugin instance, the NPObjectStub NULLs out its
@@ skipping 54 matching lines @@
   plugin_path_ = plugin_path;
   channel_host_ = channel_host;
   instance_id_ = instance_id;
 
   channel_host_->AddRoute(instance_id_, this, false);
 
   // Now tell the PluginInstance in the plugin process to initialize.
   PluginMsg_Init_Params params;
   params.containing_window = render_view_->host_window();
   params.url = url;
+  params.page_url = page_url_;
   for (int i = 0; i < argc; ++i) {
     params.arg_names.push_back(argn[i]);
     params.arg_values.push_back(argv[i]);
 
     if (LowerCaseEqualsASCII(params.arg_names.back(), "wmode") &&
         LowerCaseEqualsASCII(params.arg_values.back(), "transparent")) {
       transparent_ = true;
     }
   }
   params.load_manually = load_manually;
@@ skipping 64 matching lines @@
 
 FilePath WebPluginDelegateProxy::GetPluginPath() {
   return plugin_path_;
 }
 
 void WebPluginDelegateProxy::InstallMissingPlugin() {
   Send(new PluginMsg_InstallMissingPlugin(instance_id_));
 }
 
 void WebPluginDelegateProxy::OnMessageReceived(const IPC::Message& msg) {
+  child_process_logging::ScopedActiveURLSetter url_setter(page_url_);
+
   IPC_BEGIN_MESSAGE_MAP(WebPluginDelegateProxy, msg)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindow, OnSetWindow)
 #if defined(OS_LINUX)
     IPC_MESSAGE_HANDLER(PluginHostMsg_CreatePluginContainer,
                         OnCreatePluginContainer)
     IPC_MESSAGE_HANDLER(PluginHostMsg_DestroyPluginContainer,
                         OnDestroyPluginContainer)
 #endif
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindowlessPumpEvent,
@@ skipping 259 matching lines @@
 
   int route_id = MSG_ROUTING_NONE;
   intptr_t npobject_ptr;
   Send(new PluginMsg_GetPluginScriptableObject(
       instance_id_, &route_id, &npobject_ptr));
   if (route_id == MSG_ROUTING_NONE)
     return NULL;
 
   npobject_ = NPObjectProxy::Create(
       channel_host_.get(), route_id, npobject_ptr,
-      render_view_->modal_dialog_event());
+      render_view_->modal_dialog_event(), page_url_);
 
   return NPN_RetainObject(npobject_);
 }
 
 void WebPluginDelegateProxy::DidFinishLoadWithReason(NPReason reason) {
   Send(new PluginMsg_DidFinishLoadWithReason(instance_id_, reason));
 }
 
 void WebPluginDelegateProxy::SetFocus() {
   Send(new PluginMsg_SetFocus(instance_id_));
@@ skipping 69 matching lines @@
   if (plugin_)
     npobject = plugin_->GetWindowScriptNPObject();
 
   if (!npobject)
     return;
 
   // The stub will delete itself when the proxy tells it that it's released, or
   // otherwise when the channel is closed.
   NPObjectStub* stub = new NPObjectStub(
       npobject, channel_host_.get(), route_id,
-      render_view_->modal_dialog_event());
+      render_view_->modal_dialog_event(), page_url_);
   window_script_object_ = stub;
   window_script_object_->set_proxy(this);
   *success = true;
   *npobject_ptr = reinterpret_cast<intptr_t>(npobject);
 }
 
 void WebPluginDelegateProxy::OnGetPluginElement(
     int route_id, bool* success, intptr_t* npobject_ptr) {
   *success = false;
   NPObject* npobject = NULL;
   if (plugin_)
     npobject = plugin_->GetPluginElement();
   if (!npobject)
     return;
 
   // The stub will delete itself when the proxy tells it that it's released, or
   // otherwise when the channel is closed.
   new NPObjectStub(
       npobject, channel_host_.get(), route_id,
-      render_view_->modal_dialog_event());
+      render_view_->modal_dialog_event(), page_url_);
   *success = true;
   *npobject_ptr = reinterpret_cast<intptr_t>(npobject);
 }
 
 void WebPluginDelegateProxy::OnSetCookie(const GURL& url,
                                          const GURL& first_party_for_cookies,
                                          const std::string& cookie) {
   if (plugin_)
     plugin_->SetCookie(url, first_party_for_cookies, cookie);
 }
@@ skipping 70 matching lines @@
   if (!drag_id || !webkit_glue::GetDragData(event, &event_id, &data))
     return;
 
   NPVariant results[4];
   INT32_TO_NPVARIANT(drag_id, results[0]);
   INT32_TO_NPVARIANT(event_id, results[1]);
   EncodeDragData(data, add_data, &results[2], &results[3]);
 
   for (size_t i = 0; i < arraysize(results); ++i) {
     values->push_back(NPVariant_Param());
-    CreateNPVariantParam(results[i], NULL, &values->back(), false, NULL);
+    CreateNPVariantParam(
+        results[i], NULL, &values->back(), false, NULL, page_url_);
   }
 
   *success = true;
 }
 
 void WebPluginDelegateProxy::OnSetDropEffect(const NPVariant_Param& object,
                                              int effect,
                                              bool* success) {
   DCHECK(success);
   *success = false;
@@ skipping 110 matching lines @@
   plugin_->CancelDocumentLoad();
 }
 
 void WebPluginDelegateProxy::OnInitiateHTTPRangeRequest(
     const std::string& url, const std::string& range_info,
     intptr_t existing_stream, bool notify_needed, intptr_t notify_data) {
   plugin_->InitiateHTTPRangeRequest(url.c_str(), range_info.c_str(),
                                     existing_stream, notify_needed,
                                     notify_data);
 }