Eliminate remaining WebCore dependencies from webplugin_impl.cc...

webkit/glue/plugins/webplugin_delegate_impl.h

 // 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.
 
 #ifndef WEBKIT_GLUE_PLUGIN_WEBPLUGIN_DELEGATE_IMPL_H_
 #define WEBKIT_GLUE_PLUGIN_WEBPLUGIN_DELEGATE_IMPL_H_
 
 #include "build/build_config.h"
 
 #include <string>
@@ skipping 11 matching lines @@
 #if defined(OS_LINUX)
 typedef struct _GdkDrawable GdkPixmap;
 #endif
 
 namespace NPAPI {
 class PluginInstance;
 }
 
 // An implementation of WebPluginDelegate that proxies all calls to
 // the plugin process.
-class WebPluginDelegateImpl : public WebPluginDelegate {
+class WebPluginDelegateImpl : public webkit_glue::WebPluginDelegate {
  public:
   static bool IsPluginDelegateWindow(gfx::NativeWindow window);
   static bool GetPluginNameFromWindow(gfx::NativeWindow window,
                                       std::wstring *plugin_name);
 
   // Returns true if the window handle passed in is that of the dummy
   // activation window for windowless plugins.
   static bool IsDummyActivationWindow(gfx::NativeWindow window);
 
   // WebPluginDelegate implementation
   virtual void PluginDestroyed();
   virtual bool Initialize(const GURL& url,
                           char** argn,
                           char** argv,
                           int argc,
-                          WebPlugin* plugin,
+                          webkit_glue::WebPlugin* plugin,
                           bool load_manually);
   virtual void UpdateGeometry(const gfx::Rect& window_rect,
                               const gfx::Rect& clip_rect);
   virtual void Paint(gfx::NativeDrawingContext context, const gfx::Rect& rect);
   virtual void Print(gfx::NativeDrawingContext context);
 
   virtual void SetFocus();  // only called when windowless
   // only called when windowless
   // See NPAPI NPP_HandleEvent for more information.
   virtual bool HandleInputEvent(const WebKit::WebInputEvent& event,
@@ skipping 10 matching lines @@
   virtual void DidReceiveManualResponse(const GURL& url,
                                         const std::string& mime_type,
                                         const std::string& headers,
                                         uint32 expected_length,
                                         uint32 last_modified);
   virtual void DidReceiveManualData(const char* buffer, int length);
   virtual void DidFinishManualLoading();
   virtual void DidManualLoadFail();
   virtual FilePath GetPluginPath();
   virtual void InstallMissingPlugin();
-  virtual WebPluginResourceClient* CreateResourceClient(int resource_id,
-                                                        const GURL& url,
-                                                        bool notify_needed,
-                                                        intptr_t notify_data,
-                                                        intptr_t stream);
+  virtual webkit_glue::WebPluginResourceClient* CreateResourceClient(
+      int resource_id,
+      const GURL& url,
+      bool notify_needed,
+      intptr_t notify_data,
+      intptr_t stream);
 
   virtual bool IsWindowless() const { return windowless_ ; }
-  virtual const gfx::Rect& GetRect() const { return window_rect_; }
-  virtual const gfx::Rect& GetClipRect() const { return clip_rect_; }
+  virtual gfx::Rect GetRect() const { return window_rect_; }
+  virtual gfx::Rect GetClipRect() const { return clip_rect_; }
   virtual int GetQuirks() const { return quirks_; }
 
 #if defined(OS_MACOSX)
   // Informs the delegate that the context used for painting windowless plugins
   // has changed.
   virtual void UpdateContext(gfx::NativeDrawingContext context);
 #endif
 
  private:
   friend class DeleteTask<WebPluginDelegateImpl>;
 
   WebPluginDelegateImpl(gfx::PluginWindowHandle containing_view,
                         NPAPI::PluginInstance *instance);
   ~WebPluginDelegateImpl();
 
-  // Called by Initialize(), used for platform-specific initialization
-  // code.
-  void PlatformInitialize(WebPlugin* plugin);
+  // Called by Initialize() for platform-specific initialization.
+  void PlatformInitialize();
 
   // Called by DestroyInstance(), used for platform-specific destruction.
   void PlatformDestroyInstance();
 
 #if !defined(OS_MACOSX)
   //--------------------------
   // used for windowed plugins
   void WindowedUpdateGeometry(const gfx::Rect& window_rect,
                               const gfx::Rect& clip_rect);
   // Create the native window.
@@ skipping 62 matching lines @@
   // causes no regressions and eliminate from other platforms.
   // this is an optimization to avoid calling SetWindow to the plugin
   // when it is not necessary.  Initially, we need to call SetWindow,
   // and after that we only need to call it when the geometry changes.
   // use this flag to indicate whether we really need it or not.
   bool windowless_needs_set_window_;
 
   // used by windowed and windowless plugins
   bool windowless_;
 
-  WebPlugin* plugin_;
+  webkit_glue::WebPlugin* plugin_;
   scoped_refptr<NPAPI::PluginInstance> instance_;
 
 #if defined(OS_WIN)
   // Original wndproc before we subclassed.
   WNDPROC plugin_wnd_proc_;
 
   // Used to throttle WM_USER+1 messages in Flash.
   uint32 last_message_;
   bool is_calling_wndproc;
 #endif // OS_WIN
@@ skipping 102 matching lines @@
   void OnNullEvent();
 
   // last mouse position within the plugin's rect (used for null events)
   int last_mouse_x_;
   int last_mouse_y_;
 #endif
 
   // Holds the current cursor set by the windowless plugin.
   WebCursor current_windowless_cursor_;
 
-  friend class WebPluginDelegate;
+  friend class webkit_glue::WebPluginDelegate;
 
   DISALLOW_EVIL_CONSTRUCTORS(WebPluginDelegateImpl);
 };
 
 #endif  // #ifndef WEBKIT_GLUE_PLUGIN_WEBPLUGIN_DELEGATE_IMPL_H_