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

webkit/plugins/ppapi/plugin_delegate.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_DELEGATE_H_
 #define WEBKIT_PLUGINS_PPAPI_PLUGIN_DELEGATE_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 93 matching lines @@
 class P2PTransport;
 class NetworkListObserver;
 }  // namespace webkit_glue
 
 namespace webkit {
 
 namespace ppapi {
 
 class FileIO;
 class FullscreenContainer;
-class PluginInstance;
+class PluginInstanceImpl;
 class PluginModule;
 class PPB_Broker_Impl;
 class PPB_Flash_Menu_Impl;
 class PPB_ImageData_Impl;
 class PPB_TCPSocket_Private_Impl;
 
 // Virtual interface that the browser implements to implement features for
 // PPAPI plugins.
 class PluginDelegate {
  public:
@@ skipping 71 matching lines @@
   class WEBKIT_PLUGINS_EXPORT PlatformGraphics2D {
    public:
     virtual ~PlatformGraphics2D() {}
 
     virtual bool ReadImageData(PP_Resource image, const PP_Point* top_left) = 0;
 
     // Assciates this device with the given plugin instance. You can pass NULL
     // to clear the existing device. Returns true on success. In this case, a
     // repaint of the page will also be scheduled. Failure means that the device
     // is already bound to a different instance, and nothing will happen.
-    virtual bool BindToInstance(PluginInstance* new_instance) = 0;
+    virtual bool BindToInstance(PluginInstanceImpl* new_instance) = 0;
 
     // Paints the current backing store to the web page.
     virtual void Paint(WebKit::WebCanvas* canvas,
                        const gfx::Rect& plugin_rect,
                        const gfx::Rect& paint_rect) = 0;
 
     // Notifications about the view's progress painting.  See PluginInstance.
     // These messages are used to send Flush callbacks to the plugin.
     virtual void ViewWillInitiatePaint() = 0;
     virtual void ViewInitiatedPaint() = 0;
@@ skipping 137 matching lines @@
     // When there are no more references, this renderer's dispatcher is
     // destroyed, allowing the broker to shutdown if appropriate.
     // Callers should not reference this object after calling Disconnect().
     virtual void Disconnect(webkit::ppapi::PPB_Broker_Impl* client) = 0;
 
    protected:
     virtual ~Broker() {}
   };
 
   // Notification that the given plugin is focused or unfocused.
-  virtual void PluginFocusChanged(webkit::ppapi::PluginInstance* instance,
+  virtual void PluginFocusChanged(webkit::ppapi::PluginInstanceImpl* instance,
                                   bool focused) = 0;
   // Notification that the text input status of the given plugin is changed.
   virtual void PluginTextInputTypeChanged(
-      webkit::ppapi::PluginInstance* instance) = 0;
+      webkit::ppapi::PluginInstanceImpl* instance) = 0;
   // Notification that the caret position in the given plugin is changed.
   virtual void PluginCaretPositionChanged(
-      webkit::ppapi::PluginInstance* instance) = 0;
+      webkit::ppapi::PluginInstanceImpl* instance) = 0;
   // Notification that the plugin requested to cancel the current composition.
   virtual void PluginRequestedCancelComposition(
-      webkit::ppapi::PluginInstance* instance) = 0;
+      webkit::ppapi::PluginInstanceImpl* instance) = 0;
   // Notification that the text selection in the given plugin is changed.
   virtual void PluginSelectionChanged(
-      webkit::ppapi::PluginInstance* instance) = 0;
+      webkit::ppapi::PluginInstanceImpl* instance) = 0;
   // Requests simulating IME events for testing purpose.
   virtual void SimulateImeSetComposition(
       const base::string16& text,
       const std::vector<WebKit::WebCompositionUnderline>& underlines,
       int selection_start,
       int selection_end) = 0;
   virtual void SimulateImeConfirmComposition(const base::string16& text) = 0;
 
   // Notification that the given plugin has crashed. When a plugin crashes, all
   // instances associated with that plugin will notify that they've crashed via
   // this function.
-  virtual void PluginCrashed(PluginInstance* instance) = 0;
+  virtual void PluginCrashed(PluginInstanceImpl* instance) = 0;
 
   // Indicates that the given instance has been created.
-  virtual void InstanceCreated(PluginInstance* instance) = 0;
+  virtual void InstanceCreated(PluginInstanceImpl* instance) = 0;
 
   // Indicates that the given instance is being destroyed. This is called from
   // the destructor, so it's important that the instance is not dereferenced
   // from this call.
-  virtual void InstanceDeleted(PluginInstance* instance) = 0;
+  virtual void InstanceDeleted(PluginInstanceImpl* instance) = 0;
 
   // Creates the resource creation API for the given instance.
   virtual scoped_ptr< ::ppapi::thunk::ResourceCreationAPI>
-      CreateResourceCreationAPI(PluginInstance* instance) = 0;
+      CreateResourceCreationAPI(PluginInstanceImpl* instance) = 0;
 
   // Returns a pointer (ownership not transferred) to the bitmap to paint the
   // sad plugin screen with. Returns NULL on failure.
   virtual SkBitmap* GetSadPluginBitmap() = 0;
 
   // Creates a replacement plug-in that is shown when the plug-in at |file_path|
   // couldn't be loaded.
   virtual WebKit::WebPlugin* CreatePluginReplacement(
       const base::FilePath& file_path) = 0;
 
   // The caller will own the pointer returned from this.
   virtual PlatformImage2D* CreateImage2D(int width, int height) = 0;
 
   // Returns the internal PlatformGraphics2D implementation.
-  virtual PlatformGraphics2D* GetGraphics2D(PluginInstance* instance,
+  virtual PlatformGraphics2D* GetGraphics2D(PluginInstanceImpl* instance,
                                             PP_Resource graphics_2d) = 0;
 
   // The caller will own the pointer returned from this.
   virtual PlatformContext3D* CreateContext3D() = 0;
 
   // If |device_id| is empty, the default video capture device will be used. The
   // user can start using the returned object to capture video right away.
   // Otherwise, the specified device will be used. The user needs to wait till
   // |handler| gets an OnInitialized() notification to start using the returned
   // object.
@@ skipping 175 matching lines @@
       webkit_glue::NetworkListObserver* observer) = 0;
 
   // For PPB_X509Certificate_Private.
   virtual bool X509CertificateParseDER(
       const std::vector<char>& der,
       ::ppapi::PPB_X509Certificate_Fields* fields) = 0;
 
   // Create a fullscreen container for a plugin instance. This effectively
   // switches the plugin to fullscreen.
   virtual FullscreenContainer* CreateFullscreenContainer(
-      PluginInstance* instance) = 0;
+      PluginInstanceImpl* instance) = 0;
 
   // Gets the size of the screen. The fullscreen window will be created at that
   // size.
   virtual gfx::Size GetScreenSize() = 0;
 
   // Returns a string with the name of the default 8-bit char encoding.
   virtual std::string GetDefaultEncoding() = 0;
 
   // Sets the minimum and maximum zoom factors.
   virtual void ZoomLimitsChanged(double minimum_factor,
                                  double maximum_factor) = 0;
 
   // Create an anonymous shared memory segment of size |size| bytes, and return
   // a pointer to it, or NULL on error.  Caller owns the returned pointer.
   virtual base::SharedMemory* CreateAnonymousSharedMemory(size_t size) = 0;
 
   // Returns the current preferences.
   virtual ::ppapi::Preferences GetPreferences() = 0;
 
   // Locks the mouse for |instance|. If false is returned, the lock is not
   // possible. If true is returned then the lock is pending. Success or
   // failure will be delivered asynchronously via
   // PluginInstance::OnLockMouseACK().
-  virtual bool LockMouse(PluginInstance* instance) = 0;
+  virtual bool LockMouse(PluginInstanceImpl* instance) = 0;
 
   // Unlocks the mouse if |instance| currently owns the mouse lock. Whenever an
   // plugin instance has lost the mouse lock, it will be notified by
   // PluginInstance::OnMouseLockLost(). Please note that UnlockMouse() is not
   // the only cause of losing mouse lock. For example, a user may press the Esc
   // key to quit the mouse lock mode, which also results in an OnMouseLockLost()
   // call to the current mouse lock owner.
-  virtual void UnlockMouse(PluginInstance* instance) = 0;
+  virtual void UnlockMouse(PluginInstanceImpl* instance) = 0;
 
   // Returns true iff |instance| currently owns the mouse lock.
-  virtual bool IsMouseLocked(PluginInstance* instance) = 0;
+  virtual bool IsMouseLocked(PluginInstanceImpl* instance) = 0;
 
   // Notifies that |instance| has changed the cursor.
   // This will update the cursor appearance if it is currently over the plugin
   // instance.
-  virtual void DidChangeCursor(PluginInstance* instance,
+  virtual void DidChangeCursor(PluginInstanceImpl* instance,
                                const WebKit::WebCursorInfo& cursor) = 0;
 
   // Notifies that |instance| has received a mouse event.
-  virtual void DidReceiveMouseEvent(PluginInstance* instance) = 0;
+  virtual void DidReceiveMouseEvent(PluginInstanceImpl* instance) = 0;
 
   // Determines if the browser entered fullscreen mode.
   virtual bool IsInFullscreenMode() = 0;
 
   // Retrieve current gamepad data.
   virtual void SampleGamepads(WebKit::WebGamepads* data) = 0;
 
   // Returns true if the containing page is visible.
   virtual bool IsPageVisible() const = 0;
 
@@ skipping 18 matching lines @@
       bool should_close_source) const = 0;
 
   // Returns true if running in process.
   virtual bool IsRunningInProcess(PP_Instance instance) const = 0;
 
   // Notifies the plugin of the document load. This should initiate the call to
   // PPP_Instance.HandleDocumentLoad.
   //
   // The loader object should set itself on the PluginInstance as the document
   // loader using set_document_loader.
-  virtual void HandleDocumentLoad(PluginInstance* instance,
+  virtual void HandleDocumentLoad(PluginInstanceImpl* instance,
                                   const WebKit::WebURLResponse& response) = 0;
 
   // Sets up the renderer host and out-of-process proxy for an external plugin
   // module. Returns the renderer host, or NULL if it couldn't be created.
   virtual content::RendererPpapiHost* CreateExternalPluginModule(
       scoped_refptr<PluginModule> module,
       const base::FilePath& path,
       ::ppapi::PpapiPermissions permissions,
       const IPC::ChannelHandle& channel_handle,
       base::ProcessId plugin_pid,
       int plugin_child_id) = 0;
 };
 
 }  // namespace ppapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_PPAPI_PLUGIN_DELEGATE_H_