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

ppapi/proxy/plugin_dispatcher.cc

 // Copyright (c) 2011 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/plugin_dispatcher.h"
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 111 matching lines @@
       return true;
     }
     proxy = info->create_proxy(this, NULL);
     target_proxies_[info->id].reset(proxy);
   }
 
   return proxy->OnMessageReceived(msg);
 }
 
 void PluginDispatcher::OnChannelError() {
+  Dispatcher::OnChannelError();
+
   // The renderer has crashed. This channel and all instances associated with
   // it are no longer valid.
   ForceFreeAllInstances();
   // TODO(brettw) free resources too!
   delete this;
 }
 
 void PluginDispatcher::DidCreateInstance(PP_Instance instance) {
   if (!g_instance_to_dispatcher)
     g_instance_to_dispatcher = new InstanceToDispatcherMap;
@@ skipping 19 matching lines @@
   }
 }
 
 InstanceData* PluginDispatcher::GetInstanceData(PP_Instance instance) {
   InstanceDataMap::iterator it = instance_map_.find(instance);
   return (it == instance_map_.end()) ? NULL : &it->second;
 }
 
 #if defined(OS_POSIX)
 int PluginDispatcher::GetRendererFD() {
-  if (renderer_fd_ == -1)
+  if (renderer_fd_ == -1 && channel())
     renderer_fd_ = channel()->GetClientFileDescriptor();
   return renderer_fd_;
 }
 
 void PluginDispatcher::CloseRendererFD() {
   if (renderer_fd_ != -1) {
     if (HANDLE_EINTR(close(renderer_fd_)) < 0)
       PLOG(ERROR) << "close";
     renderer_fd_ = -1;
   }
 }
 #endif
 
 void PluginDispatcher::ForceFreeAllInstances() {
-  // TODO(brettw) implement freeing instances on crash.
+  if (!g_instance_to_dispatcher)
+    return;
+
+  // Iterating will remove each item from the map, so we need to make a copy
+  // to avoid things changing out from under is.
+  InstanceToDispatcherMap temp_map = *g_instance_to_dispatcher;
+  for (InstanceToDispatcherMap::iterator i = temp_map.begin();
+       i != temp_map.end(); ++i) {
+    if (i->second == this) {
+      // Synthesize an "instance destroyed" message, this will notify the
+      // plugin and also remove it from our list of tracked plugins.
+      OnMessageReceived(
+          PpapiMsg_PPPInstance_DidDestroy(INTERFACE_ID_PPP_INSTANCE, i->first));
+    }
+  }
 }
 
 void PluginDispatcher::OnMsgSupportsInterface(
     const std::string& interface_name,
     bool* result) {
   *result = false;
 
   // Setup a proxy for receiving the messages from this interface.
   const InterfaceProxy::Info* info = GetPPPInterfaceInfo(interface_name);
   if (!info)
@@ skipping 10 matching lines @@
   if (!interface_functions)
     return;
   target_proxies_[info->id].reset(
       info->create_proxy(this, interface_functions));
   *result = true;
 }
 
 }  // namespace proxy
 }  // namespace pp