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

content/child/npapi/webplugin_delegate_impl_win.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 "webkit/plugins/npapi/webplugin_delegate_impl.h"
+#include "content/child/npapi/webplugin_delegate_impl.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/stats_counters.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/version.h"
 #include "base/win/iat_patch_function.h"
 #include "base/win/registry.h"
 #include "base/win/windows_version.h"
+#include "content/child/npapi/plugin_instance.h"
+#include "content/child/npapi/plugin_lib.h"
+#include "content/child/npapi/plugin_stream_url.h"
+#include "content/child/npapi/webplugin.h"
+#include "content/child/npapi/webplugin_ime_win.h"
+#include "content/common/plugin_constants_win.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/base/win/dpi.h"
 #include "ui/base/win/hwnd_util.h"
 #include "webkit/common/cursors/webcursor.h"
-#include "webkit/plugins/npapi/plugin_constants_win.h"
-#include "webkit/plugins/npapi/plugin_instance.h"
-#include "webkit/plugins/npapi/plugin_lib.h"
-#include "webkit/plugins/npapi/plugin_stream_url.h"
 #include "webkit/plugins/npapi/plugin_utils.h"
-#include "webkit/plugins/npapi/webplugin.h"
-#include "webkit/plugins/npapi/webplugin_ime_win.h"
 #include "webkit/plugins/plugin_constants.h"
 
 using WebKit::WebKeyboardEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
+using webkit::WebPluginInfo;
 
-namespace webkit {
-namespace npapi {
+namespace content {
 
 namespace {
 
 const wchar_t kWebPluginDelegateProperty[] = L"WebPluginDelegateProperty";
-const wchar_t kPluginNameAtomProperty[] = L"PluginNameAtom";
-const wchar_t kPluginVersionAtomProperty[] = L"PluginVersionAtom";
-const wchar_t kDummyActivationWindowName[] = L"DummyWindowForActivation";
 const wchar_t kPluginFlashThrottle[] = L"FlashThrottle";
 
 // The fastest we are willing to process WM_USER+1 events for Flash.
 // Flash can easily exceed the limits of our CPU if we don't throttle it.
 // The throttle has been chosen by testing various delays and compromising
 // on acceptable Flash performance and reasonable CPU consumption.
 //
 // I'd like to make the throttle delay variable, based on the amount of
 // time currently required to paint Flash plugins.  There isn't a good
 // way to count the time spent in aggregate plugin painting, however, so
@@ skipping 132 matching lines @@
   Version plugin_version;
   webkit::npapi::CreateVersionFromString(plugin_info.version, &plugin_version);
 
   int major_version = 0;
   if (plugin_version.IsValid())
     major_version = plugin_version.components()[0];
 
   return major_version;
 }
 
-bool GetPluginPropertyFromWindow(
-    HWND window, const wchar_t* plugin_atom_property,
-    base::string16* plugin_property) {
-  ATOM plugin_atom = reinterpret_cast<ATOM>(
-      GetPropW(window, plugin_atom_property));
-  if (plugin_atom != 0) {
-    WCHAR plugin_property_local[MAX_PATH] = {0};
-    GlobalGetAtomNameW(plugin_atom,
-                       plugin_property_local,
-                       ARRAYSIZE(plugin_property_local));
-    *plugin_property = plugin_property_local;
-    return true;
-  }
-  return false;
-}
-
 }  // namespace
 
-bool WebPluginDelegateImpl::IsPluginDelegateWindow(HWND window) {
-  return ui::GetClassName(window) == base::string16(kNativeWindowClassName);
-}
-
-// static
-bool WebPluginDelegateImpl::GetPluginNameFromWindow(
-    HWND window, base::string16* plugin_name) {
-  return IsPluginDelegateWindow(window) &&
-      GetPluginPropertyFromWindow(
-          window, kPluginNameAtomProperty, plugin_name);
-}
-
-// static
-bool WebPluginDelegateImpl::GetPluginVersionFromWindow(
-    HWND window, base::string16* plugin_version) {
-  return IsPluginDelegateWindow(window) &&
-      GetPluginPropertyFromWindow(
-          window, kPluginVersionAtomProperty, plugin_version);
-}
-
-bool WebPluginDelegateImpl::IsDummyActivationWindow(HWND window) {
-  if (!IsWindow(window))
-    return false;
-
-  wchar_t window_title[MAX_PATH + 1] = {0};
-  if (GetWindowText(window, window_title, arraysize(window_title))) {
-    return (0 == lstrcmpiW(window_title, kDummyActivationWindowName));
-  }
-  return false;
-}
-
-HWND WebPluginDelegateImpl::GetDefaultWindowParent() {
-  return GetDesktopWindow();
-}
-
 LRESULT CALLBACK WebPluginDelegateImpl::HandleEventMessageFilterHook(
     int code, WPARAM wParam, LPARAM lParam) {
   if (g_current_plugin_instance) {
     g_current_plugin_instance->OnModalLoopEntered();
   } else {
     NOTREACHED();
   }
   return CallNextHookEx(NULL, code, wParam, lParam);
 }
 
@@ skipping 238 matching lines @@
 }
 
 bool WebPluginDelegateImpl::WindowedCreatePlugin() {
   DCHECK(!windowed_handle_);
 
   RegisterNativeWindowClass();
 
   // The window will be sized and shown later.
   windowed_handle_ = CreateWindowEx(
       WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR,
-      kNativeWindowClassName,
+      webkit::npapi::kNativeWindowClassName,
       0,
       WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
       0,
       0,
       0,
       0,
-      GetDefaultWindowParent(),
+      webkit::npapi::GetDefaultWindowParent(),
       0,
       GetModuleHandle(NULL),
       0);
   if (windowed_handle_ == 0)
     return false;
 
     // This is a tricky workaround for Issue 2673 in chromium "Flash: IME not
     // available". To use IMEs in this window, we have to make Windows attach
   // IMEs to this window (i.e. load IME DLLs, attach them to this process, and
   // add their message hooks to this window). Windows attaches IMEs while this
@@ skipping 12 matching lines @@
   // window property. Use atoms so that other processes can access the name and
   // version of the plugin that this window is hosting.
   if (instance_ != NULL) {
     PluginLib* plugin_lib = instance()->plugin_lib();
     if (plugin_lib != NULL) {
       std::wstring plugin_name = plugin_lib->plugin_info().name;
       if (!plugin_name.empty()) {
         ATOM plugin_name_atom = GlobalAddAtomW(plugin_name.c_str());
         DCHECK_NE(0, plugin_name_atom);
         result = SetProp(windowed_handle_,
-            kPluginNameAtomProperty,
+            webkit::npapi::kPluginNameAtomProperty,
             reinterpret_cast<HANDLE>(plugin_name_atom));
         DCHECK(result == TRUE) << "SetProp failed, last error = " <<
             GetLastError();
       }
       base::string16 plugin_version = plugin_lib->plugin_info().version;
       if (!plugin_version.empty()) {
         ATOM plugin_version_atom = GlobalAddAtomW(plugin_version.c_str());
         DCHECK_NE(0, plugin_version_atom);
         result = SetProp(windowed_handle_,
-            kPluginVersionAtomProperty,
+            webkit::npapi::kPluginVersionAtomProperty,
             reinterpret_cast<HANDLE>(plugin_version_atom));
         DCHECK(result == TRUE) << "SetProp failed, last error = " <<
             GetLastError();
       }
     }
   }
 
   // Calling SetWindowLongPtrA here makes the window proc ASCII, which is
   // required by at least the Shockwave Director plug-in.
   SetWindowLongPtrA(
@@ skipping 203 matching lines @@
 
   return TRUE;
 }
 
 bool WebPluginDelegateImpl::CreateDummyWindowForActivation() {
   DCHECK(!dummy_window_for_activation_);
 
   dummy_window_for_activation_ = CreateWindowEx(
     0,
     L"Static",
-    kDummyActivationWindowName,
+    webkit::npapi::kDummyActivationWindowName,
     WS_CHILD,
     0,
     0,
     0,
     0,
     // We don't know the parent of the dummy window yet, so just set it to the
     // desktop and it'll get parented by the browser.
-      GetDefaultWindowParent(),
+      webkit::npapi::GetDefaultWindowParent(),
     0,
     GetModuleHandle(NULL),
     0);
 
   if (dummy_window_for_activation_ == 0)
     return false;
 
   BOOL result = SetProp(dummy_window_for_activation_,
                         kWebPluginDelegateProperty, this);
   DCHECK(result == TRUE) << "SetProp failed, last error = " << GetLastError();
@@ skipping 112 matching lines @@
   wcex.hInstance      = GetModuleHandle(NULL);
   wcex.hIcon          = 0;
   wcex.hCursor        = 0;
   // Some plugins like windows media player 11 create child windows parented
   // by our plugin window, where the media content is rendered. These plugins
   // dont implement WM_ERASEBKGND, which causes painting issues, when the
   // window where the media is rendered is moved around. DefWindowProc does
   // implement WM_ERASEBKGND correctly if we have a valid background brush.
   wcex.hbrBackground  = reinterpret_cast<HBRUSH>(COLOR_WINDOW+1);
   wcex.lpszMenuName   = 0;
-  wcex.lpszClassName  = kNativeWindowClassName;
+  wcex.lpszClassName  = webkit::npapi::kNativeWindowClassName;
   wcex.hIconSm        = 0;
 
   return RegisterClassEx(&wcex);
 }
 
 LRESULT CALLBACK WebPluginDelegateImpl::WrapperWindowProc(
     HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
   // This is another workaround for Issue 2673 in chromium "Flash: IME not
   // available". Somehow, the CallWindowProc() function does not dispatch
   // window messages when its first parameter is a handle representing the
@@ skipping 112 matching lines @@
 
     result = CallWindowProc(
         delegate->plugin_wnd_proc_, hwnd, message, wparam, lparam);
 
     delegate->is_calling_wndproc = false;
     g_current_plugin_instance = last_plugin_instance;
 
     if (message == WM_NCDESTROY) {
       RemoveProp(hwnd, kWebPluginDelegateProperty);
       ATOM plugin_name_atom = reinterpret_cast<ATOM>(
-          RemoveProp(hwnd, kPluginNameAtomProperty));
+          RemoveProp(hwnd, webkit::npapi::kPluginNameAtomProperty));
       if (plugin_name_atom != 0)
         GlobalDeleteAtom(plugin_name_atom);
       ATOM plugin_version_atom = reinterpret_cast<ATOM>(
-          RemoveProp(hwnd, kPluginVersionAtomProperty));
+          RemoveProp(hwnd, webkit::npapi::kPluginVersionAtomProperty));
       if (plugin_version_atom != 0)
         GlobalDeleteAtom(plugin_version_atom);
       ClearThrottleQueueForWindow(hwnd);
     }
   }
   delegate->last_message_ = old_message;
   return result;
 }
 
 void WebPluginDelegateImpl::WindowlessUpdateGeometry(
@@ skipping 223 matching lines @@
     handle_event_message_filter_hook_ =
         SetWindowsHookEx(WH_MSGFILTER, HandleEventMessageFilterHook, NULL,
                          GetCurrentThreadId());
     // To ensure that the plugin receives keyboard events we set focus to the
     // dummy window.
     // TODO(iyengar) We need a framework in the renderer to identify which
     // windowless plugin is under the mouse and to handle this. This would
     // also require some changes in RenderWidgetHost to detect this in the
     // WM_MOUSEACTIVATE handler and inform the renderer accordingly.
     bool valid =
-        GetParent(dummy_window_for_activation_) != GetDefaultWindowParent();
+        GetParent(dummy_window_for_activation_) !=
+        webkit::npapi::GetDefaultWindowParent();
     if (valid) {
       last_focus_window = ::SetFocus(dummy_window_for_activation_);
     } else {
       NOTREACHED() << "Dummy window not parented";
     }
   }
 
   bool old_task_reentrancy_state =
       base::MessageLoop::current()->NestableTasksAllowed();
 
@@ skipping 103 matching lines @@
 
   if (g_current_plugin_instance) {
     unsigned long window_process_id = 0;
     unsigned long window_thread_id =
         GetWindowThreadProcessId(window, &window_process_id);
     // TrackPopupMenu fails if the window passed in belongs to a different
     // thread.
     if (::GetCurrentThreadId() != window_thread_id) {
       bool valid =
           GetParent(g_current_plugin_instance->dummy_window_for_activation_) !=
-              GetDefaultWindowParent();
+              webkit::npapi::GetDefaultWindowParent();
       if (valid) {
         window = g_current_plugin_instance->dummy_window_for_activation_;
       } else {
         NOTREACHED() << "Dummy window not parented";
       }
     }
   }
 
   BOOL result = TrackPopupMenu(menu, flags, x, y, reserved, window, rect);
   return result;
@@ skipping 63 matching lines @@
 FARPROC WINAPI WebPluginDelegateImpl::GetProcAddressPatch(HMODULE module,
                                                           LPCSTR name) {
   FARPROC imm_function = WebPluginIMEWin::GetProcAddress(name);
   if (imm_function)
     return imm_function;
   return ::GetProcAddress(module, name);
 }
 
 void WebPluginDelegateImpl::HandleCaptureForMessage(HWND window,
                                                     UINT message) {
-  if (!WebPluginDelegateImpl::IsPluginDelegateWindow(window))
+  if (!webkit::npapi::IsPluginDelegateWindow(window))
     return;
 
   switch (message) {
     case WM_LBUTTONDOWN:
     case WM_MBUTTONDOWN:
     case WM_RBUTTONDOWN:
       ::SetCapture(window);
       // As per documentation the WM_PARENTNOTIFY message is sent to the parent
       // window chain if mouse input is received by the child window. However
       // the parent receives the WM_PARENTNOTIFY message only if we doubleclick
       // on the window. We send the WM_PARENTNOTIFY message for mouse input
       // messages to the parent to indicate that user action is expected.
       ::SendMessage(::GetParent(window), WM_PARENTNOTIFY, message, 0);
       break;
 
     case WM_LBUTTONUP:
     case WM_MBUTTONUP:
     case WM_RBUTTONUP:
       ::ReleaseCapture();
       break;
 
     default:
       break;
   }
 }
 
-}  // namespace npapi
-}  // namespace webkit
+}  // namespace content