Move webkit/plugins/ppapi to content/renderer/pepper.

content/renderer/pepper/plugin_module.cc

 // Copyright (c) 2012 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/plugins/ppapi/plugin_module.h"
+#include "content/renderer/pepper/plugin_module.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/time/time.h"
+#include "content/common/pepper_plugin_registry.h"
+#include "content/renderer/pepper/common.h"
+#include "content/renderer/pepper/host_globals.h"
+#include "content/renderer/pepper/ppapi_interface_factory.h"
+#include "content/renderer/pepper/ppapi_plugin_instance_impl.h"
+#include "content/renderer/pepper/ppb_gpu_blacklist_private_impl.h"
+#include "content/renderer/pepper/ppb_image_data_impl.h"
+#include "content/renderer/pepper/ppb_proxy_impl.h"
+#include "content/renderer/pepper/ppb_scrollbar_impl.h"
+#include "content/renderer/pepper/ppb_uma_private_impl.h"
+#include "content/renderer/pepper/ppb_var_deprecated_impl.h"
+#include "content/renderer/pepper/ppb_video_decoder_impl.h"
 #include "ppapi/c/dev/ppb_audio_input_dev.h"
 #include "ppapi/c/dev/ppb_buffer_dev.h"
 #include "ppapi/c/dev/ppb_char_set_dev.h"
 #include "ppapi/c/dev/ppb_crypto_dev.h"
 #include "ppapi/c/dev/ppb_cursor_control_dev.h"
 #include "ppapi/c/dev/ppb_device_ref_dev.h"
 #include "ppapi/c/dev/ppb_file_chooser_dev.h"
 #include "ppapi/c/dev/ppb_find_dev.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/c/dev/ppb_gles_chromium_texture_mapping_dev.h"
@@ skipping 87 matching lines @@
 #include "ppapi/shared_impl/callback_tracker.h"
 #include "ppapi/shared_impl/ppapi_switches.h"
 #include "ppapi/shared_impl/ppb_input_event_shared.h"
 #include "ppapi/shared_impl/ppb_opengles2_shared.h"
 #include "ppapi/shared_impl/ppb_var_shared.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_graphics_2d_api.h"
 #include "ppapi/thunk/thunk.h"
 #include "webkit/plugins/plugin_switches.h"
-#include "webkit/plugins/ppapi/common.h"
-#include "webkit/plugins/ppapi/host_globals.h"
-#include "webkit/plugins/ppapi/ppapi_interface_factory.h"
-#include "webkit/plugins/ppapi/ppapi_plugin_instance_impl.h"
-#include "webkit/plugins/ppapi/ppb_gpu_blacklist_private_impl.h"
-#include "webkit/plugins/ppapi/ppb_image_data_impl.h"
-#include "webkit/plugins/ppapi/ppb_proxy_impl.h"
-#include "webkit/plugins/ppapi/ppb_scrollbar_impl.h"
-#include "webkit/plugins/ppapi/ppb_uma_private_impl.h"
-#include "webkit/plugins/ppapi/ppb_var_deprecated_impl.h"
-#include "webkit/plugins/ppapi/ppb_video_decoder_impl.h"
 
 using ppapi::InputEventData;
 using ppapi::PpapiGlobals;
 using ppapi::TimeTicksToPPTimeTicks;
 using ppapi::TimeToPPTime;
 using ppapi::thunk::EnterResource;
 using ppapi::thunk::PPB_Graphics2D_API;
 using ppapi::thunk::PPB_InputEvent_API;
 
 namespace webkit {
@@ skipping 189 matching lines @@
 
 const void* GetInterface(const char* name) {
   // All interfaces should be used on the main thread.
   CHECK(IsMainThread());
 
   return InternalGetInterface(name);
 }
 
 // Gets the PPAPI entry points from the given library and places them into the
 // given structure. Returns true on success.
-bool LoadEntryPointsFromLibrary(const base::NativeLibrary& library,
-                                PluginModule::EntryPoints* entry_points) {
+bool LoadEntryPointsFromLibrary(
+    const base::NativeLibrary& library,
+    content::PepperPluginInfo::EntryPoints* entry_points) {
   entry_points->get_interface =
-      reinterpret_cast<PluginModule::GetInterfaceFunc>(
+      reinterpret_cast<content::PepperPluginInfo::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 =
-      reinterpret_cast<PluginModule::PPP_InitializeModuleFunc>(
+      reinterpret_cast<content::PepperPluginInfo::PPP_InitializeModuleFunc>(
           base::GetFunctionPointerFromNativeLibrary(library,
                                                     "PPP_InitializeModule"));
   if (!entry_points->initialize_module) {
     LOG(WARNING) << "No PPP_InitializeModule in plugin library";
     return false;
   }
 
   // It's okay for PPP_ShutdownModule to not be defined and shutdown_module to
   // be NULL.
   entry_points->shutdown_module =
-      reinterpret_cast<PluginModule::PPP_ShutdownModuleFunc>(
+      reinterpret_cast<content::PepperPluginInfo::PPP_ShutdownModuleFunc>(
           base::GetFunctionPointerFromNativeLibrary(library,
                                                     "PPP_ShutdownModule"));
 
   return true;
 }
 
 }  // namespace
 
-PluginModule::EntryPoints::EntryPoints()
-    : get_interface(NULL),
-      initialize_module(NULL),
-      shutdown_module(NULL) {
-}
-
 // PluginModule ----------------------------------------------------------------
 
 PluginModule::PluginModule(const std::string& name,
                            const base::FilePath& path,
-                           PluginDelegate::ModuleLifetime* lifetime_delegate,
                            const ::ppapi::PpapiPermissions& perms)
-    : lifetime_delegate_(lifetime_delegate),
-      callback_tracker_(new ::ppapi::CallbackTracker),
+    : callback_tracker_(new ::ppapi::CallbackTracker),
       is_in_destructor_(false),
       is_crashed_(false),
       broker_(NULL),
       library_(NULL),
       name_(name),
       path_(path),
       permissions_(perms),
       reserve_instance_id_(NULL) {
   // Ensure the globals object is created.
   if (!host_globals)
@@ skipping 23 matching lines @@
   callback_tracker_->AbortAll();
 
   if (entry_points_.shutdown_module)
     entry_points_.shutdown_module();
 
   if (library_)
     base::UnloadNativeLibrary(library_);
 
   // Notifications that we've been deleted should be last.
   HostGlobals::Get()->ModuleDeleted(pp_module_);
-  if (!is_crashed_ && lifetime_delegate_) {
+  if (!is_crashed_) {
     // When the plugin crashes, we immediately tell the lifetime delegate that
     // we're gone, so we don't want to tell it again.
-    lifetime_delegate_->PluginModuleDead(this);
+    content::PepperPluginRegistry::GetInstance()->PluginModuleDead(this);
   }
 
   // Don't add stuff here, the two notifications that the module object has
   // been deleted should be last. This allows, for example,
   // PPB_Proxy.IsInModuleDestructor to map PP_Module to this class during the
   // previous parts of the destructor.
 }
 
 void PluginModule::SetEmbedderState(scoped_ptr<EmbedderState> state) {
   embedder_state_ = state.Pass();
 }
 
 PluginModule::EmbedderState* PluginModule::GetEmbedderState() {
   return embedder_state_.get();
 }
 
-bool PluginModule::InitAsInternalPlugin(const EntryPoints& entry_points) {
+bool PluginModule::InitAsInternalPlugin(
+    const content::PepperPluginInfo::EntryPoints& entry_points) {
   if (InitializeModule(entry_points)) {
     entry_points_ = entry_points;
     return true;
   }
   return false;
 }
 
 bool PluginModule::InitAsLibrary(const base::FilePath& path) {
   base::NativeLibrary library = base::LoadNativeLibrary(path, NULL);
   if (!library)
     return false;
 
-  EntryPoints entry_points;
+  content::PepperPluginInfo::EntryPoints entry_points;
 
   if (!LoadEntryPointsFromLibrary(library, &entry_points) ||
       !InitializeModule(entry_points)) {
     base::UnloadNativeLibrary(library);
     return false;
   }
   entry_points_ = entry_points;
   library_ = library;
   return true;
 }
 
 void PluginModule::InitAsProxied(
     PluginDelegate::OutOfProcessProxy* out_of_process_proxy) {
   DCHECK(!out_of_process_proxy_.get());
   out_of_process_proxy_.reset(out_of_process_proxy);
 }
 
 scoped_refptr<PluginModule>
     PluginModule::CreateModuleForExternalPluginInstance() {
   // Create a new module, but don't set the lifetime delegate. This isn't a
   // plugin in the usual sense, so it isn't tracked by the browser.
   scoped_refptr<PluginModule> external_plugin_module(
       new PluginModule(name_,
                        path_,
-                       NULL,  // no lifetime_delegate
                        permissions_));
   return external_plugin_module;
 }
 
 PP_ExternalPluginResult PluginModule::InitAsProxiedExternalPlugin(
     PluginInstanceImpl* instance) {
   DCHECK(out_of_process_proxy_.get());
   // InitAsProxied (for the trusted/out-of-process case) initializes only the
   // module, and one or more instances are added later. In this case, the
   // PluginInstance was already created as in-process, so we missed the proxy
@@ skipping 20 matching lines @@
     return out_of_process_proxy_->GetPluginChildId();
   return 0;
 }
 
 // static
 const PPB_Core* PluginModule::GetCore() {
   return &core_interface;
 }
 
 // static
-PluginModule::GetInterfaceFunc PluginModule::GetLocalGetInterfaceFunc() {
+content::PepperPluginInfo::GetInterfaceFunc
+    PluginModule::GetLocalGetInterfaceFunc() {
   return &GetInterface;
 }
 
 // static
 bool PluginModule::SupportsInterface(const char* name) {
   return !!InternalGetInterface(name);
 }
 
 PluginInstanceImpl* PluginModule::CreateInstance(
     PluginDelegate* delegate,
@@ skipping 44 matching lines @@
 
 void PluginModule::PluginCrashed() {
   DCHECK(!is_crashed_);  // Should only get one notification.
   is_crashed_ = true;
 
   // Notify all instances that they crashed.
   for (PluginInstanceSet::iterator i = instances_.begin();
        i != instances_.end(); ++i)
     (*i)->InstanceCrashed();
 
-  if (lifetime_delegate_)
-    lifetime_delegate_->PluginModuleDead(this);
+  content::PepperPluginRegistry::GetInstance()->PluginModuleDead(this);
 }
 
 void PluginModule::SetReserveInstanceIDCallback(
     PP_Bool (*reserve)(PP_Module, PP_Instance)) {
   DCHECK(!reserve_instance_id_) << "Only expect one set.";
   reserve_instance_id_ = reserve;
 }
 
 bool PluginModule::ReserveInstanceID(PP_Instance instance) {
   if (reserve_instance_id_)
     return PPBoolToBool(reserve_instance_id_(pp_module_, instance));
   return true;  // Instance ID is usable.
 }
 
 void PluginModule::SetBroker(PluginDelegate::Broker* broker) {
   DCHECK(!broker_ || !broker);
   broker_ = broker;
 }
 
 PluginDelegate::Broker* PluginModule::GetBroker() {
   return broker_;
 }
 
 // static
 void PluginModule::ResetHostGlobalsForTest() {
   delete host_globals;
   host_globals = NULL;
 }
 
-bool PluginModule::InitializeModule(const EntryPoints& entry_points) {
+bool PluginModule::InitializeModule(
+    const content::PepperPluginInfo::EntryPoints& entry_points) {
   DCHECK(!out_of_process_proxy_.get()) << "Don't call for proxied modules.";
   DCHECK(entry_points.initialize_module != NULL);
   int retval = entry_points.initialize_module(pp_module(), &GetInterface);
   if (retval != 0) {
     LOG(WARNING) << "PPP_InitializeModule returned failure " << retval;
     return false;
   }
   return true;
 }
 
 }  // namespace ppapi
 }  // namespace webkit