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

webkit/plugins/ppapi/ppapi_plugin_instance_impl.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_PPAPI_PLUGIN_INSTANCE_H_
-#define WEBKIT_PLUGINS_PPAPI_PPAPI_PLUGIN_INSTANCE_H_
+#ifndef WEBKIT_PLUGINS_PPAPI_PPAPI_PLUGIN_INSTANCE_IMPL_H_
+#define WEBKIT_PLUGINS_PPAPI_PPAPI_PLUGIN_INSTANCE_IMPL_H_
 
 #include <set>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "cc/layers/texture_layer_client.h"
 #include "ppapi/c/dev/pp_cursor_type_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_printing_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_text_input_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_instance.h"
-#include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_time.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/c/ppb_gamepad.h"
 #include "ppapi/c/ppb_input_event.h"
 #include "ppapi/c/ppp_graphics_3d.h"
 #include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_messaging.h"
 #include "ppapi/c/ppp_mouse_lock.h"
 #include "ppapi/c/private/ppb_content_decryptor_private.h"
 #include "ppapi/c/private/ppp_instance_private.h"
 #include "ppapi/shared_impl/ppb_instance_shared.h"
 #include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/shared_impl/singleton_resource_id.h"
 #include "ppapi/shared_impl/tracked_callback.h"
 #include "ppapi/thunk/ppb_gamepad_api.h"
 #include "ppapi/thunk/resource_creation_api.h"
 #include "skia/ext/refptr.h"
 #include "third_party/WebKit/public/platform/WebCanvas.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLLoaderClient.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebPlugin.h"
 #include "third_party/WebKit/public/web/WebUserGestureToken.h"
 #include "ui/base/ime/text_input_type.h"
 #include "ui/gfx/rect.h"
 #include "url/gurl.h"
 #include "webkit/plugins/ppapi/plugin_delegate.h"
+#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppp_pdf.h"
 #include "webkit/plugins/webkit_plugins_export.h"
 
 struct PP_Point;
 struct _NPP;
 
 class SkBitmap;
 class TransportDIB;
 
-namespace IPC {
-struct ChannelHandle;
-}
-
 namespace WebKit {
 class WebInputEvent;
 class WebLayer;
 class WebMouseEvent;
 class WebPluginContainer;
 class WebURLLoader;
 class WebURLResponse;
 struct WebCompositionUnderline;
 struct WebCursorInfo;
 struct WebURLError;
 struct WebPrintParams;
 }
 
 namespace cc {
 class TextureLayer;
 }
 
-namespace content {
-class RenderView;
-}
-
-namespace gfx {
-class ImageSkia;
-}
-
 namespace ppapi {
-class PpapiPermissions;
 class Resource;
-class VarTracker;
 struct InputEventData;
 struct PPP_Instance_Combined;
-struct URLRequestInfoData;
 }
 
 namespace ui {
 class Range;
 }
 
 namespace v8 {
 class Isolate;
 }
 
 namespace webkit {
 namespace ppapi {
 
 class ContentDecryptorDelegate;
 class FullscreenContainer;
 class MessageChannel;
 class PluginDelegate;
 class PluginModule;
 class PluginObject;
 class PPB_Graphics3D_Impl;
 class PPB_ImageData_Impl;
 class PPB_URLLoader_Impl;
 
 // Represents one time a plugin appears on one web page.
 //
 // Note: to get from a PP_Instance to a PluginInstance*, use the
 // ResourceTracker.
-class WEBKIT_PLUGINS_EXPORT PluginInstance :
-    public base::RefCounted<PluginInstance>,
-    public base::SupportsWeakPtr<PluginInstance>,
+class WEBKIT_PLUGINS_EXPORT PluginInstanceImpl :
+    public base::RefCounted<PluginInstanceImpl>,
+    public base::SupportsWeakPtr<PluginInstanceImpl>,
+    public NON_EXPORTED_BASE(PluginInstance),
     public ::ppapi::PPB_Instance_Shared {
  public:
-  // Create and return a PluginInstance object which supports the most recent
-  // version of PPP_Instance possible by querying the given get_plugin_interface
-  // function. If the plugin does not support any valid PPP_Instance interface,
-  // returns NULL.
-  static PluginInstance* Create(PluginDelegate* delegate,
-                                content::RenderView* render_view,
-                                PluginModule* module,
-                                WebKit::WebPluginContainer* container,
-                                const GURL& plugin_url);
+  // Create and return a PluginInstanceImpl object which supports the most
+  // recent version of PPP_Instance possible by querying the given
+  // get_plugin_interface function. If the plugin does not support any valid
+  // PPP_Instance interface, returns NULL.
+  static PluginInstanceImpl* Create(PluginDelegate* delegate,
+                                    content::RenderView* render_view,
+                                    PluginModule* module,
+                                    WebKit::WebPluginContainer* container,
+                                    const GURL& plugin_url);
   // Delete should be called by the WebPlugin before this destructor.
-  virtual ~PluginInstance();
+  virtual ~PluginInstanceImpl();
 
   PluginDelegate* delegate() const { return delegate_; }
-  content::RenderView* render_view() const {return render_view_; }
   PluginModule* module() const { return module_.get(); }
   MessageChannel& message_channel() { return *message_channel_; }
 
   WebKit::WebPluginContainer* container() const { return container_; }
 
-  void set_always_on_top(bool on_top) { always_on_top_ = on_top; }
-
   // Returns the PP_Instance uniquely identifying this instance. Guaranteed
   // nonzero.
   PP_Instance pp_instance() const { return pp_instance_; }
 
   ::ppapi::PPP_Instance_Combined* instance_interface() const {
     return instance_interface_.get();
   }
 
   ::ppapi::thunk::ResourceCreationAPI& resource_creation() {
     return *resource_creation_.get();
@@ skipping 22 matching lines @@
   void ScrollRect(int dx, int dy, const gfx::Rect& rect);
 
   // Commit the backing texture to the screen once the side effects some
   // rendering up to an offscreen SwapBuffers are visible.
   void CommitBackingTexture();
 
   // Called when the out-of-process plugin implementing this instance crashed.
   void InstanceCrashed();
 
   // PPB_Instance and PPB_Instance_Private implementation.
-  const GURL& plugin_url() const { return plugin_url_; }
   bool full_frame() const { return full_frame_; }
   const ::ppapi::ViewData& view_data() const { return view_data_; }
 
   // PPP_Instance and PPP_Instance_Private.
   bool Initialize(const std::vector<std::string>& arg_names,
                   const std::vector<std::string>& arg_values,
                   bool full_frame);
   bool HandleDocumentLoad(const WebKit::WebURLResponse& response);
   bool HandleInputEvent(const WebKit::WebInputEvent& event,
                         WebKit::WebCursorInfo* cursor_info);
@@ skipping 87 matching lines @@
   //                       flash_fullscreen_ == true
   //
   // In normal state, events come from webkit and painting goes back to it.
   // In fullscreen state, events come from the fullscreen container, and
   // painting goes back to it.
   // In pending state, events from webkit are ignored, and as soon as we
   // receive events from the fullscreen container, we go to the fullscreen
   // state.
   bool FlashIsFullscreenOrPending();
 
-  // Switches between fullscreen and normal mode. If |delay_report| is set to
-  // false, it may report the new state through DidChangeView immediately. If
-  // true, it will delay it. When called from the plugin, delay_report should
-  // be true to avoid re-entrancy.
-  void FlashSetFullscreen(bool fullscreen, bool delay_report);
-
   // Updates |flash_fullscreen_| and sends focus change notification if
   // necessary.
   void UpdateFlashFullscreenState(bool flash_fullscreen);
 
   FullscreenContainer* fullscreen_container() const {
     return fullscreen_container_;
   }
 
   // Implementation of PPB_Fullscreen.
 
@@ skipping 10 matching lines @@
 
   bool flash_fullscreen() const { return flash_fullscreen_; }
 
   // Switches between fullscreen and normal mode. The transition is
   // asynchronous. WebKit will trigger corresponding VewChanged calls.
   // Returns true on success, false on failure (e.g. trying to enter fullscreen
   // when not processing a user gesture or trying to set fullscreen when
   // already in fullscreen mode).
   bool SetFullscreen(bool fullscreen);
 
-  // Implementation of PPB_Flash.
-  int32_t Navigate(const ::ppapi::URLRequestInfoData& request,
-                   const char* target,
-                   bool from_user_action);
-  bool IsRectTopmost(const gfx::Rect& rect);
-
   // Implementation of PPP_Messaging.
   void HandleMessage(PP_Var message);
 
   PluginDelegate::PlatformContext3D* CreateContext3D();
 
-  // Returns true iff the plugin is a full-page plugin (i.e. not in an iframe
-  // or embedded in a page).
-  bool IsFullPagePlugin() const;
-
   // Returns true if the plugin is processing a user gesture.
   bool IsProcessingUserGesture();
 
   // Returns the user gesture token to use for creating a WebScopedUserGesture,
   // if IsProcessingUserGesture returned true.
   WebKit::WebUserGestureToken CurrentUserGestureToken();
 
   // A mouse lock request was pending and this reports success or failure.
   void OnLockMouseACK(bool succeeded);
   // A mouse lock was in place, but has been lost.
@@ skipping 17 matching lines @@
   // clear itself when it is destroyed.
   WebKit::WebURLLoaderClient* document_loader() const {
     return document_loader_;
   }
   void set_document_loader(WebKit::WebURLLoaderClient* loader) {
     document_loader_ = loader;
   }
 
   ContentDecryptorDelegate* GetContentDecryptorDelegate();
 
+  // webkit::ppapi::PluginInstance implementation
+  content::RenderView* GetRenderView();
+  virtual WebKit::WebPluginContainer* GetContainer();
+  virtual ::ppapi::VarTracker* GetVarTracker();
+  virtual const GURL& GetPluginURL();
+  virtual base::FilePath GetModulePath();
+  virtual PP_Resource CreateExternalFileReference(
+      const base::FilePath& external_file_path);
+  virtual PP_Resource CreateImage(gfx::ImageSkia* source_image,
+                                  float scale);
+  virtual PP_ExternalPluginResult SwitchToOutOfProcessProxy(
+      const base::FilePath& file_path,
+      ::ppapi::PpapiPermissions permissions,
+      const IPC::ChannelHandle& channel_handle,
+      base::ProcessId plugin_pid,
+      int plugin_child_id);
+  virtual void SetAlwaysOnTop(bool on_top);
+  virtual bool IsFullPagePlugin();
+  virtual void FlashSetFullscreen(bool fullscreen, bool delay_report);
+  virtual bool IsRectTopmost(const gfx::Rect& rect);
+  virtual int32_t Navigate(const ::ppapi::URLRequestInfoData& request,
+                           const char* target,
+                           bool from_user_action);
+
   // PPB_Instance_API implementation.
   virtual PP_Bool BindGraphics(PP_Instance instance,
                                PP_Resource device) OVERRIDE;
   virtual PP_Bool IsFullFrame(PP_Instance instance) OVERRIDE;
   virtual const ::ppapi::ViewData* GetViewData(PP_Instance instance) OVERRIDE;
   virtual PP_Bool FlashIsFullscreen(PP_Instance instance) OVERRIDE;
   virtual PP_Var GetWindowObject(PP_Instance instance) OVERRIDE;
   virtual PP_Var GetOwnerElementObject(PP_Instance instance) OVERRIDE;
   virtual PP_Var ExecuteScript(PP_Instance instance,
                                PP_Var script,
@@ skipping 111 matching lines @@
   bool IsValidInstanceOf(PluginModule* module);
 
   // Returns the plugin NPP identifier that this plugin will use to identify
   // itself when making NPObject scripting calls to WebBindings.
   struct _NPP* instanceNPP();
 
   // Returns the v8::Isolate that was current when this Instance was created.
   // This is not inlined so as to avoid an unnecessary header include of v8.h.
   v8::Isolate* GetIsolate() const;
 
-  static PluginInstance* Get(PP_Instance instance_id);
-
-  ::ppapi::VarTracker* GetVarTracker();
-
-  // Returns a reference to a file with the given path.
-  // The returned object will have a refcount of 0 (just like "new").
-  PP_Resource CreateExternalFileReference(
-      const base::FilePath& external_file_path);
-
-  // Creates a PPB_ImageData given a Skia image.
-  PP_Resource CreateImage(gfx::ImageSkia* source_image, float scale);
-
-  // Returns the location of this module.
-  base::FilePath GetModulePath();
-
-  // Switches this instance with one that uses the out of process IPC proxy.
-  PP_ExternalPluginResult SwitchToOutOfProcessProxy(
-      const base::FilePath& file_path,
-      ::ppapi::PpapiPermissions permissions,
-      const IPC::ChannelHandle& channel_handle,
-      base::ProcessId plugin_pid,
-      int plugin_child_id);
-
  private:
   friend class PpapiUnittest;
 
   // Class to record document load notifications and play them back once the
   // real document loader becomes available. Used only by NaCl instances.
   class NaClDocumentLoader : public WebKit::WebURLLoaderClient {
    public:
     NaClDocumentLoader();
     virtual ~NaClDocumentLoader();
 
     void ReplayReceivedData(WebURLLoaderClient* document_loader);
 
     // WebKit::WebURLLoaderClient implementation.
     virtual void didReceiveData(WebKit::WebURLLoader* loader,
                                 const char* data,
                                 int data_length,
                                 int encoded_data_length);
     virtual void didFinishLoading(WebKit::WebURLLoader* loader,
                                   double finish_time);
     virtual void didFail(WebKit::WebURLLoader* loader,
                          const WebKit::WebURLError& error);
 
    private:
     std::list<std::string> data_;
     bool finished_loading_;
     scoped_ptr<WebKit::WebURLError> error_;
   };
 
   // Implements PPB_Gamepad_API. This is just to avoid having an excessive
-  // number of interfaces implemented by PluginInstance.
+  // number of interfaces implemented by PluginInstanceImpl.
   class GamepadImpl : public ::ppapi::thunk::PPB_Gamepad_API,
                       public ::ppapi::Resource {
    public:
     explicit GamepadImpl(PluginDelegate* delegate);
     // Resource implementation.
     virtual ::ppapi::thunk::PPB_Gamepad_API* AsPPB_Gamepad_API() OVERRIDE;
     virtual void Sample(PP_Instance instance,
                         PP_GamepadsSampleData* data) OVERRIDE;
    private:
     PluginDelegate* delegate_;
   };
 
-  // See the static Create functions above for creating PluginInstance objects.
-  // This constructor is private so that we can hide the PPP_Instance_Combined
-  // details while still having 1 constructor to maintain for member
-  // initialization.
-  PluginInstance(PluginDelegate* delegate,
-                 content::RenderView* render_view,
-                 PluginModule* module,
-                 ::ppapi::PPP_Instance_Combined* instance_interface,
-                 WebKit::WebPluginContainer* container,
-                 const GURL& plugin_url);
+  // See the static Create functions above for creating PluginInstanceImpl
+  // objects. This constructor is private so that we can hide the
+  // PPP_Instance_Combined details while still having 1 constructor to maintain
+  // for member initialization.
+  PluginInstanceImpl(PluginDelegate* delegate,
+                     content::RenderView* render_view,
+                     PluginModule* module,
+                     ::ppapi::PPP_Instance_Combined* instance_interface,
+                     WebKit::WebPluginContainer* container,
+                     const GURL& plugin_url);
 
   bool LoadFindInterface();
   bool LoadInputEventInterface();
   bool LoadMessagingInterface();
   bool LoadMouseLockInterface();
   bool LoadPdfInterface();
   bool LoadPrintInterface();
   bool LoadPrivateInterface();
   bool LoadSelectionInterface();
   bool LoadTextInputInterface();
@@ skipping 105 matching lines @@
   // Indicates if we've ever sent a didChangeView to the plugin. This ensures we
   // always send an initial notification, even if the position and clip are the
   // same as the default values.
   bool sent_initial_did_change_view_;
 
   // We use a weak ptr factory for scheduling DidChangeView events so that we
   // can tell whether updates are pending and consolidate them. When there's
   // already a weak ptr pending (HasWeakPtrs is true), code should update the
   // view_data_ but not send updates. This also allows us to cancel scheduled
   // view change events.
-  base::WeakPtrFactory<PluginInstance> view_change_weak_ptr_factory_;
+  base::WeakPtrFactory<PluginInstanceImpl> view_change_weak_ptr_factory_;
 
   // The current device context for painting in 2D and 3D.
   scoped_refptr<PPB_Graphics3D_Impl> bound_graphics_3d_;
   PluginDelegate::PlatformGraphics2D* bound_graphics_2d_platform_;
 
   // We track two types of focus, one from WebKit, which is the focus among
   // all elements of the page, one one from the browser, which is whether the
   // tab/window has focus. We tell the plugin it has focus only when both of
   // these values are set to true.
   bool has_webkit_focus_;
@@ skipping 145 matching lines @@
 
   // Dummy NPP value used when calling in to WebBindings, to allow the bindings
   // to correctly track NPObjects belonging to this plugin instance.
   scoped_ptr<struct _NPP> npp_;
 
   // We store the isolate at construction so that we can be sure to use the
   // Isolate in which this Instance was created when interacting with v8.
   v8::Isolate* isolate_;
 
   friend class PpapiPluginInstanceTest;
-  DISALLOW_COPY_AND_ASSIGN(PluginInstance);
+  DISALLOW_COPY_AND_ASSIGN(PluginInstanceImpl);
 };
 
 }  // namespace ppapi
 }  // namespace webkit
 
-#endif  // WEBKIT_PLUGINS_PPAPI_PPAPI_PLUGIN_INSTANCE_H_
+#endif  // WEBKIT_PLUGINS_PPAPI_PPAPI_PLUGIN_INSTANCE_IMPL_H_