Distinguish plugin disconnections from plugin crashes.

content/renderer/pepper/pepper_plugin_delegate_impl.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/renderer/pepper/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <cstddef>
 #include <map>
 #include <queue>
@@ skipping 132 matching lines @@
       dispatcher_.reset();
       dispatcher_delegate_.reset();
       return false;
     }
     dispatcher_->channel()->SetRestrictDispatchChannelGroup(
         kRendererRestrictDispatchGroup_Pepper);
     return true;
   }
 
   // OutOfProcessProxy implementation.
-  virtual const void* GetProxiedInterface(const char* name) {
+  virtual const void* GetProxiedInterface(const char* name) OVERRIDE {
     return dispatcher_->GetProxiedInterface(name);
   }
-  virtual void AddInstance(PP_Instance instance) {
+  virtual void AddInstance(PP_Instance instance) OVERRIDE {
     ppapi::proxy::HostDispatcher::SetForInstance(instance, dispatcher_.get());
 
     RendererPpapiHostImpl* host =
         RendererPpapiHostImpl::GetForPPInstance(instance);
     // TODO(brettw) remove this null check when the old-style pepper-based
     // browser tag is removed from this file. Getting this notification should
     // always give us an instance we can find in the map otherwise, but that
     // isn't true for browser tag support.
     if (host) {
       RenderView* render_view = host->GetRenderViewForInstance(instance);
       webkit::ppapi::PluginInstance* plugin_instance =
           host->GetPluginInstance(instance);
       render_view->Send(new ViewHostMsg_DidCreateOutOfProcessPepperInstance(
           plugin_child_id_,
           instance,
           PepperRendererInstanceData(
               0,  // The render process id will be supplied in the browser.
               render_view->GetRoutingID(),
               plugin_instance->container()->element().document().url(),
               plugin_instance->plugin_url()),
           is_external_));
     }
   }
-  virtual void RemoveInstance(PP_Instance instance) {
+  virtual void RemoveInstance(PP_Instance instance) OVERRIDE {
     ppapi::proxy::HostDispatcher::RemoveForInstance(instance);
 
     RendererPpapiHostImpl* host =
         RendererPpapiHostImpl::GetForPPInstance(instance);
     // TODO(brettw) remove null check as described in AddInstance.
     if (host) {
       RenderView* render_view = host->GetRenderViewForInstance(instance);
       render_view->Send(new ViewHostMsg_DidDeleteOutOfProcessPepperInstance(
           plugin_child_id_,
           instance,
           is_external_));
     }
   }
+  virtual base::ProcessId GetPeerProcessId() OVERRIDE {
+    return peer_pid_;
+  }
 
   ppapi::proxy::HostDispatcher* dispatcher() { return dispatcher_.get(); }
 
  private:
   webkit::ppapi::PluginModule* module_;
 
   base::ProcessId peer_pid_;
 
   // ID that the browser process uses to idetify the child process for the
   // plugin. This isn't directly useful from our process (the renderer) except
@@ skipping 549 matching lines @@
     return false;
   return focused_plugin_->IsPluginAcceptingCompositionEvents();
 }
 
 bool PepperPluginDelegateImpl::CanComposeInline() const {
   return IsPluginAcceptingCompositionEvents();
 }
 
 void PepperPluginDelegateImpl::PluginCrashed(
     webkit::ppapi::PluginInstance* instance) {
-  render_view_->PluginCrashed(instance->module()->path());
+  render_view_->PluginCrashed(instance->module()->path(),
+                              instance->module()->GetPeerProcessId());
   UnSetAndDeleteLockTargetAdapter(instance);
 }
 
 void PepperPluginDelegateImpl::InstanceCreated(
     webkit::ppapi::PluginInstance* instance) {
   active_instances_.insert(instance);
 
   // Set the initial focus.
   instance->SetContentAreaFocus(render_view_->has_focus());
 }
@@ skipping 955 matching lines @@
     RenderWidgetFullscreenPepper* container =
         static_cast<RenderWidgetFullscreenPepper*>(
             instance->fullscreen_container());
     return container->mouse_lock_dispatcher();
   } else {
     return render_view_->mouse_lock_dispatcher();
   }
 }
 
 }  // namespace content