Out of process Pepper

webkit/glue/plugins/pepper_plugin_module.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 "webkit/glue/plugins/pepper_plugin_module.h"
 
 #include <set>
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 29 matching lines @@
 #include "ppapi/c/pp_module.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_graphics_2d.h"
 #include "ppapi/c/ppb_image_data.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/ppp.h"
 #include "ppapi/c/ppp_instance.h"
+#include "ppapi/proxy/host_dispatcher.h"
+#include "ppapi/proxy/ppapi_messages.h"
 #include "webkit/glue/plugins/pepper_audio.h"
 #include "webkit/glue/plugins/pepper_buffer.h"
 #include "webkit/glue/plugins/pepper_char_set.h"
 #include "webkit/glue/plugins/pepper_cursor_control.h"
 #include "webkit/glue/plugins/pepper_directory_reader.h"
 #include "webkit/glue/plugins/pepper_file_chooser.h"
 #include "webkit/glue/plugins/pepper_file_io.h"
 #include "webkit/glue/plugins/pepper_file_ref.h"
 #include "webkit/glue/plugins/pepper_file_system.h"
 #include "webkit/glue/plugins/pepper_font.h"
@@ skipping 13 matching lines @@
 #include "webkit/glue/plugins/pepper_var.h"
 #include "webkit/glue/plugins/pepper_video_decoder.h"
 #include "webkit/glue/plugins/pepper_widget.h"
 #include "webkit/glue/plugins/ppb_private.h"
 #include "webkit/glue/plugins/ppb_private2.h"
 
 #ifdef ENABLE_GPU
 #include "webkit/glue/plugins/pepper_graphics_3d.h"
 #endif  // ENABLE_GPU
 
+#if defined(OS_POSIX)
+#include "ipc/ipc_channel_posix.h"
+#endif
+
 namespace pepper {
 
 namespace {
 
 // Maintains all currently loaded plugin libs for validating PP_Module
 // identifiers.
 typedef std::set<PluginModule*> PluginModuleSet;
 
 PluginModuleSet* GetLivePluginSet() {
   static PluginModuleSet live_plugin_libs;
@@ skipping 230 matching lines @@
     const FilePath& path) {
   // FIXME(brettw) do uniquifying of the plugin here like the NPAPI one.
 
   scoped_refptr<PluginModule> lib(new PluginModule());
   if (!lib->InitFromFile(path))
     return NULL;
 
   return lib;
 }
 
+// static
 scoped_refptr<PluginModule> PluginModule::CreateInternalModule(
     EntryPoints entry_points) {
   scoped_refptr<PluginModule> lib(new PluginModule());
   if (!lib->InitFromEntryPoints(entry_points))
     return NULL;
 
   return lib;
 }
 
 // static
+scoped_refptr<PluginModule> PluginModule::CreateOutOfProcessModule(
+    MessageLoop* ipc_message_loop,
+    const IPC::ChannelHandle& handle,
+    base::WaitableEvent* shutdown_event) {
+  scoped_refptr<PluginModule> lib(new PluginModule);
+  if (!lib->InitForOutOfProcess(ipc_message_loop, handle, shutdown_event))
+    return NULL;
+  return lib;
+}
+
+// static
 const PPB_Core* PluginModule::GetCore() {
   return &core_interface;
 }
 
 bool PluginModule::InitFromEntryPoints(const EntryPoints& entry_points) {
   if (initialized_)
     return true;
 
   // Attempt to run the initialization funciton.
   int retval = entry_points.initialize_module(pp_module(), &GetInterface);
@@ skipping 21 matching lines @@
     base::UnloadNativeLibrary(library);
     return false;
   }
 
   // We let InitFromEntryPoints() handle setting the all the internal state
   // of the object other than the |library_| reference.
   library_ = library;
   return true;
 }
 
+bool PluginModule::InitForOutOfProcess(MessageLoop* ipc_message_loop,
+                                       const IPC::ChannelHandle& handle,
+                                       base::WaitableEvent* shutdown_event) {
+  const PPB_Var_Deprecated* var_interface =
+      reinterpret_cast<const PPB_Var_Deprecated*>(
+          GetInterface(PPB_VAR_DEPRECATED_INTERFACE));
+  dispatcher_.reset(new pp::proxy::HostDispatcher(var_interface,
+                                                  pp_module(), &GetInterface));
+
+#if defined(OS_POSIX)
+  // If we received a ChannelHandle, register it now.
+  if (handle.socket.fd >= 0)
+    IPC::AddChannelSocket(handle.name, handle.socket.fd);
+#endif
+
+  if (!dispatcher_->InitWithChannel(ipc_message_loop, handle.name, true,
+                                    shutdown_event)) {
+    dispatcher_.reset();
+    return false;
+  }
+
+  bool init_result = false;
+  dispatcher_->Send(new PpapiMsg_InitializeModule(pp_module(), &init_result));
+
+  if (!init_result) {
+    // TODO(brettw) does the module get unloaded in this case?
+    dispatcher_.reset();
+    return false;
+  }
+  return true;
+}
+
 // static
 bool PluginModule::LoadEntryPoints(const base::NativeLibrary& library,
                                    EntryPoints* entry_points) {
-
   entry_points->get_interface =
       reinterpret_cast<PPP_GetInterfaceFunc>(
           base::GetFunctionPointerFromNativeLibrary(library,
                                                     "PPP_GetInterface"));
   if (!entry_points->get_interface) {
     LOG(WARNING) << "No PPP_GetInterface in plugin library";
     return false;
   }
 
   entry_points->initialize_module =
@@ skipping 16 matching lines @@
 }
 
 PluginInstance* PluginModule::CreateInstance(PluginDelegate* delegate) {
   const PPP_Instance* plugin_instance_interface =
       reinterpret_cast<const PPP_Instance*>(GetPluginInterface(
           PPP_INSTANCE_INTERFACE));
   if (!plugin_instance_interface) {
     LOG(WARNING) << "Plugin doesn't support instance interface, failing.";
     return NULL;
   }
-  return new PluginInstance(delegate, this, plugin_instance_interface);
+  PluginInstance* instance = new PluginInstance(delegate, this,
+                                                plugin_instance_interface);
+  if (dispatcher_.get()) {
+    pp::proxy::HostDispatcher::SetForInstance(instance->pp_instance(),
+                                              dispatcher_.get());
+  }
+  return instance;
 }
 
 PluginInstance* PluginModule::GetSomeInstance() const {
   // This will generally crash later if there is not actually any instance to
   // return, so we force a crash now to make bugs easier to track down.
   CHECK(!instances_.empty());
   return *instances_.begin();
 }
 
 const void* PluginModule::GetPluginInterface(const char* name) const {
+  if (dispatcher_.get())
+    return dispatcher_->GetProxiedInterface(name);
+
+  // In-process plugins.
   if (!entry_points_.get_interface)
     return NULL;
   return entry_points_.get_interface(name);
 }
 
 void PluginModule::InstanceCreated(PluginInstance* instance) {
   instances_.insert(instance);
 }
 
 void PluginModule::InstanceDeleted(PluginInstance* instance) {
+  pp::proxy::HostDispatcher::RemoveForInstance(instance->pp_instance());
   instances_.erase(instance);
 }
 
 void PluginModule::AddNPObjectVar(ObjectVar* object_var) {
   DCHECK(np_object_to_object_var_.find(object_var->np_object()) ==
          np_object_to_object_var_.end()) << "ObjectVar already in map";
   np_object_to_object_var_[object_var->np_object()] = object_var;
 }
 
 void PluginModule::RemoveNPObjectVar(ObjectVar* object_var) {
@@ skipping 24 matching lines @@
   live_plugin_objects_.insert(plugin_object);
 }
 
 void PluginModule::RemovePluginObject(PluginObject* plugin_object) {
   // Don't actually verify that the object is in the set since during module
   // deletion we'll be in the process of freeing them.
   live_plugin_objects_.erase(plugin_object);
 }
 
 }  // namespace pepper