Create a public API around webkit::ppapi::PluginInstance and use it in chrome. After this, webkit/p…

webkit/plugins/ppapi/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_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 31 matching lines @@
 }  // namespace ppapi
 
 namespace WebKit {
 class WebPluginContainer;
 }  // namespace WebKit
 
 namespace webkit {
 namespace ppapi {
 
 class PluginDelegate;
-class PluginInstance;
+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 :
     public base::RefCounted<PluginModule>,
     public base::SupportsWeakPtr<PluginModule> {
  public:
@@ skipping 11 matching lines @@
   };
 
   // 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<PluginInstance*> PluginInstanceSet;
+  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,
@@ skipping 24 matching lines @@
 
   // Creates a new module for an external plugin instance that will be using the
   // IPC proxy. We can't use the existing module, or new instances of the plugin
   // can't be created.
   scoped_refptr<PluginModule> CreateModuleForExternalPluginInstance();
 
   // Initializes the external plugin module for the out of process proxy.
   // InitAsProxied must be called before calling InitAsProxiedExternalPlugin.
   // Returns a result code indicating whether the proxy started successfully or
   // there was an error.
-  PP_ExternalPluginResult InitAsProxiedExternalPlugin(PluginInstance* instance);
+  PP_ExternalPluginResult InitAsProxiedExternalPlugin(
+      PluginInstanceImpl* instance);
 
   bool IsProxied() const;
 
   // Returns the peer process ID if the plugin is running out of process;
   // returns |base::kNullProcessId| otherwise.
   base::ProcessId GetPeerProcessId();
 
   // Returns the plugin child process ID if the plugin is running out of
   // 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
@@ skipping 15 matching lines @@
   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).
   PP_Module pp_module() const { return pp_module_; }
 
   const std::string& name() const { return name_; }
   const base::FilePath& path() const { return path_; }
   const ::ppapi::PpapiPermissions& permissions() const { return permissions_; }
 
-  PluginInstance* CreateInstance(PluginDelegate* delegate,
-                                 content::RenderView* render_view,
-                                 WebKit::WebPluginContainer* container,
-                                 const GURL& plugin_url);
+  PluginInstanceImpl* CreateInstance(PluginDelegate* delegate,
+                                     content::RenderView* render_view,
+                                     WebKit::WebPluginContainer* container,
+                                     const GURL& plugin_url);
 
   // Returns "some" plugin instance associated with this module. This is not
   // guaranteed to be any one in particular. This is normally used to execute
   // callbacks up to the browser layer that are not inherently per-instance,
   // but the delegate lives only on the plugin instance so we need one of them.
-  PluginInstance* GetSomeInstance() const;
+  PluginInstanceImpl* GetSomeInstance() const;
 
   const PluginInstanceSet& GetAllInstances() const { return instances_; }
 
   // Calls the plugin's GetInterface and returns the given interface pointer,
   // which could be NULL.
   const void* GetPluginInterface(const char* name) const;
 
   // This module is associated with a set of instances. The PluginInstance
   // object declares its association with this module in its destructor and
   // releases us in its destructor.
-  void InstanceCreated(PluginInstance* instance);
-  void InstanceDeleted(PluginInstance* instance);
+  void InstanceCreated(PluginInstanceImpl* instance);
+  void InstanceDeleted(PluginInstanceImpl* instance);
 
   scoped_refptr< ::ppapi::CallbackTracker> GetCallbackTracker();
 
   // Called when running out of process and the plugin crashed. This will
   // release relevant resources and update all affected instances.
   void PluginCrashed();
 
   bool is_in_destructor() const { return is_in_destructor_; }
   bool is_crashed() const { return is_crashed_; }
 
@@ skipping 76 matching lines @@
 
   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_