Share PPAPI out-of-process plugins between renderer processes....

ppapi/proxy/plugin_dispatcher.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/plugin_var_serialization_rules.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppp_class_proxy.h"
 
+#if defined(OS_POSIX)
+#include "base/eintr_wrapper.h"
+#include "ipc/ipc_channel_posix.h"
+#endif
+
 namespace pp {
 namespace proxy {
 
 namespace {
 
 typedef std::map<PP_Instance, PluginDispatcher*> InstanceToDispatcherMap;
 InstanceToDispatcherMap* g_instance_to_dispatcher = NULL;
 
-const void* GetInterfaceFromDispatcher(const char* interface) {
-  // All interfaces the plugin requests of the browser are "PPB".
-  const InterfaceProxy::Info* info = Dispatcher::GetPPBInterfaceInfo(interface);
-  if (!info)
-    return NULL;
-  return info->interface;
-}
-
 }  // namespace
 
 PluginDispatcher::PluginDispatcher(base::ProcessHandle remote_process_handle,
-                                   GetInterfaceFunc get_interface,
-                                   InitModuleFunc init_module,
-                                   ShutdownModuleFunc shutdown_module)
-    : Dispatcher(remote_process_handle, get_interface),
-      init_module_(init_module),
-      shutdown_module_(shutdown_module) {
+                                   GetInterfaceFunc get_interface)
+    : Dispatcher(remote_process_handle, get_interface)
+#if defined(OS_POSIX)
+    , renderer_fd_(-1)
+#endif
+    {
   SetSerializationRules(new PluginVarSerializationRules);
 
   // As a plugin, we always support the PPP_Class interface. There's no
   // GetInterface call or name for it, so we insert it into our table now.
   target_proxies_[INTERFACE_ID_PPP_CLASS].reset(new PPP_Class_Proxy(this));
 }
 
 PluginDispatcher::~PluginDispatcher() {
-  if (shutdown_module_)
-    shutdown_module_();
+#if defined(OS_POSIX)
+  CloseRendererFD();
+#endif
 }
 
 // static
 PluginDispatcher* PluginDispatcher::GetForInstance(PP_Instance instance) {
   if (!g_instance_to_dispatcher)
     return NULL;
   InstanceToDispatcherMap::iterator found = g_instance_to_dispatcher->find(
       instance);
   if (found == g_instance_to_dispatcher->end())
     return NULL;
   return found->second;
 }
 
+// static
+const void* PluginDispatcher::GetInterfaceFromDispatcher(
+    const char* interface) {
+  // All interfaces the plugin requests of the browser are "PPB".
+  const InterfaceProxy::Info* info = GetPPBInterfaceInfo(interface);
+  if (!info)
+    return NULL;
+  return info->interface;
+}
+
 bool PluginDispatcher::IsPlugin() const {
   return true;
 }
 
 bool PluginDispatcher::OnMessageReceived(const IPC::Message& msg) {
   // Handle common control messages.
   if (Dispatcher::OnMessageReceived(msg))
     return true;
 
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     // Handle some plugin-specific control messages.
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(PluginDispatcher, msg)
       IPC_MESSAGE_HANDLER(PpapiMsg_SupportsInterface, OnMsgSupportsInterface)
-      IPC_MESSAGE_HANDLER(PpapiMsg_InitializeModule, OnMsgInitializeModule)
-      IPC_MESSAGE_HANDLER(PpapiMsg_Shutdown, OnMsgShutdown)
     IPC_END_MESSAGE_MAP()
     return handled;
   }
 
   if (msg.routing_id() <= 0 && msg.routing_id() >= INTERFACE_ID_COUNT) {
     // Host is sending us garbage. Since it's supposed to be trusted, this
     // isn't supposed to happen. Crash here in all builds in case the renderer
     // is compromised.
     CHECK(false);
     return true;
@@ skipping 22 matching lines @@
       NOTREACHED();
       return true;
     }
     proxy = info->create_proxy(this, NULL);
     target_proxies_[info->id].reset(proxy);
   }
 
   return proxy->OnMessageReceived(msg);
 }
 
+void PluginDispatcher::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;
   (*g_instance_to_dispatcher)[instance] = this;
 
   instance_map_[instance] = InstanceData();
 }
 
 void PluginDispatcher::DidDestroyInstance(PP_Instance instance) {
   InstanceDataMap::iterator it = instance_map_.find(instance);
@@ skipping 10 matching lines @@
       NOTREACHED();
     }
   }
 }
 
 InstanceData* PluginDispatcher::GetInstanceData(PP_Instance instance) {
   InstanceDataMap::iterator it = instance_map_.find(instance);
   return (it == instance_map_.end()) ? NULL : &it->second;
 }
 
-void PluginDispatcher::OnMsgInitializeModule(PP_Module pp_module,
-                                             bool* result) {
-  set_pp_module(pp_module);
-  *result = init_module_(pp_module, &GetInterfaceFromDispatcher) == PP_OK;
+#if defined(OS_POSIX)
+int PluginDispatcher::GetRendererFD() {
+  if (renderer_fd_ == -1)
+    renderer_fd_ = channel()->GetClientFileDescriptor();
+  return renderer_fd_;
 }
 
-void PluginDispatcher::OnMsgShutdown() {
-  if (shutdown_module_)
-    shutdown_module_();
-  MessageLoop::current()->Quit();
+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.
 }
 
 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