Revert 50667 - Add in support for internal pepper plugins into the PepperPlug...

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 13 matching lines @@
 #include "third_party/ppapi/c/pp_module.h"
 #include "third_party/ppapi/c/pp_resource.h"
 #include "third_party/ppapi/c/pp_var.h"
 #include "webkit/glue/plugins/pepper_buffer.h"
 #include "webkit/glue/plugins/pepper_device_context_2d.h"
 #include "webkit/glue/plugins/pepper_image_data.h"
 #include "webkit/glue/plugins/pepper_plugin_instance.h"
 #include "webkit/glue/plugins/pepper_resource_tracker.h"
 #include "webkit/glue/plugins/pepper_var.h"
 
+typedef bool (*PPP_InitializeModuleFunc)(PP_Module, PPB_GetInterface);
+typedef void (*PPP_ShutdownModuleFunc)();
+
 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 104 matching lines @@
   // in production code.
   if (strcmp(name, PPB_TESTING_INTERFACE) == 0) {
     if (CommandLine::ForCurrentProcess()->HasSwitch("enable-pepper-testing"))
       return &testing_interface;
   }
   return NULL;
 }
 
 }  // namespace
 
-PluginModule::PluginModule()
-    : initialized_(false),
-      library_(NULL) {
+PluginModule::PluginModule(const FilePath& filename)
+    : filename_(filename),
+      initialized_(false),
+      library_(0),
+      ppp_get_interface_(NULL) {
   GetMainThreadMessageLoop();  // Initialize the main thread message loop.
   GetLivePluginSet()->insert(this);
 }
 
 PluginModule::~PluginModule() {
   // When the module is being deleted, there should be no more instances still
   // holding a reference to us.
   DCHECK(instances_.empty());
 
   GetLivePluginSet()->erase(this);
 
-  if (entry_points_.shutdown_module)
-    entry_points_.shutdown_module();
-
-  if (library_)
+  if (library_) {
+    PPP_ShutdownModuleFunc shutdown_module =
+        reinterpret_cast<PPP_ShutdownModuleFunc>(
+            base::GetFunctionPointerFromNativeLibrary(library_,
+                                                      "PPP_ShutdownModule"));
+    if (shutdown_module)
+      shutdown_module();
     base::UnloadNativeLibrary(library_);
+  }
 }
 
 // static
 scoped_refptr<PluginModule> PluginModule::CreateModule(
-    const FilePath& path) {
+    const FilePath& filename) {
   // 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;
-}
-
-scoped_refptr<PluginModule> PluginModule::CreateInternalModule(
-    EntryPoints entry_points) {
-  scoped_refptr<PluginModule> lib(new PluginModule());
-  if (!lib->InitFromEntryPoints(entry_points))
-    return NULL;
-
+  scoped_refptr<PluginModule> lib(new PluginModule(filename));
+  if (!lib->Load())
+    lib = NULL;
   return lib;
 }
 
 // static
 PluginModule* PluginModule::FromPPModule(PP_Module module) {
   PluginModule* lib = reinterpret_cast<PluginModule*>(module);
   if (GetLivePluginSet()->find(lib) == GetLivePluginSet()->end())
     return NULL;  // Invalid plugin.
   return lib;
 }
 
-bool PluginModule::InitFromEntryPoints(const EntryPoints& entry_points) {
+bool PluginModule::Load() {
   if (initialized_)
     return true;
+  initialized_ = true;
 
-  // Attempt to run the initialization funciton.
-  int retval = entry_points.initialize_module(GetPPModule(), &GetInterface);
+  library_ = base::LoadNativeLibrary(filename_);
+  if (!library_)
+    return false;
+
+  // Save the GetInterface function pointer for later.
+  ppp_get_interface_ =
+      reinterpret_cast<PPP_GetInterfaceFunc>(
+          base::GetFunctionPointerFromNativeLibrary(library_,
+                                                    "PPP_GetInterface"));
+  if (!ppp_get_interface_) {
+    LOG(WARNING) << "No PPP_GetInterface in plugin library";
+    return false;
+  }
+
+  // Call the plugin initialize function.
+  PPP_InitializeModuleFunc initialize_module =
+      reinterpret_cast<PPP_InitializeModuleFunc>(
+          base::GetFunctionPointerFromNativeLibrary(library_,
+                                                    "PPP_InitializeModule"));
+  if (!initialize_module) {
+    LOG(WARNING) << "No PPP_InitializeModule in plugin library";
+    return false;
+  }
+  int retval = initialize_module(GetPPModule(), &GetInterface);
   if (retval != 0) {
     LOG(WARNING) << "PPP_InitializeModule returned failure " << retval;
     return false;
   }
 
-  entry_points_ = entry_points;
-  initialized_ = true;
   return true;
 }
 
-bool PluginModule::InitFromFile(const FilePath& path) {
-  if (initialized_)
-    return true;
-
-  base::NativeLibrary library = base::LoadNativeLibrary(path);
-  if (!library)
-    return false;
-
-  EntryPoints entry_points;
-  if (!LoadEntryPoints(library, &entry_points) ||
-      !InitFromEntryPoints(entry_points)) {
-    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;
-}
-
-// 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 =
-      reinterpret_cast<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<PPP_ShutdownModuleFunc>(
-          base::GetFunctionPointerFromNativeLibrary(library,
-                                                    "PPP_ShutdownModule"));
-
-  return true;
-}
-
 PP_Module PluginModule::GetPPModule() const {
   return reinterpret_cast<intptr_t>(this);
 }
 
 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* 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 (!entry_points_.get_interface)
+  if (!ppp_get_interface_)
     return NULL;
-  return entry_points_.get_interface(name);
+  return ppp_get_interface_(name);
 }
 
 void PluginModule::InstanceCreated(PluginInstance* instance) {
   instances_.insert(instance);
 }
 
 void PluginModule::InstanceDeleted(PluginInstance* instance) {
   instances_.erase(instance);
 }
 
 }  // namespace pepper