Move the NPAPI files from webkit/glue/plugins to webkit/plugins/npapi and put...

webkit/plugins/npapi/webplugin_delegate_impl.h

 // Copyright (c) 2010 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_PLUGINS_WEBPLUGIN_DELEGATE_IMPL_H_
-#define WEBKIT_GLUE_PLUGINS_WEBPLUGIN_DELEGATE_IMPL_H_
-
-#include "build/build_config.h"
+#ifndef WEBKIT_PLUGINS_NPAPI_WEBPLUGIN_DELEGATE_IMPL_H_
+#define WEBKIT_PLUGINS_NPAPI_WEBPLUGIN_DELEGATE_IMPL_H_
 
 #include <string>
 #include <list>
 
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/timer.h"
+#include "build/build_config.h"
 #include "gfx/native_widget_types.h"
 #include "gfx/rect.h"
 #include "third_party/npapi/bindings/npapi.h"
-#include "webkit/glue/plugins/webplugin_delegate.h"
+#include "webkit/plugins/npapi/webplugin_delegate.h"
 #include "webkit/glue/webcursor.h"
 
 #if defined(USE_X11)
 #include "app/x11_util.h"
 
 typedef struct _GdkDrawable GdkPixmap;
 #endif
 
 class FilePath;
 
-namespace NPAPI {
-class PluginInstance;
-}
-
 namespace WebKit {
 class WebMouseEvent;
 }
 
 #if defined(OS_MACOSX)
 class ExternalDragTracker;
 #ifndef NP_NO_QUICKDRAW
 class QuickDrawDrawingManager;
 #endif
 #ifdef __OBJC__
 @class CALayer;
 @class CARenderer;
 #else
 class CALayer;
 class CARenderer;
 #endif
-namespace webkit_glue {
+#endif
+
+namespace webkit {
+namespace npapi {
+
+class PluginInstance;
+
+#if defined(OS_MACOSX)
 class WebPluginAcceleratedSurface;
-}
 #endif
 
 // An implementation of WebPluginDelegate that runs in the plugin process,
 // proxied from the renderer by WebPluginDelegateProxy.
-class WebPluginDelegateImpl : public webkit_glue::WebPluginDelegate {
+class WebPluginDelegateImpl : public WebPluginDelegate {
  public:
   enum PluginQuirks {
     PLUGIN_QUIRK_SETWINDOW_TWICE = 1,  // Win32
     PLUGIN_QUIRK_THROTTLE_WM_USER_PLUS_ONE = 2,  // Win32
     PLUGIN_QUIRK_DONT_CALL_WND_PROC_RECURSIVELY = 4,  // Win32
     PLUGIN_QUIRK_DONT_SET_NULL_WINDOW_HANDLE_ON_DESTROY = 8,  // Win32
     PLUGIN_QUIRK_DONT_ALLOW_MULTIPLE_INSTANCES = 16,  // Win32
     PLUGIN_QUIRK_DIE_AFTER_UNLOAD = 32,  // Win32
     PLUGIN_QUIRK_PATCH_SETCURSOR = 64,  // Win32
     PLUGIN_QUIRK_BLOCK_NONSTANDARD_GETURL_REQUESTS = 128,  // Win32
@@ skipping 17 matching lines @@
                                       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 bool Initialize(const GURL& url,
                           const std::vector<std::string>& arg_names,
                           const std::vector<std::string>& arg_values,
-                          webkit_glue::WebPlugin* plugin,
+                          WebPlugin* plugin,
                           bool load_manually);
   virtual void PluginDestroyed();
   virtual void UpdateGeometry(const gfx::Rect& window_rect,
                               const gfx::Rect& clip_rect);
   virtual void Paint(WebKit::WebCanvas* canvas, const gfx::Rect& rect);
   virtual void Print(gfx::NativeDrawingContext context);
   virtual void SetFocus(bool focused);
   virtual bool HandleInputEvent(const WebKit::WebInputEvent& event,
                                 WebKit::WebCursorInfo* cursor_info);
   virtual NPObject* GetPluginScriptableObject();
   virtual void DidFinishLoadWithReason(
       const GURL& url, NPReason reason, int notify_id);
   virtual int GetProcessId();
   virtual void SendJavaScriptStream(const GURL& url,
                                     const std::string& result,
                                     bool success,
                                     int notify_id);
   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 void InstallMissingPlugin();
-  virtual webkit_glue::WebPluginResourceClient* CreateResourceClient(
+  virtual WebPluginResourceClient* CreateResourceClient(
       unsigned long resource_id, const GURL& url, int notify_id);
-  virtual webkit_glue::WebPluginResourceClient* CreateSeekableResourceClient(
+  virtual WebPluginResourceClient* CreateSeekableResourceClient(
       unsigned long resource_id, int range_request_id);
   // End of WebPluginDelegate implementation.
 
   bool IsWindowless() const { return windowless_ ; }
   gfx::Rect GetRect() const { return window_rect_; }
   gfx::Rect GetClipRect() const { return clip_rect_; }
 
   // Returns the path for the library implementing this plugin.
   FilePath GetPluginPath();
 
@@ skipping 50 matching lines @@
 #endif
 
 #if defined(USE_X11)
   void SetWindowlessShmPixmap(XID shm_pixmap) {
     windowless_shm_pixmap_ = shm_pixmap;
   }
 #endif
 
  private:
   friend class DeleteTask<WebPluginDelegateImpl>;
-  friend class webkit_glue::WebPluginDelegate;
+  friend class WebPluginDelegate;
 
   WebPluginDelegateImpl(gfx::PluginWindowHandle containing_view,
-                        NPAPI::PluginInstance *instance);
+                        PluginInstance *instance);
   ~WebPluginDelegateImpl();
 
   // Called by Initialize() for platform-specific initialization.
   // If this returns false, the plugin shouldn't be started--see Initialize().
   bool PlatformInitialize();
 
   // Called by DestroyInstance(), used for platform-specific destruction.
   void PlatformDestroyInstance();
 
   //--------------------------
@@ skipping 55 matching lines @@
   bool PlatformSetPluginHasFocus(bool focused);
 
   //-----------------------------------------
   // used for windowed and windowless plugins
 
   // Does platform-specific event handling. Arguments and return are identical
   // to HandleInputEvent.
   bool PlatformHandleInputEvent(const WebKit::WebInputEvent& event,
                                 WebKit::WebCursorInfo* cursor_info);
 
-  NPAPI::PluginInstance* instance() { return instance_.get(); }
+  PluginInstance* instance() { return instance_.get(); }
 
   // Closes down and destroys our plugin instance.
   void DestroyInstance();
 
 
   // used for windowed plugins
   // Note: on Mac OS X, the only time the windowed handle is non-zero
   // is the case of accelerated rendering, which uses a fake window handle to
   // identify itself back to the browser. It still performs all of its
   // work offscreen.
   gfx::PluginWindowHandle windowed_handle_;
   gfx::Rect windowed_last_pos_;
 
   bool windowed_did_set_window_;
 
   // used by windowed and windowless plugins
   bool windowless_;
 
-  webkit_glue::WebPlugin* plugin_;
-  scoped_refptr<NPAPI::PluginInstance> instance_;
+  WebPlugin* plugin_;
+  scoped_refptr<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;
 
   // The current keyboard layout of this process and the main thread ID of the
@@ skipping 115 matching lines @@
 #ifndef NP_NO_CARBON
   NP_CGContext np_cg_context_;
 #endif
 #ifndef NP_NO_QUICKDRAW
   NP_Port qd_port_;
   scoped_ptr<QuickDrawDrawingManager> qd_manager_;
   base::TimeTicks fast_path_enable_tick_;
 #endif
 
   CALayer* layer_;  // Used for CA drawing mode. Weak, retained by plug-in.
-  webkit_glue::WebPluginAcceleratedSurface* surface_;  // Weak ref.
+  WebPluginAcceleratedSurface* surface_;  // Weak ref.
   CARenderer* renderer_;  // Renders layer_ to surface_.
   scoped_ptr<base::RepeatingTimer<WebPluginDelegateImpl> > redraw_timer_;
 
   // The upper-left corner of the web content area in screen coordinates,
   // relative to an upper-left (0,0).
   gfx::Point content_area_origin_;
 
   bool containing_window_has_focus_;
   bool initial_window_focus_;
   bool container_is_visible_;
@@ skipping 58 matching lines @@
   // where SetContentAreaHasFocus is never called. See
   // https://bugs.webkit.org/show_bug.cgi?id=46013 for details.
   bool containing_view_has_focus_;
 
   // True if NPP_New did not return an error.
   bool creation_succeeded_;
 
   DISALLOW_COPY_AND_ASSIGN(WebPluginDelegateImpl);
 };
 
-#endif  // WEBKIT_GLUE_PLUGINS_WEBPLUGIN_DELEGATE_IMPL_H_
+}  // namespace npapi
+}  // namespace webkit
+
+#endif  // WEBKIT_PLUGINS_NPAPI_WEBPLUGIN_DELEGATE_IMPL_H_