Implement basic crash detection and shutdown handling for out of process PPAP...

ppapi/proxy/host_dispatcher.cc

 // Copyright (c) 2010 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 "ppapi/proxy/host_dispatcher.h"
 
 #include <map>
 
 #include "base/logging.h"
+#include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/proxy/host_var_serialization_rules.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
 typedef std::map<PP_Instance, HostDispatcher*> InstanceToDispatcherMap;
 InstanceToDispatcherMap* g_instance_to_dispatcher = NULL;
 
 }  // namespace
 
 HostDispatcher::HostDispatcher(base::ProcessHandle remote_process_handle,
                                PP_Module module,
                                GetInterfaceFunc local_get_interface)
-    : Dispatcher(remote_process_handle, local_get_interface) {
-  set_pp_module(module);
+    : Dispatcher(remote_process_handle, local_get_interface),
+      pp_module_(module),
+      ppb_proxy_(NULL) {
   const PPB_Var_Deprecated* var_interface =
       static_cast<const PPB_Var_Deprecated*>(
           local_get_interface(PPB_VAR_DEPRECATED_INTERFACE));
   SetSerializationRules(new HostVarSerializationRules(var_interface, module));
 
   memset(plugin_interface_support_, 0,
          sizeof(PluginInterfaceSupport) * INTERFACE_ID_COUNT);
 }
 
 HostDispatcher::~HostDispatcher() {
@@ skipping 63 matching lines @@
     }
 
     proxy = info->create_proxy(this, local_interface);
     target_proxies_[info->id].reset(proxy);
   }
 
   return proxy->OnMessageReceived(msg);
 }
 
 void HostDispatcher::OnChannelError() {
-  // TODO(brettw) plugin has crashed, handle this.
+  Dispatcher::OnChannelError();  // Stop using the channel.
+
+  // Tell the host about the crash so it can clean up.
+  GetPPBProxy()->PluginCrashed(pp_module());
 }
 
 const void* HostDispatcher::GetProxiedInterface(const std::string& interface) {
   // First see if we even have a proxy for this interface.
   const InterfaceProxy::Info* info = GetPPPInterfaceInfo(interface);
   if (!info)
     return NULL;
 
   if (plugin_interface_support_[static_cast<int>(info->id)] !=
       INTERFACE_UNQUERIED) {
     // Already queried the plugin if it supports this interface.
     if (plugin_interface_support_[info->id] == INTERFACE_SUPPORTED)
       return info->interface;
     return NULL;
   }
 
   // Need to re-query. Cache the result so we only do this once.
   bool supported = false;
   Send(new PpapiMsg_SupportsInterface(interface, &supported));
   plugin_interface_support_[static_cast<int>(info->id)] =
       supported ? INTERFACE_SUPPORTED : INTERFACE_UNSUPPORTED;
 
   if (supported)
     return info->interface;
   return NULL;
 }
 
+const PPB_Proxy_Private* HostDispatcher::GetPPBProxy() {
+  if (!ppb_proxy_) {
+    ppb_proxy_ = reinterpret_cast<const PPB_Proxy_Private*>(
+        GetLocalInterface(PPB_PROXY_PRIVATE_INTERFACE));
+  }
+  return ppb_proxy_;
+}
+
 }  // namespace proxy
 }  // namespace pp