Remove webkit/plugins/npapi.

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 "content/child/npapi/webplugin_delegate_impl.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 15 matching lines @@
 #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_utils.h"
 #include "webkit/plugins/plugin_constants.h"
 
 using WebKit::WebKeyboardEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 using webkit::WebPluginInfo;
 
 namespace content {
 
 namespace {
@@ skipping 135 matching lines @@
   if (result != STATUS_SUCCESS)
     return L"";
 
   KEY_NAME_INFORMATION* info =
       reinterpret_cast<KEY_NAME_INFORMATION*>(buffer.get());
   return std::wstring(info->Name, info->NameLength / sizeof(wchar_t));
 }
 
 int GetPluginMajorVersion(const WebPluginInfo& plugin_info) {
   Version plugin_version;
-  webkit::npapi::CreateVersionFromString(plugin_info.version, &plugin_version);
+  webkit::WebPluginInfo::CreateVersionFromString(
+      plugin_info.version, &plugin_version);
 
   int major_version = 0;
   if (plugin_version.IsValid())
     major_version = plugin_version.components()[0];
 
   return major_version;
 }
 
 }  // namespace
 
@@ skipping 248 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,
-      webkit::npapi::kNativeWindowClassName,
+      kNativeWindowClassName,
       0,
       WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
       0,
       0,
       0,
       0,
-      webkit::npapi::GetDefaultWindowParent(),
+      GetDesktopWindow(),
       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_,
-            webkit::npapi::kPluginNameAtomProperty,
+            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_,
-            webkit::npapi::kPluginVersionAtomProperty,
+            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",
-    webkit::npapi::kDummyActivationWindowName,
+    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.
-      webkit::npapi::GetDefaultWindowParent(),
+    GetDesktopWindow(),
     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  = webkit::npapi::kNativeWindowClassName;
+  wcex.lpszClassName  = 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, webkit::npapi::kPluginNameAtomProperty));
+          RemoveProp(hwnd, kPluginNameAtomProperty));
       if (plugin_name_atom != 0)
         GlobalDeleteAtom(plugin_name_atom);
       ATOM plugin_version_atom = reinterpret_cast<ATOM>(
-          RemoveProp(hwnd, webkit::npapi::kPluginVersionAtomProperty));
+          RemoveProp(hwnd, kPluginVersionAtomProperty));
       if (plugin_version_atom != 0)
         GlobalDeleteAtom(plugin_version_atom);
       ClearThrottleQueueForWindow(hwnd);
     }
   }
   delegate->last_message_ = old_message;
   return result;
 }
 
 void WebPluginDelegateImpl::WindowlessUpdateGeometry(
@@ skipping 222 matching lines @@
     // the message filter hook.
     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_) !=
-        webkit::npapi::GetDefaultWindowParent();
+    bool valid = GetParent(dummy_window_for_activation_) != GetDesktopWindow();
     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_) !=
-              webkit::npapi::GetDefaultWindowParent();
+              GetDesktopWindow();
       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 (!webkit::npapi::IsPluginDelegateWindow(window))
+  if (ui::GetClassName(window) != base::string16(kNativeWindowClassName))
     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 content