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

content/renderer/pepper/plugin_module.h

 // 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.
 
-#ifndef WEBKIT_PLUGINS_PPAPI_PLUGIN_MODULE_H_
-#define WEBKIT_PLUGINS_PPAPI_PLUGIN_MODULE_H_
+#ifndef CONTENT_RENDERER_PEPPER_PLUGIN_MODULE_H_
+#define CONTENT_RENDERER_PEPPER_PLUGIN_MODULE_H_
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/native_library.h"
 #include "base/process.h"
+#include "content/common/content_export.h"
+#include "content/public/common/pepper_plugin_info.h"
+#include "content/renderer/pepper/plugin_delegate.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_instance.h"
-#include "ppapi/c/pp_module.h"
-#include "ppapi/c/ppb.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/private/ppb_instance_private.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
-#include "webkit/plugins/ppapi/plugin_delegate.h"
-#include "webkit/plugins/webkit_plugins_export.h"
 
 typedef void* NPIdentifier;
 
 namespace base {
 class FilePath;
 }
 
 namespace content {
 class RenderView;
 }
@@ skipping 11 matching lines @@
 namespace ppapi {
 
 class PluginDelegate;
 class PluginInstanceImpl;
 
 // Represents one plugin library loaded into one renderer. This library may
 // have multiple instances.
 //
 // Note: to get from a PP_Instance to a PluginInstance*, use the
 // ResourceTracker.
-class WEBKIT_PLUGINS_EXPORT PluginModule :
+class CONTENT_EXPORT PluginModule :
     public base::RefCounted<PluginModule>,
     public base::SupportsWeakPtr<PluginModule> {
  public:
-  typedef const void* (*GetInterfaceFunc)(const char*);
-  typedef int (*PPP_InitializeModuleFunc)(PP_Module, PPB_GetInterface);
-  typedef void (*PPP_ShutdownModuleFunc)();
-
-  struct EntryPoints {
-    // This structure is POD, with the constructor initializing to NULL.
-    WEBKIT_PLUGINS_EXPORT EntryPoints();
-
-    GetInterfaceFunc get_interface;
-    PPP_InitializeModuleFunc initialize_module;
-    PPP_ShutdownModuleFunc shutdown_module;  // Optional, may be NULL.
-  };
-
   // Allows the embedder to associate a class with this module. This is opaque
   // from the PluginModule's perspective (see Set/GetEmbedderState below) but
   // the module is in charge of deleting the class.
   class EmbedderState {
    public:
     virtual ~EmbedderState() {}
   };
 
   typedef std::set<PluginInstanceImpl*> PluginInstanceSet;
 
   // You must call one of the Init functions after the constructor to create a
   // module of the type you desire.
   //
   // The module lifetime delegate is a non-owning pointer that must outlive
   // all plugin modules. In practice it will be a global singleton that
   // tracks which modules are alive.
   PluginModule(const std::string& name,
                const base::FilePath& path,
-               PluginDelegate::ModuleLifetime* lifetime_delegate,
                const ::ppapi::PpapiPermissions& perms);
 
-  ~PluginModule();
-
   // Sets the given class as being associated with this module. It will be
   // deleted when the module is destroyed. You can only set it once, subsequent
   // sets will assert.
   //
   // See EmbedderState above for more.
   void SetEmbedderState(scoped_ptr<EmbedderState> state);
   EmbedderState* GetEmbedderState();
 
   // Initializes this module as an internal plugin with the given entrypoints.
   // This is used for "plugins" compiled into Chrome. Returns true on success.
   // False means that the plugin can not be used.
-  bool InitAsInternalPlugin(const EntryPoints& entry_points);
+  bool InitAsInternalPlugin(
+      const content::PepperPluginInfo::EntryPoints& entry_points);
 
   // Initializes this module using the given library path as the plugin.
   // Returns true on success. False means that the plugin can not be used.
   bool InitAsLibrary(const base::FilePath& path);
 
   // Initializes this module for the given out of process proxy. This takes
   // ownership of the given pointer, even in the failure case.
   void InitAsProxied(PluginDelegate::OutOfProcessProxy* out_of_process_proxy);
 
   // Creates a new module for an external plugin instance that will be using the
@@ skipping 18 matching lines @@
   // process. Returns 0 otherwise. This is the ID that the browser process uses
   // to idetify the child process for the plugin. This isn't directly useful
   // from our process (the renderer) except in messages to the browser to
   // disambiguate plugins.
   int GetPluginChildId();
 
   static const PPB_Core* GetCore();
 
   // Returns a pointer to the local GetInterface function for retrieving
   // PPB interfaces.
-  static GetInterfaceFunc GetLocalGetInterfaceFunc();
+  static content::PepperPluginInfo::GetInterfaceFunc GetLocalGetInterfaceFunc();
 
   // Returns whether an interface is supported. This method can be called from
   // the browser process and used for interface matching before plugin
   // registration.
   // NOTE: those custom interfaces provided by PpapiInterfaceFactoryManager
   // will not be considered when called on the browser process.
   static bool SupportsInterface(const char* name);
 
   // Returns the module handle. This may be used before Init() is called (the
   // proxy needs this information to set itself up properly).
@@ skipping 51 matching lines @@
   void SetBroker(PluginDelegate::Broker* broker);
   PluginDelegate::Broker* GetBroker();
 
   // In production we purposely leak the HostGlobals object but in unittest
   // code, this can interfere with subsequent tests. This deletes the
   // existing HostGlobals. A new one will be constructed when a PluginModule is
   // instantiated.
   static void ResetHostGlobalsForTest();
 
  private:
+  friend class base::RefCounted<PluginModule>;
+  ~PluginModule();
   // Calls the InitializeModule entrypoint. The entrypoint must have been
   // set and the plugin must not be out of process (we don't maintain
   // entrypoints in that case).
-  bool InitializeModule(const EntryPoints& entry_points);
-
-  // Note: This may be null.
-  PluginDelegate::ModuleLifetime* lifetime_delegate_;
+  bool InitializeModule(
+      const content::PepperPluginInfo::EntryPoints& entry_points);
 
   // See EmbedderState above.
   scoped_ptr<EmbedderState> embedder_state_;
 
   // Tracker for completion callbacks, used mainly to ensure that all callbacks
   // are properly aborted on module shutdown.
   scoped_refptr< ::ppapi::CallbackTracker> callback_tracker_;
 
   PP_Module pp_module_;
 
@@ skipping 15 matching lines @@
 
   // Holds a reference to the base::NativeLibrary handle if this PluginModule
   // instance wraps functions loaded from a library.  Can be NULL.  If
   // |library_| is non-NULL, PluginModule will attempt to unload the library
   // during destruction.
   base::NativeLibrary library_;
 
   // Contains pointers to the entry points of the actual plugin implementation.
   // These will be NULL for out-of-process plugins, which is indicated by the
   // presence of the out_of_process_proxy_ value.
-  EntryPoints entry_points_;
+  content::PepperPluginInfo::EntryPoints entry_points_;
 
   // The name and file location of the module.
   const std::string name_;
   const base::FilePath path_;
 
   ::ppapi::PpapiPermissions permissions_;
 
   // Non-owning pointers to all instances associated with this module. When
   // there are no more instances, this object should be deleted.
   PluginInstanceSet instances_;
 
   PP_Bool (*reserve_instance_id_)(PP_Module, PP_Instance);
 
   DISALLOW_COPY_AND_ASSIGN(PluginModule);
 };
 
 }  // namespace ppapi
 }  // namespace webkit
 
-#endif  // WEBKIT_PLUGINS_PPAPI_PLUGIN_MODULE_H_
+#endif  // CONTENT_RENDERER_PEPPER_PLUGIN_MODULE_H_