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

ppapi/proxy/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/dispatcher.h"
 
 #include <string.h>  // For memset.
 
 #include <map>
 
@@ skipping 133 matching lines @@
 
 // static
 InterfaceList* InterfaceList::GetInstance() {
   return Singleton<InterfaceList>::get();
 }
 
 }  // namespace
 
 Dispatcher::Dispatcher(base::ProcessHandle remote_process_handle,
                        GetInterfaceFunc local_get_interface)
-    : pp_module_(0),
-      remote_process_handle_(remote_process_handle),
+    : remote_process_handle_(remote_process_handle),
       test_sink_(NULL),
       disallow_trusted_interfaces_(false),  // TODO(brettw) make this settable.
       local_get_interface_(local_get_interface),
       callback_tracker_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 Dispatcher::~Dispatcher() {
 }
 
 bool Dispatcher::InitWithChannel(MessageLoop* ipc_message_loop,
@@ skipping 19 matching lines @@
     IPC_BEGIN_MESSAGE_MAP(Dispatcher, msg)
       IPC_MESSAGE_FORWARD(PpapiMsg_ExecuteCallback, &callback_tracker_,
                           CallbackTracker::ReceiveExecuteSerializedCallback)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
   }
   return false;
 }
 
+void Dispatcher::OnChannelError() {
+  channel_.reset();
+}
+
 // static
 const InterfaceProxy::Info* Dispatcher::GetPPBInterfaceInfo(
     const std::string& name) {
   const InterfaceList* list = InterfaceList::GetInstance();
   InterfaceList::NameToInfo::const_iterator found =
       list->name_to_browser_info_.find(name);
   if (found == list->name_to_browser_info_.end())
     return NULL;
   return found->second;
 }
@@ skipping 30 matching lines @@
   serialization_rules_.reset(var_serialization_rules);
 }
 
 const void* Dispatcher::GetLocalInterface(const char* interface) {
   return local_get_interface_(interface);
 }
 
 bool Dispatcher::Send(IPC::Message* msg) {
   if (test_sink_)
     return test_sink_->Send(msg);
-  return channel_->Send(msg);
+  if (channel_.get())
+    return channel_->Send(msg);
+
+  // Remote side crashed, drop this message.
+  delete msg;
+  return false;
 }
 
 }  // namespace proxy
 }  // namespace pp