Move NPAPI implementation out of webkit/plugins/npapi and into content.

content/browser/renderer_host/render_widget_host_view_base.cc

 // 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.
 
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 
 #include "base/logging.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/renderer_host/basic_mouse_wheel_smooth_scroll_gesture.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/port/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/port/browser/smooth_scroll_gesture.h"
 #include "third_party/WebKit/public/web/WebScreenInfo.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/size_f.h"
 
 #if defined(OS_WIN)
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/win/wrapped_window_proc.h"
 #include "content/browser/plugin_process_host.h"
+#include "content/common/plugin_constants_win.h"
+#include "content/common/webplugin_geometry.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/common/content_switches.h"
 #include "ui/base/win/dpi.h"
 #include "ui/base/win/hwnd_util.h"
 #include "ui/gfx/gdi_util.h"
-#include "webkit/plugins/npapi/plugin_constants_win.h"
-#include "webkit/plugins/npapi/webplugin.h"
-#include "webkit/plugins/npapi/webplugin_delegate_impl.h"
-
-using webkit::npapi::WebPluginDelegateImpl;
+#include "webkit/plugins/npapi/plugin_utils.h"
 #endif
 
 #if defined(TOOLKIT_GTK)
 #include <gdk/gdkx.h>
 #include <gtk/gtk.h>
 
 #include "content/browser/renderer_host/gtk_window_utils.h"
 #endif
 
 namespace content {
@@ skipping 67 matching lines @@
         return 0;
       default:
         break;
     }
   }
   return ::DefWindowProc(window, message, wparam, lparam);
 }
 
 bool IsPluginWrapperWindow(HWND window) {
   return ui::GetClassNameW(window) ==
-      string16(webkit::npapi::kWrapperNativeWindowClassName);
+      string16(kWrapperNativeWindowClassName);
 }
 
 // Create an intermediate window between the given HWND and its parent.
 HWND ReparentWindow(HWND window, HWND parent) {
   static ATOM atom = 0;
   static HMODULE instance = NULL;
   if (!atom) {
     WNDCLASSEX window_class;
     base::win::InitializeWindowClass(
-        webkit::npapi::kWrapperNativeWindowClassName,
+        kWrapperNativeWindowClassName,
         &base::win::WrappedWindowProc<PluginWrapperWindowProc>,
         CS_DBLCLKS,
         0,
         0,
         NULL,
         // xxx reinterpret_cast<HBRUSH>(COLOR_WINDOW+1),
         reinterpret_cast<HBRUSH>(COLOR_GRAYTEXT+1),
         NULL,
         NULL,
         NULL,
@@ skipping 15 matching lines @@
   static const int kMaxTries = 5;
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&NotifyPluginProcessHostHelper, window, new_parent,
                  kMaxTries));
   return new_parent;
 }
 
 BOOL CALLBACK PaintEnumChildProc(HWND hwnd, LPARAM lparam) {
-  if (!WebPluginDelegateImpl::IsPluginDelegateWindow(hwnd))
+  if (!webkit::npapi::IsPluginDelegateWindow(hwnd))
     return TRUE;
 
   gfx::Rect* rect = reinterpret_cast<gfx::Rect*>(lparam);
   gfx::Rect rect_in_pixels = ui::win::DIPToScreenRect(*rect);
-  static UINT msg = RegisterWindowMessage(webkit::npapi::kPaintMessageName);
+  static UINT msg = RegisterWindowMessage(kPaintMessageName);
   WPARAM wparam = rect_in_pixels.x() << 16 | rect_in_pixels.y();
   lparam = rect_in_pixels.width() << 16 | rect_in_pixels.height();
 
   // SendMessage gets the message across much quicker than PostMessage, since it
   // doesn't get queued.  When the plugin thread calls PeekMessage or other
   // Win32 APIs, sent messages are dispatched automatically.
   SendNotifyMessage(hwnd, msg, wparam, lparam);
 
   return TRUE;
 }
 
 // Windows callback for OnDestroy to detach the plugin windows.
 BOOL CALLBACK DetachPluginWindowsCallbackInternal(HWND window, LPARAM param) {
   RenderWidgetHostViewBase::DetachPluginWindowsCallback(window);
   return TRUE;
 }
 
 }  // namespace
 
 // static
 void RenderWidgetHostViewBase::DetachPluginWindowsCallback(HWND window) {
-  if (WebPluginDelegateImpl::IsPluginDelegateWindow(window) &&
+  if (webkit::npapi::IsPluginDelegateWindow(window) &&
       !IsHungAppWindow(window)) {
     ::ShowWindow(window, SW_HIDE);
     SetParent(window, NULL);
   }
 }
 
 // static
 void RenderWidgetHostViewBase::MovePluginWindowsHelper(
     HWND parent,
-    const std::vector<webkit::npapi::WebPluginGeometry>& moves) {
+    const std::vector<WebPluginGeometry>& moves) {
   if (moves.empty())
     return;
 
   bool oop_plugins =
     !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) &&
     !CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessPlugins);
 
   HDWP defer_window_pos_info =
       ::BeginDeferWindowPos(static_cast<int>(moves.size()));
 
   if (!defer_window_pos_info) {
     NOTREACHED();
     return;
   }
 
   for (size_t i = 0; i < moves.size(); ++i) {
     unsigned long flags = 0;
-    const webkit::npapi::WebPluginGeometry& move = moves[i];
+    const WebPluginGeometry& move = moves[i];
     HWND window = move.window;
 
     // As the plugin parent window which lives on the browser UI thread is
     // destroyed asynchronously, it is possible that we have a stale window
     // sent in by the renderer for moving around.
     // Note: get the parent before checking if the window is valid, to avoid a
     // race condition where the window is destroyed after the check but before
     // the GetParent call.
     HWND cur_parent = ::GetParent(window);
     if (!::IsWindow(window))
       continue;
 
-    if (!WebPluginDelegateImpl::IsPluginDelegateWindow(window)) {
+    if (!webkit::npapi::IsPluginDelegateWindow(window)) {
       // The renderer should only be trying to move plugin windows. However,
       // this may happen as a result of a race condition (i.e. even after the
       // check right above), so we ignore it.
       continue;
     }
 
     if (oop_plugins) {
-      if (cur_parent == WebPluginDelegateImpl::GetDefaultWindowParent()) {
+      if (cur_parent == webkit::npapi::GetDefaultWindowParent()) {
         // The plugin window hasn't been parented yet, add an intermediate
         // window that lives on this thread to speed up scrolling. Note this
         // only works with out of process plugins since we depend on
         // PluginProcessHost to destroy the intermediate HWNDs.
         cur_parent = ReparentWindow(window, parent);
         ::ShowWindow(window, SW_SHOW);  // Window was created hidden.
       } else if (!IsPluginWrapperWindow(cur_parent)) {
         continue;  // Race if plugin process is shutting down.
       }
 
       // We move the intermediate parent window which doesn't result in cross-
       // process synchronous Windows messages.
       window = cur_parent;
     } else {
-      if (cur_parent == WebPluginDelegateImpl::GetDefaultWindowParent())
+      if (cur_parent == webkit::npapi::GetDefaultWindowParent())
         SetParent(window, parent);
     }
 
     if (move.visible)
       flags |= SWP_SHOWWINDOW;
     else
       flags |= SWP_HIDEWINDOW;
 
 #if defined(USE_AURA)
     // Without this flag, Windows repaints the parent area uncovered by this
@@ skipping 36 matching lines @@
     if (!defer_window_pos_info) {
       DCHECK(false) << "DeferWindowPos failed, so all plugin moves ignored.";
       return;
     }
   }
 
   ::EndDeferWindowPos(defer_window_pos_info);
 
 #if defined(USE_AURA)
   for (size_t i = 0; i < moves.size(); ++i) {
-    const webkit::npapi::WebPluginGeometry& move = moves[i];
+    const WebPluginGeometry& move = moves[i];
     RECT r;
     GetWindowRect(move.window, &r);
     gfx::Rect gr(r);
     PaintEnumChildProc(move.window, reinterpret_cast<LPARAM>(&gr));
   }
 #endif
 }
 
 // static
 void RenderWidgetHostViewBase::PaintPluginWindowsHelper(
@@ skipping 196 matching lines @@
 
 uint32 RenderWidgetHostViewBase::RendererFrameNumber() {
   return renderer_frame_number_;
 }
 
 void RenderWidgetHostViewBase::DidReceiveRendererFrame() {
   ++renderer_frame_number_;
 }
 
 }  // namespace content