plugins: move NativeLibrary into base.

webkit/glue/plugins/plugin_lib.cc

 // Copyright (c) 2006-2008 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 "config.h"
 
 #include "webkit/glue/plugins/plugin_lib.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/plugins/plugin_instance.h"
 #include "webkit/glue/plugins/plugin_host.h"
 #include "webkit/glue/plugins/plugin_list.h"
 
+// A macro for converting string constants into appropriate
+// NativeLibraryFunctionNameTypes.
+#if defined(OS_MACOSX)
+#define NATIVE_LIBRARY_FUNCTION_NAME(x) CFSTR(x)
+#else
+#define NATIVE_LIBRARY_FUNCTION_NAME(x) x
+#endif  // OS_*
+
 namespace NPAPI
 {
 
 const char kPluginLibrariesLoadedCounter[] = "PluginLibrariesLoaded";
 const char kPluginInstancesActiveCounter[] = "PluginInstancesActive";
 
 // A list of all the instantiated plugins.
 static std::vector<scoped_refptr<PluginLib> >* g_loaded_libs;
 
 PluginLib* PluginLib::CreatePluginLib(const FilePath& filename) {
@@ skipping 119 matching lines @@
     }
     if (g_loaded_libs->empty()) {
       delete g_loaded_libs;
       g_loaded_libs = NULL;
     }
   }
 }
 
 bool PluginLib::Load() {
   bool rv = false;
-  NativeLibrary library = 0;
+  base::NativeLibrary library = 0;
 
   if (!internal_) {
     if (library_ != 0)
       return rv;
 
-    library = LoadNativeLibrary(web_plugin_info_.path);
+    library = base::LoadNativeLibrary(web_plugin_info_.path);
     if (library == 0)
       return rv;
 
     rv = true;  // assume success now
 
     entry_points_.np_initialize =
-        (NP_InitializeFunc)GetFunctionPointerFromNativeLibrary(library,
-            FUNCTION_NAME("NP_Initialize"));
+        (NP_InitializeFunc)base::GetFunctionPointerFromNativeLibrary(library,
+            NATIVE_LIBRARY_FUNCTION_NAME("NP_Initialize"));
     if (entry_points_.np_initialize == 0)
       rv = false;
 
 #if !defined(OS_LINUX)
     entry_points_.np_getentrypoints =
-        (NP_GetEntryPointsFunc)GetFunctionPointerFromNativeLibrary(library,
-            FUNCTION_NAME("NP_GetEntryPoints"));
+        (NP_GetEntryPointsFunc)base::GetFunctionPointerFromNativeLibrary(
+            library,
+            NATIVE_LIBRARY_FUNCTION_NAME("NP_GetEntryPoints"));
     if (entry_points_.np_getentrypoints == 0)
       rv = false;
 #endif
 
     entry_points_.np_shutdown =
-        (NP_ShutdownFunc)GetFunctionPointerFromNativeLibrary(library,
-            FUNCTION_NAME("NP_Shutdown"));
+        (NP_ShutdownFunc)base::GetFunctionPointerFromNativeLibrary(library,
+            NATIVE_LIBRARY_FUNCTION_NAME("NP_Shutdown"));
     if (entry_points_.np_shutdown == 0)
       rv = false;
   } else {
     rv = true;
   }
 
   if (rv) {
     plugin_funcs_.size = sizeof(plugin_funcs_);
     plugin_funcs_.version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
 #if !defined(OS_LINUX)
     if (entry_points_.np_getentrypoints(&plugin_funcs_) != NPERR_NO_ERROR)
       rv = false;
 #else
     // On Linux, we get the plugin entry points during NP_Initialize.
 #endif
   }
 
   if (!internal_) {
     if (rv)
       library_ = library;
     else
-      UnloadNativeLibrary(library);
+      base::UnloadNativeLibrary(library);
   }
 
   return rv;
 }
 
 // This class implements delayed NP_Shutdown and FreeLibrary on the plugin dll.
 class FreePluginLibraryTask : public Task {
  public:
-  FreePluginLibraryTask(PluginLib::NativeLibrary library,
+  FreePluginLibraryTask(base::NativeLibrary library,
                         NP_ShutdownFunc shutdown_func)
       : library_(library),
         NP_Shutdown_(shutdown_func) {
   }
 
   ~FreePluginLibraryTask() {}
 
   void Run() {
     if (NP_Shutdown_)
       NP_Shutdown_();
 
     if (library_) {
-      PluginLib::UnloadNativeLibrary(library_);
+      base::UnloadNativeLibrary(library_);
       library_ = NULL;
     }
   }
 
  private:
-  PluginLib::NativeLibrary library_;
+  base::NativeLibrary library_;
   NP_ShutdownFunc NP_Shutdown_;
   DISALLOW_EVIL_CONSTRUCTORS(FreePluginLibraryTask);
 };
 
 void PluginLib::Unload() {
   if (!internal_ && library_) {
     // In case of single process mode, a plugin can delete itself
     // by executing a script. So delay the unloading of the library
     // so that the plugin will have a chance to unwind.
     bool defer_unload = webkit_glue::IsPluginRunningInRendererProcess();
 
 #if USE(JSC)
     // The plugin NPAPI instances may still be around. Delay the
     // NP_Shutdown and FreeLibrary calls at least till the next
     // peek message.
     defer_unload = true;
 #endif
 
     if (defer_unload) {
       FreePluginLibraryTask* free_library_task =
           new FreePluginLibraryTask(library_, entry_points_.np_shutdown);
       MessageLoop::current()->PostTask(FROM_HERE, free_library_task);
     } else {
       Shutdown();
-      UnloadNativeLibrary(library_);
+      base::UnloadNativeLibrary(library_);
     }
 
     library_ = 0;
   }
 }
 
 void PluginLib::Shutdown() {
   if (initialized_ && !internal_) {
     NP_Shutdown();
     initialized_ = false;
   }
 }
 
 }  // namespace NPAPI