src/content/child/npapi/webplugin_delegate_impl_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/child/npapi/webplugin_delegate_impl.h"
   6
   7 #include <map>
   8 #include <set>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/bind.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/lazy_instance.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/message_loop/message_loop.h"
  17 #include "base/metrics/stats_counters.h"
  18 #include "base/strings/string_util.h"
  19 #include "base/strings/stringprintf.h"
  20 #include "base/synchronization/lock.h"
  21 #include "base/version.h"
  22 #include "base/win/iat_patch_function.h"
  23 #include "base/win/registry.h"
  24 #include "base/win/windows_version.h"
  25 #include "content/child/npapi/plugin_instance.h"
  26 #include "content/child/npapi/plugin_lib.h"
  27 #include "content/child/npapi/plugin_stream_url.h"
  28 #include "content/child/npapi/webplugin.h"
  29 #include "content/child/npapi/webplugin_ime_win.h"
  30 #include "content/common/cursors/webcursor.h"
  31 #include "content/common/plugin_constants_win.h"
  32 #include "content/public/common/content_constants.h"
  33 #include "skia/ext/platform_canvas.h"
  34 #include "third_party/WebKit/public/web/WebInputEvent.h"
  35 #include "ui/gfx/win/dpi.h"
  36 #include "ui/gfx/win/hwnd_util.h"
  37
  38 using blink::WebKeyboardEvent;
  39 using blink::WebInputEvent;
  40 using blink::WebMouseEvent;
  41
  42 namespace content {
  43
  44 namespace {
  45
  46 const wchar_t kWebPluginDelegateProperty[] = L"WebPluginDelegateProperty";
  47 const wchar_t kPluginFlashThrottle[] = L"FlashThrottle";
  48
  49 // The fastest we are willing to process WM_USER+1 events for Flash.
  50 // Flash can easily exceed the limits of our CPU if we don't throttle it.
  51 // The throttle has been chosen by testing various delays and compromising
  52 // on acceptable Flash performance and reasonable CPU consumption.
  53 //
  54 // I'd like to make the throttle delay variable, based on the amount of
  55 // time currently required to paint Flash plugins.  There isn't a good
  56 // way to count the time spent in aggregate plugin painting, however, so
  57 // this seems to work well enough.
  58 const int kFlashWMUSERMessageThrottleDelayMs = 5;
  59
  60 // Flash displays popups in response to user clicks by posting a WM_USER
  61 // message to the plugin window. The handler for this message displays
  62 // the popup. To ensure that the popups allowed state is sent correctly
  63 // to the renderer we reset the popups allowed state in a timer.
  64 const int kWindowedPluginPopupTimerMs = 50;
  65
  66 // The current instance of the plugin which entered the modal loop.
  67 WebPluginDelegateImpl* g_current_plugin_instance = NULL;
  68
  69 typedef std::deque<MSG> ThrottleQueue;
  70 base::LazyInstance<ThrottleQueue> g_throttle_queue = LAZY_INSTANCE_INITIALIZER;
  71
  72 base::LazyInstance<std::map<HWND, WNDPROC> > g_window_handle_proc_map =
  73     LAZY_INSTANCE_INITIALIZER;
  74
  75 // Helper object for patching the TrackPopupMenu API.
  76 base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_track_popup_menu =
  77     LAZY_INSTANCE_INITIALIZER;
  78
  79 // Helper object for patching the SetCursor API.
  80 base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_set_cursor =
  81     LAZY_INSTANCE_INITIALIZER;
  82
  83 // Helper object for patching the RegEnumKeyExW API.
  84 base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_reg_enum_key_ex_w =
  85     LAZY_INSTANCE_INITIALIZER;
  86
  87 // Helper object for patching the GetProcAddress API.
  88 base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_get_proc_address =
  89     LAZY_INSTANCE_INITIALIZER;
  90
  91 base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_window_from_point =
  92     LAZY_INSTANCE_INITIALIZER;
  93
  94 // http://crbug.com/16114
  95 // Enforces providing a valid device context in NPWindow, so that NPP_SetWindow
  96 // is never called with NPNWindoTypeDrawable and NPWindow set to NULL.
  97 // Doing so allows removing NPP_SetWindow call during painting a windowless
  98 // plugin, which otherwise could trigger layout change while painting by
  99 // invoking NPN_Evaluate. Which would cause bad, bad crashes. Bad crashes.
 100 // TODO(dglazkov): If this approach doesn't produce regressions, move class to
 101 // webplugin_delegate_impl.h and implement for other platforms.
 102 class DrawableContextEnforcer {
 103  public:
 104   explicit DrawableContextEnforcer(NPWindow* window)
 105       : window_(window),
 106         disposable_dc_(window && !window->window) {
 107     // If NPWindow is NULL, create a device context with monochrome 1x1 surface
 108     // and stuff it to NPWindow.
 109     if (disposable_dc_)
 110       window_->window = CreateCompatibleDC(NULL);
 111   }
 112
 113   ~DrawableContextEnforcer() {
 114     if (!disposable_dc_)
 115       return;
 116
 117     DeleteDC(static_cast<HDC>(window_->window));
 118     window_->window = NULL;
 119   }
 120
 121  private:
 122   NPWindow* window_;
 123   bool disposable_dc_;
 124 };
 125
 126 // These are from ntddk.h
 127 typedef LONG NTSTATUS;
 128
 129 #ifndef STATUS_SUCCESS
 130 #define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
 131 #endif
 132
 133 #ifndef STATUS_BUFFER_TOO_SMALL
 134 #define STATUS_BUFFER_TOO_SMALL ((NTSTATUS)0xC0000023L)
 135 #endif
 136
 137 typedef enum _KEY_INFORMATION_CLASS {
 138   KeyBasicInformation,
 139   KeyNodeInformation,
 140   KeyFullInformation,
 141   KeyNameInformation,
 142   KeyCachedInformation,
 143   KeyVirtualizationInformation
 144 } KEY_INFORMATION_CLASS;
 145
 146 typedef struct _KEY_NAME_INFORMATION {
 147   ULONG NameLength;
 148   WCHAR Name[1];
 149 } KEY_NAME_INFORMATION, *PKEY_NAME_INFORMATION;
 150
 151 typedef DWORD (__stdcall *ZwQueryKeyType)(
 152     HANDLE  key_handle,
 153     int key_information_class,
 154     PVOID  key_information,
 155     ULONG  length,
 156     PULONG  result_length);
 157
 158 // Returns a key's full path.
 159 std::wstring GetKeyPath(HKEY key) {
 160   if (key == NULL)
 161     return L"";
 162
 163   HMODULE dll = GetModuleHandle(L"ntdll.dll");
 164   if (dll == NULL)
 165     return L"";
 166
 167   ZwQueryKeyType func = reinterpret_cast<ZwQueryKeyType>(
 168       ::GetProcAddress(dll, "ZwQueryKey"));
 169   if (func == NULL)
 170     return L"";
 171
 172   DWORD size = 0;
 173   DWORD result = 0;
 174   result = func(key, KeyNameInformation, 0, 0, &size);
 175   if (result != STATUS_BUFFER_TOO_SMALL)
 176     return L"";
 177
 178   scoped_ptr<char[]> buffer(new char[size]);
 179   if (buffer.get() == NULL)
 180     return L"";
 181
 182   result = func(key, KeyNameInformation, buffer.get(), size, &size);
 183   if (result != STATUS_SUCCESS)
 184     return L"";
 185
 186   KEY_NAME_INFORMATION* info =
 187       reinterpret_cast<KEY_NAME_INFORMATION*>(buffer.get());
 188   return std::wstring(info->Name, info->NameLength / sizeof(wchar_t));
 189 }
 190
 191 int GetPluginMajorVersion(const WebPluginInfo& plugin_info) {
 192   Version plugin_version;
 193   WebPluginInfo::CreateVersionFromString(plugin_info.version, &plugin_version);
 194
 195   int major_version = 0;
 196   if (plugin_version.IsValid())
 197     major_version = plugin_version.components()[0];
 198
 199   return major_version;
 200 }
 201
 202 }  // namespace
 203
 204 LRESULT CALLBACK WebPluginDelegateImpl::HandleEventMessageFilterHook(
 205     int code, WPARAM wParam, LPARAM lParam) {
 206   if (g_current_plugin_instance) {
 207     g_current_plugin_instance->OnModalLoopEntered();
 208   } else {
 209     NOTREACHED();
 210   }
 211   return CallNextHookEx(NULL, code, wParam, lParam);
 212 }
 213
 214 LRESULT CALLBACK WebPluginDelegateImpl::MouseHookProc(
 215     int code, WPARAM wParam, LPARAM lParam) {
 216   if (code == HC_ACTION) {
 217     MOUSEHOOKSTRUCT* hook_struct = reinterpret_cast<MOUSEHOOKSTRUCT*>(lParam);
 218     if (hook_struct)
 219       HandleCaptureForMessage(hook_struct->hwnd, wParam);
 220   }
 221
 222   return CallNextHookEx(NULL, code, wParam, lParam);
 223 }
 224
 225 WebPluginDelegateImpl::WebPluginDelegateImpl(
 226     WebPlugin* plugin,
 227     PluginInstance* instance)
 228     : instance_(instance),
 229       quirks_(0),
 230       plugin_(plugin),
 231       windowless_(false),
 232       windowed_handle_(NULL),
 233       windowed_did_set_window_(false),
 234       plugin_wnd_proc_(NULL),
 235       last_message_(0),
 236       is_calling_wndproc(false),
 237       dummy_window_for_activation_(NULL),
 238       dummy_window_parent_(NULL),
 239       old_dummy_window_proc_(NULL),
 240       handle_event_message_filter_hook_(NULL),
 241       handle_event_pump_messages_event_(NULL),
 242       user_gesture_message_posted_(false),
 243       user_gesture_msg_factory_(this),
 244       handle_event_depth_(0),
 245       mouse_hook_(NULL),
 246       first_set_window_call_(true),
 247       plugin_has_focus_(false),
 248       has_webkit_focus_(false),
 249       containing_view_has_focus_(true),
 250       creation_succeeded_(false) {
 251   memset(&window_, 0, sizeof(window_));
 252
 253   const WebPluginInfo& plugin_info = instance_->plugin_lib()->plugin_info();
 254   std::wstring filename =
 255       base::StringToLowerASCII(plugin_info.path.BaseName().value());
 256
 257   if (instance_->mime_type() == kFlashPluginSwfMimeType ||
 258       filename == kFlashPlugin) {
 259     // Flash only requests windowless plugins if we return a Mozilla user
 260     // agent.
 261     instance_->set_use_mozilla_user_agent();
 262     quirks_ |= PLUGIN_QUIRK_THROTTLE_WM_USER_PLUS_ONE;
 263     quirks_ |= PLUGIN_QUIRK_PATCH_SETCURSOR;
 264     quirks_ |= PLUGIN_QUIRK_ALWAYS_NOTIFY_SUCCESS;
 265     quirks_ |= PLUGIN_QUIRK_HANDLE_MOUSE_CAPTURE;
 266     quirks_ |= PLUGIN_QUIRK_EMULATE_IME;
 267     quirks_ |= PLUGIN_QUIRK_FAKE_WINDOW_FROM_POINT;
 268   } else if (filename == kAcrobatReaderPlugin) {
 269     // Check for the version number above or equal 9.
 270     int major_version = GetPluginMajorVersion(plugin_info);
 271     if (major_version >= 9) {
 272       quirks_ |= PLUGIN_QUIRK_DIE_AFTER_UNLOAD;
 273       // 9.2 needs this.
 274       quirks_ |= PLUGIN_QUIRK_SETWINDOW_TWICE;
 275     }
 276     quirks_ |= PLUGIN_QUIRK_BLOCK_NONSTANDARD_GETURL_REQUESTS;
 277   } else if (plugin_info.name.find(L"Windows Media Player") !=
 278              std::wstring::npos) {
 279     // Windows Media Player needs two NPP_SetWindow calls.
 280     quirks_ |= PLUGIN_QUIRK_SETWINDOW_TWICE;
 281
 282     // Windowless mode doesn't work in the WMP NPAPI plugin.
 283     quirks_ |= PLUGIN_QUIRK_NO_WINDOWLESS;
 284
 285     // The media player plugin sets its size on the first NPP_SetWindow call
 286     // and never updates its size. We should call the underlying NPP_SetWindow
 287     // only when we have the correct size.
 288     quirks_ |= PLUGIN_QUIRK_IGNORE_FIRST_SETWINDOW_CALL;
 289
 290     if (filename == kOldWMPPlugin) {
 291       // Non-admin users on XP couldn't modify the key to force the new UI.
 292       quirks_ |= PLUGIN_QUIRK_PATCH_REGENUMKEYEXW;
 293     }
 294   } else if (instance_->mime_type() == "audio/x-pn-realaudio-plugin" ||
 295              filename == kRealPlayerPlugin) {
 296     quirks_ |= PLUGIN_QUIRK_DONT_CALL_WND_PROC_RECURSIVELY;
 297   } else if (plugin_info.name.find(L"VLC Multimedia Plugin") !=
 298              std::wstring::npos ||
 299              plugin_info.name.find(L"VLC Multimedia Plug-in") !=
 300              std::wstring::npos) {
 301     // VLC hangs on NPP_Destroy if we call NPP_SetWindow with a null window
 302     // handle
 303     quirks_ |= PLUGIN_QUIRK_DONT_SET_NULL_WINDOW_HANDLE_ON_DESTROY;
 304     int major_version = GetPluginMajorVersion(plugin_info);
 305     if (major_version == 0) {
 306       // VLC 0.8.6d and 0.8.6e crash if multiple instances are created.
 307       quirks_ |= PLUGIN_QUIRK_DONT_ALLOW_MULTIPLE_INSTANCES;
 308     }
 309   } else if (filename == kSilverlightPlugin) {
 310     // Explanation for this quirk can be found in
 311     // WebPluginDelegateImpl::Initialize.
 312     quirks_ |= PLUGIN_QUIRK_PATCH_SETCURSOR;
 313   } else if (plugin_info.name.find(L"DivX Web Player") !=
 314              std::wstring::npos) {
 315     // The divx plugin sets its size on the first NPP_SetWindow call and never
 316     // updates its size. We should call the underlying NPP_SetWindow only when
 317     // we have the correct size.
 318     quirks_ |= PLUGIN_QUIRK_IGNORE_FIRST_SETWINDOW_CALL;
 319   }
 320 }
 321
 322 WebPluginDelegateImpl::~WebPluginDelegateImpl() {
 323   if (::IsWindow(dummy_window_for_activation_)) {
 324     WNDPROC current_wnd_proc = reinterpret_cast<WNDPROC>(
 325         GetWindowLongPtr(dummy_window_for_activation_, GWLP_WNDPROC));
 326     if (current_wnd_proc == DummyWindowProc) {
 327       SetWindowLongPtr(dummy_window_for_activation_,
 328                        GWLP_WNDPROC,
 329                        reinterpret_cast<LONG_PTR>(old_dummy_window_proc_));
 330     }
 331     ::DestroyWindow(dummy_window_for_activation_);
 332   }
 333
 334   DestroyInstance();
 335
 336   if (!windowless_)
 337     WindowedDestroyWindow();
 338
 339   if (handle_event_pump_messages_event_) {
 340     CloseHandle(handle_event_pump_messages_event_);
 341   }
 342 }
 343
 344 bool WebPluginDelegateImpl::PlatformInitialize() {
 345   plugin_->SetWindow(windowed_handle_);
 346
 347   if (windowless_) {
 348     CreateDummyWindowForActivation();
 349     handle_event_pump_messages_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
 350     plugin_->SetWindowlessData(
 351         handle_event_pump_messages_event_,
 352         reinterpret_cast<gfx::NativeViewId>(dummy_window_for_activation_));
 353   }
 354
 355   // Windowless plugins call the WindowFromPoint API and passes the result of
 356   // that to the TrackPopupMenu API call as the owner window. This causes the
 357   // API to fail as the API expects the window handle to live on the same
 358   // thread as the caller. It works in the other browsers as the plugin lives
 359   // on the browser thread. Our workaround is to intercept the TrackPopupMenu
 360   // API and replace the window handle with the dummy activation window.
 361   if (windowless_ && !g_iat_patch_track_popup_menu.Pointer()->is_patched()) {
 362     g_iat_patch_track_popup_menu.Pointer()->Patch(
 363         GetPluginPath().value().c_str(), "user32.dll", "TrackPopupMenu",
 364         WebPluginDelegateImpl::TrackPopupMenuPatch);
 365   }
 366
 367   // Windowless plugins can set cursors by calling the SetCursor API. This
 368   // works because the thread inputs of the browser UI thread and the plugin
 369   // thread are attached. We intercept the SetCursor API for windowless
 370   // plugins and remember the cursor being set. This is shipped over to the
 371   // browser in the HandleEvent call, which ensures that the cursor does not
 372   // change when a windowless plugin instance changes the cursor
 373   // in a background tab.
 374   if (windowless_ && !g_iat_patch_set_cursor.Pointer()->is_patched() &&
 375       (quirks_ & PLUGIN_QUIRK_PATCH_SETCURSOR)) {
 376     g_iat_patch_set_cursor.Pointer()->Patch(
 377         GetPluginPath().value().c_str(), "user32.dll", "SetCursor",
 378         WebPluginDelegateImpl::SetCursorPatch);
 379   }
 380
 381   // The windowed flash plugin has a bug which occurs when the plugin enters
 382   // fullscreen mode. It basically captures the mouse on WM_LBUTTONDOWN and
 383   // does not release capture correctly causing it to stop receiving
 384   // subsequent mouse events. This problem is also seen in Safari where there
 385   // is code to handle this in the wndproc. However the plugin subclasses the
 386   // window again in WM_LBUTTONDOWN before entering full screen. As a result
 387   // Safari does not receive the WM_LBUTTONUP message. To workaround this
 388   // issue we use a per thread mouse hook. This bug does not occur in Firefox
 389   // and opera. Firefox has code similar to Safari. It could well be a bug in
 390   // the flash plugin, which only occurs in webkit based browsers.
 391   if (quirks_ & PLUGIN_QUIRK_HANDLE_MOUSE_CAPTURE) {
 392     mouse_hook_ = SetWindowsHookEx(WH_MOUSE, MouseHookProc, NULL,
 393                                     GetCurrentThreadId());
 394   }
 395
 396   // On XP, WMP will use its old UI unless a registry key under HKLM has the
 397   // name of the current process.  We do it in the installer for admin users,
 398   // for the rest patch this function.
 399   if ((quirks_ & PLUGIN_QUIRK_PATCH_REGENUMKEYEXW) &&
 400       base::win::GetVersion() == base::win::VERSION_XP &&
 401       (base::win::RegKey().Open(HKEY_LOCAL_MACHINE,
 402           L"SOFTWARE\\Microsoft\\MediaPlayer\\ShimInclusionList\\chrome.exe",
 403           KEY_READ) != ERROR_SUCCESS) &&
 404       !g_iat_patch_reg_enum_key_ex_w.Pointer()->is_patched()) {
 405     g_iat_patch_reg_enum_key_ex_w.Pointer()->Patch(
 406         L"wmpdxm.dll", "advapi32.dll", "RegEnumKeyExW",
 407         WebPluginDelegateImpl::RegEnumKeyExWPatch);
 408   }
 409
 410   // Flash retrieves the pointers to IMM32 functions with GetProcAddress() calls
 411   // and use them to retrieve IME data. We add a patch to this function so we
 412   // can dispatch these IMM32 calls to the WebPluginIMEWin class, which emulates
 413   // IMM32 functions for Flash.
 414   if (!g_iat_patch_get_proc_address.Pointer()->is_patched() &&
 415       (quirks_ & PLUGIN_QUIRK_EMULATE_IME)) {
 416     g_iat_patch_get_proc_address.Pointer()->Patch(
 417         GetPluginPath().value().c_str(), "kernel32.dll", "GetProcAddress",
 418         GetProcAddressPatch);
 419   }
 420
 421   if (windowless_ && !g_iat_patch_window_from_point.Pointer()->is_patched() &&
 422       (quirks_ & PLUGIN_QUIRK_FAKE_WINDOW_FROM_POINT)) {
 423     g_iat_patch_window_from_point.Pointer()->Patch(
 424         GetPluginPath().value().c_str(), "user32.dll", "WindowFromPoint",
 425         WebPluginDelegateImpl::WindowFromPointPatch);
 426   }
 427
 428   return true;
 429 }
 430
 431 void WebPluginDelegateImpl::PlatformDestroyInstance() {
 432   if (!instance_->plugin_lib())
 433     return;
 434
 435   // Unpatch if this is the last plugin instance.
 436   if (instance_->plugin_lib()->instance_count() != 1)
 437     return;
 438
 439   if (g_iat_patch_set_cursor.Pointer()->is_patched())
 440     g_iat_patch_set_cursor.Pointer()->Unpatch();
 441
 442   if (g_iat_patch_track_popup_menu.Pointer()->is_patched())
 443     g_iat_patch_track_popup_menu.Pointer()->Unpatch();
 444
 445   if (g_iat_patch_reg_enum_key_ex_w.Pointer()->is_patched())
 446     g_iat_patch_reg_enum_key_ex_w.Pointer()->Unpatch();
 447
 448   if (g_iat_patch_window_from_point.Pointer()->is_patched())
 449     g_iat_patch_window_from_point.Pointer()->Unpatch();
 450
 451   if (mouse_hook_) {
 452     UnhookWindowsHookEx(mouse_hook_);
 453     mouse_hook_ = NULL;
 454   }
 455 }
 456
 457 void WebPluginDelegateImpl::Paint(SkCanvas* canvas, const gfx::Rect& rect) {
 458   if (windowless_ && skia::SupportsPlatformPaint(canvas)) {
 459     skia::ScopedPlatformPaint scoped_platform_paint(canvas);
 460     HDC hdc = scoped_platform_paint.GetPlatformSurface();
 461     WindowlessPaint(hdc, rect);
 462   }
 463 }
 464
 465 bool WebPluginDelegateImpl::WindowedCreatePlugin() {
 466   DCHECK(!windowed_handle_);
 467
 468   RegisterNativeWindowClass();
 469
 470   // The window will be sized and shown later.
 471   windowed_handle_ = CreateWindowEx(
 472       WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR,
 473       kNativeWindowClassName,
 474       0,
 475       WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
 476       0,
 477       0,
 478       0,
 479       0,
 480       GetDesktopWindow(),
 481       0,
 482       GetModuleHandle(NULL),
 483       0);
 484   if (windowed_handle_ == 0)
 485     return false;
 486
 487     // This is a tricky workaround for Issue 2673 in chromium "Flash: IME not
 488     // available". To use IMEs in this window, we have to make Windows attach
 489   // IMEs to this window (i.e. load IME DLLs, attach them to this process, and
 490   // add their message hooks to this window). Windows attaches IMEs while this
 491   // process creates a top-level window. On the other hand, to layout this
 492   // window correctly in the given parent window (RenderWidgetHostViewWin or
 493   // RenderWidgetHostViewAura), this window should be a child window of the
 494   // parent window. To satisfy both of the above conditions, this code once
 495   // creates a top-level window and change it to a child window of the parent
 496   // window (in the browser process).
 497     SetWindowLongPtr(windowed_handle_, GWL_STYLE,
 498                      WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
 499
 500   BOOL result = SetProp(windowed_handle_, kWebPluginDelegateProperty, this);
 501   DCHECK(result == TRUE) << "SetProp failed, last error = " << GetLastError();
 502
 503   // Calling SetWindowLongPtrA here makes the window proc ASCII, which is
 504   // required by at least the Shockwave Director plug-in.
 505   SetWindowLongPtrA(windowed_handle_,
 506                     GWLP_WNDPROC,
 507                     reinterpret_cast<LONG_PTR>(DefWindowProcA));
 508
 509   return true;
 510 }
 511
 512 void WebPluginDelegateImpl::WindowedDestroyWindow() {
 513   if (windowed_handle_ != NULL) {
 514     // Unsubclass the window.
 515     WNDPROC current_wnd_proc = reinterpret_cast<WNDPROC>(
 516         GetWindowLongPtr(windowed_handle_, GWLP_WNDPROC));
 517     if (current_wnd_proc == NativeWndProc) {
 518       SetWindowLongPtr(windowed_handle_,
 519                        GWLP_WNDPROC,
 520                        reinterpret_cast<LONG_PTR>(plugin_wnd_proc_));
 521     }
 522
 523     plugin_->WillDestroyWindow(windowed_handle_);
 524
 525     DestroyWindow(windowed_handle_);
 526     windowed_handle_ = 0;
 527   }
 528 }
 529
 530 // Erase all messages in the queue destined for a particular window.
 531 // When windows are closing, callers should use this function to clear
 532 // the queue.
 533 // static
 534 void WebPluginDelegateImpl::ClearThrottleQueueForWindow(HWND window) {
 535   ThrottleQueue* throttle_queue = g_throttle_queue.Pointer();
 536
 537   ThrottleQueue::iterator it;
 538   for (it = throttle_queue->begin(); it != throttle_queue->end(); ) {
 539     if (it->hwnd == window) {
 540       it = throttle_queue->erase(it);
 541     } else {
 542       it++;
 543     }
 544   }
 545 }
 546
 547 // Delayed callback for processing throttled messages.
 548 // Throttled messages are aggregated globally across all plugins.
 549 // static
 550 void WebPluginDelegateImpl::OnThrottleMessage() {
 551   // The current algorithm walks the list and processes the first
 552   // message it finds for each plugin.  It is important to service
 553   // all active plugins with each pass through the throttle, otherwise
 554   // we see video jankiness.  Copy the set to notify before notifying
 555   // since we may re-enter OnThrottleMessage from CallWindowProc!
 556   ThrottleQueue* throttle_queue = g_throttle_queue.Pointer();
 557   ThrottleQueue notify_queue;
 558   std::set<HWND> processed;
 559
 560   ThrottleQueue::iterator it = throttle_queue->begin();
 561   while (it != throttle_queue->end()) {
 562     const MSG& msg = *it;
 563     if (processed.find(msg.hwnd) == processed.end()) {
 564       processed.insert(msg.hwnd);
 565       notify_queue.push_back(msg);
 566       it = throttle_queue->erase(it);
 567     } else {
 568       it++;
 569     }
 570   }
 571
 572   // Due to re-entrancy, we must save our queue state now.  Otherwise, we may
 573   // self-post below, and *also* start up another delayed task when the first
 574   // entry is pushed onto the queue in ThrottleMessage().
 575   bool throttle_queue_was_empty = throttle_queue->empty();
 576
 577   for (it = notify_queue.begin(); it != notify_queue.end(); ++it) {
 578     const MSG& msg = *it;
 579     WNDPROC proc = reinterpret_cast<WNDPROC>(msg.time);
 580     // It is possible that the window was closed after we queued
 581     // this message.  This is a rare event; just verify the window
 582     // is alive.  (see also bug 1259488)
 583     if (IsWindow(msg.hwnd))
 584       CallWindowProc(proc, msg.hwnd, msg.message, msg.wParam, msg.lParam);
 585   }
 586
 587   if (!throttle_queue_was_empty) {
 588     base::MessageLoop::current()->PostDelayedTask(
 589         FROM_HERE,
 590         base::Bind(&WebPluginDelegateImpl::OnThrottleMessage),
 591         base::TimeDelta::FromMilliseconds(kFlashWMUSERMessageThrottleDelayMs));
 592   }
 593 }
 594
 595 // Schedule a windows message for delivery later.
 596 // static
 597 void WebPluginDelegateImpl::ThrottleMessage(WNDPROC proc, HWND hwnd,
 598                                             UINT message, WPARAM wParam,
 599                                             LPARAM lParam) {
 600   MSG msg;
 601   msg.time = reinterpret_cast<DWORD>(proc);
 602   msg.hwnd = hwnd;
 603   msg.message = message;
 604   msg.wParam = wParam;
 605   msg.lParam = lParam;
 606
 607   ThrottleQueue* throttle_queue = g_throttle_queue.Pointer();
 608
 609   throttle_queue->push_back(msg);
 610
 611   if (throttle_queue->size() == 1) {
 612     base::MessageLoop::current()->PostDelayedTask(
 613         FROM_HERE,
 614         base::Bind(&WebPluginDelegateImpl::OnThrottleMessage),
 615         base::TimeDelta::FromMilliseconds(kFlashWMUSERMessageThrottleDelayMs));
 616   }
 617 }
 618
 619 // We go out of our way to find the hidden windows created by Flash for
 620 // windowless plugins.  We throttle the rate at which they deliver messages
 621 // so that they will not consume outrageous amounts of CPU.
 622 // static
 623 LRESULT CALLBACK WebPluginDelegateImpl::FlashWindowlessWndProc(
 624     HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
 625   std::map<HWND, WNDPROC>::iterator index =
 626       g_window_handle_proc_map.Get().find(hwnd);
 627
 628   WNDPROC old_proc = (*index).second;
 629   DCHECK(old_proc);
 630
 631   switch (message) {
 632     case WM_NCDESTROY: {
 633       WebPluginDelegateImpl::ClearThrottleQueueForWindow(hwnd);
 634       g_window_handle_proc_map.Get().erase(index);
 635       break;
 636     }
 637     // Flash may flood the message queue with WM_USER+1 message causing 100% CPU
 638     // usage.  See https://bugzilla.mozilla.org/show_bug.cgi?id=132759.  We
 639     // prevent this by throttling the messages.
 640     case WM_USER + 1: {
 641       WebPluginDelegateImpl::ThrottleMessage(old_proc, hwnd, message, wparam,
 642                                              lparam);
 643       return TRUE;
 644     }
 645
 646     default: {
 647       break;
 648     }
 649   }
 650   return CallWindowProc(old_proc, hwnd, message, wparam, lparam);
 651 }
 652
 653 LRESULT CALLBACK WebPluginDelegateImpl::DummyWindowProc(
 654     HWND hwnd, UINT message, WPARAM w_param, LPARAM l_param) {
 655   WebPluginDelegateImpl* delegate = reinterpret_cast<WebPluginDelegateImpl*>(
 656       GetProp(hwnd, kWebPluginDelegateProperty));
 657   CHECK(delegate);
 658   if (message == WM_WINDOWPOSCHANGING) {
 659     // We need to know when the dummy window is parented because windowless
 660     // plugins need the parent window for things like menus. There's no message
 661     // for a parent being changed, but a WM_WINDOWPOSCHANGING is sent so we
 662     // check every time we get it.
 663     // For non-aura builds, this never changes since RenderWidgetHostViewWin's
 664     // window is constant. For aura builds, this changes every time the tab gets
 665     // dragged to a new window.
 666     HWND parent = GetParent(hwnd);
 667     if (parent != delegate->dummy_window_parent_) {
 668       delegate->dummy_window_parent_ = parent;
 669
 670       // Set the containing window handle as the instance window handle. This is
 671       // what Safari does. Not having a valid window handle causes subtle bugs
 672       // with plugins which retrieve the window handle and use it for things
 673       // like context menus. The window handle can be retrieved via
 674       // NPN_GetValue of NPNVnetscapeWindow.
 675       delegate->instance_->set_window_handle(parent);
 676
 677       // The plugin caches the result of NPNVnetscapeWindow when we originally
 678       // called NPP_SetWindow, so force it to get the new value.
 679       delegate->WindowlessSetWindow();
 680     }
 681   } else if (message == WM_NCDESTROY) {
 682     RemoveProp(hwnd, kWebPluginDelegateProperty);
 683   }
 684   return CallWindowProc(
 685       delegate->old_dummy_window_proc_, hwnd, message, w_param, l_param);
 686 }
 687
 688 // Callback for enumerating the Flash windows.
 689 BOOL CALLBACK EnumFlashWindows(HWND window, LPARAM arg) {
 690   WNDPROC wnd_proc = reinterpret_cast<WNDPROC>(arg);
 691   TCHAR class_name[1024];
 692   if (!RealGetWindowClass(window, class_name,
 693                           sizeof(class_name)/sizeof(TCHAR))) {
 694     LOG(ERROR) << "RealGetWindowClass failure: " << GetLastError();
 695     return FALSE;
 696   }
 697
 698   if (wcscmp(class_name, L"SWFlash_PlaceholderX"))
 699     return TRUE;
 700
 701   WNDPROC current_wnd_proc = reinterpret_cast<WNDPROC>(
 702         GetWindowLongPtr(window, GWLP_WNDPROC));
 703   if (current_wnd_proc != wnd_proc) {
 704     WNDPROC old_flash_proc = reinterpret_cast<WNDPROC>(SetWindowLongPtr(
 705         window, GWLP_WNDPROC,
 706         reinterpret_cast<LONG_PTR>(wnd_proc)));
 707     DCHECK(old_flash_proc);
 708     g_window_handle_proc_map.Get()[window] = old_flash_proc;
 709   }
 710
 711   return TRUE;
 712 }
 713
 714 bool WebPluginDelegateImpl::CreateDummyWindowForActivation() {
 715   DCHECK(!dummy_window_for_activation_);
 716
 717   dummy_window_for_activation_ = CreateWindowEx(
 718     0,
 719     L"Static",
 720     kDummyActivationWindowName,
 721     WS_CHILD,
 722     0,
 723     0,
 724     0,
 725     0,
 726     // We don't know the parent of the dummy window yet, so just set it to the
 727     // desktop and it'll get parented by the browser.
 728     GetDesktopWindow(),
 729     0,
 730     GetModuleHandle(NULL),
 731     0);
 732
 733   if (dummy_window_for_activation_ == 0)
 734     return false;
 735
 736   BOOL result = SetProp(dummy_window_for_activation_,
 737                         kWebPluginDelegateProperty, this);
 738   DCHECK(result == TRUE) << "SetProp failed, last error = " << GetLastError();
 739   old_dummy_window_proc_ = reinterpret_cast<WNDPROC>(SetWindowLongPtr(
 740       dummy_window_for_activation_, GWLP_WNDPROC,
 741       reinterpret_cast<LONG_PTR>(DummyWindowProc)));
 742
 743   // Flash creates background windows which use excessive CPU in our
 744   // environment; we wrap these windows and throttle them so that they don't
 745   // get out of hand.
 746   if (!EnumThreadWindows(::GetCurrentThreadId(), EnumFlashWindows,
 747       reinterpret_cast<LPARAM>(
 748       &WebPluginDelegateImpl::FlashWindowlessWndProc))) {
 749     // Log that this happened.  Flash will still work; it just means the
 750     // throttle isn't installed (and Flash will use more CPU).
 751     NOTREACHED();
 752     LOG(ERROR) << "Failed to wrap all windowless Flash windows";
 753   }
 754   return true;
 755 }
 756
 757 bool WebPluginDelegateImpl::WindowedReposition(
 758     const gfx::Rect& window_rect_in_dip,
 759     const gfx::Rect& clip_rect_in_dip) {
 760   if (!windowed_handle_) {
 761     NOTREACHED();
 762     return false;
 763   }
 764
 765   gfx::Rect window_rect = gfx::win::DIPToScreenRect(window_rect_in_dip);
 766   gfx::Rect clip_rect = gfx::win::DIPToScreenRect(clip_rect_in_dip);
 767   if (window_rect_ == window_rect && clip_rect_ == clip_rect)
 768     return false;
 769
 770   // We only set the plugin's size here.  Its position is moved elsewhere, which
 771   // allows the window moves/scrolling/clipping to be synchronized with the page
 772   // and other windows.
 773   // If the plugin window has no parent, then don't focus it because it isn't
 774   // being displayed anywhere. See:
 775   // http://code.google.com/p/chromium/issues/detail?id=32658
 776   if (window_rect.size() != window_rect_.size()) {
 777     UINT flags = SWP_NOMOVE | SWP_NOZORDER;
 778     if (!GetParent(windowed_handle_))
 779       flags |= SWP_NOACTIVATE;
 780     ::SetWindowPos(windowed_handle_,
 781                    NULL,
 782                    0,
 783                    0,
 784                    window_rect.width(),
 785                    window_rect.height(),
 786                    flags);
 787   }
 788
 789   window_rect_ = window_rect;
 790   clip_rect_ = clip_rect;
 791
 792   // Ensure that the entire window gets repainted.
 793   ::InvalidateRect(windowed_handle_, NULL, FALSE);
 794
 795   return true;
 796 }
 797
 798 void WebPluginDelegateImpl::WindowedSetWindow() {
 799   if (!instance_)
 800     return;
 801
 802   if (!windowed_handle_) {
 803     NOTREACHED();
 804     return;
 805   }
 806
 807   instance()->set_window_handle(windowed_handle_);
 808
 809   DCHECK(!instance()->windowless());
 810
 811   window_.clipRect.top = std::max(0, clip_rect_.y());
 812   window_.clipRect.left = std::max(0, clip_rect_.x());
 813   window_.clipRect.bottom = std::max(0, clip_rect_.y() + clip_rect_.height());
 814   window_.clipRect.right = std::max(0, clip_rect_.x() + clip_rect_.width());
 815   window_.height = window_rect_.height();
 816   window_.width = window_rect_.width();
 817   window_.x = 0;
 818   window_.y = 0;
 819
 820   window_.window = windowed_handle_;
 821   window_.type = NPWindowTypeWindow;
 822
 823   // Reset this flag before entering the instance in case of side-effects.
 824   windowed_did_set_window_ = true;
 825
 826   NPError err = instance()->NPP_SetWindow(&window_);
 827   if (quirks_ & PLUGIN_QUIRK_SETWINDOW_TWICE)
 828     instance()->NPP_SetWindow(&window_);
 829
 830   WNDPROC current_wnd_proc = reinterpret_cast<WNDPROC>(
 831         GetWindowLongPtr(windowed_handle_, GWLP_WNDPROC));
 832   if (current_wnd_proc != NativeWndProc) {
 833     plugin_wnd_proc_ = reinterpret_cast<WNDPROC>(
 834         SetWindowLongPtr(windowed_handle_,
 835                          GWLP_WNDPROC,
 836                          reinterpret_cast<LONG_PTR>(NativeWndProc)));
 837   }
 838 }
 839
 840 ATOM WebPluginDelegateImpl::RegisterNativeWindowClass() {
 841   static bool have_registered_window_class = false;
 842   if (have_registered_window_class == true)
 843     return true;
 844
 845   have_registered_window_class = true;
 846
 847   WNDCLASSEX wcex;
 848   wcex.cbSize         = sizeof(WNDCLASSEX);
 849   wcex.style          = CS_DBLCLKS;
 850   wcex.lpfnWndProc    = WrapperWindowProc;
 851   wcex.cbClsExtra     = 0;
 852   wcex.cbWndExtra     = 0;
 853   wcex.hInstance      = GetModuleHandle(NULL);
 854   wcex.hIcon          = 0;
 855   wcex.hCursor        = 0;
 856   // Some plugins like windows media player 11 create child windows parented
 857   // by our plugin window, where the media content is rendered. These plugins
 858   // dont implement WM_ERASEBKGND, which causes painting issues, when the
 859   // window where the media is rendered is moved around. DefWindowProc does
 860   // implement WM_ERASEBKGND correctly if we have a valid background brush.
 861   wcex.hbrBackground  = reinterpret_cast<HBRUSH>(COLOR_WINDOW+1);
 862   wcex.lpszMenuName   = 0;
 863   wcex.lpszClassName  = kNativeWindowClassName;
 864   wcex.hIconSm        = 0;
 865
 866   return RegisterClassEx(&wcex);
 867 }
 868
 869 LRESULT CALLBACK WebPluginDelegateImpl::WrapperWindowProc(
 870     HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
 871   // This is another workaround for Issue 2673 in chromium "Flash: IME not
 872   // available". Somehow, the CallWindowProc() function does not dispatch
 873   // window messages when its first parameter is a handle representing the
 874   // DefWindowProc() function. To avoid this problem, this code creates a
 875   // wrapper function which just encapsulates the DefWindowProc() function
 876   // and set it as the window procedure of a windowed plug-in.
 877   return DefWindowProc(hWnd, message, wParam, lParam);
 878 }
 879
 880 // Returns true if the message passed in corresponds to a user gesture.
 881 static bool IsUserGestureMessage(unsigned int message) {
 882   switch (message) {
 883     case WM_LBUTTONDOWN:
 884     case WM_LBUTTONUP:
 885     case WM_RBUTTONDOWN:
 886     case WM_RBUTTONUP:
 887     case WM_MBUTTONDOWN:
 888     case WM_MBUTTONUP:
 889     case WM_KEYDOWN:
 890     case WM_KEYUP:
 891       return true;
 892
 893     default:
 894       break;
 895   }
 896
 897   return false;
 898 }
 899
 900 LRESULT CALLBACK WebPluginDelegateImpl::NativeWndProc(
 901     HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
 902   WebPluginDelegateImpl* delegate = reinterpret_cast<WebPluginDelegateImpl*>(
 903       GetProp(hwnd, kWebPluginDelegateProperty));
 904   if (!delegate) {
 905     NOTREACHED();
 906     return 0;
 907   }
 908
 909   if (message == delegate->last_message_ &&
 910       delegate->GetQuirks() & PLUGIN_QUIRK_DONT_CALL_WND_PROC_RECURSIVELY &&
 911       delegate->is_calling_wndproc) {
 912     // Real may go into a state where it recursively dispatches the same event
 913     // when subclassed.  See https://bugzilla.mozilla.org/show_bug.cgi?id=192914
 914     // We only do the recursive check for Real because it's possible and valid
 915     // for a plugin to synchronously dispatch a message to itself such that it
 916     // looks like it's in recursion.
 917     return TRUE;
 918   }
 919
 920   // Flash may flood the message queue with WM_USER+1 message causing 100% CPU
 921   // usage.  See https://bugzilla.mozilla.org/show_bug.cgi?id=132759.  We
 922   // prevent this by throttling the messages.
 923   if (message == WM_USER + 1 &&
 924       delegate->GetQuirks() & PLUGIN_QUIRK_THROTTLE_WM_USER_PLUS_ONE) {
 925     WebPluginDelegateImpl::ThrottleMessage(delegate->plugin_wnd_proc_, hwnd,
 926                                            message, wparam, lparam);
 927     return FALSE;
 928   }
 929
 930   LRESULT result;
 931   uint32 old_message = delegate->last_message_;
 932   delegate->last_message_ = message;
 933
 934   static UINT custom_msg = RegisterWindowMessage(kPaintMessageName);
 935   if (message == custom_msg) {
 936     // Get the invalid rect which is in screen coordinates and convert to
 937     // window coordinates.
 938     gfx::Rect invalid_rect;
 939     invalid_rect.set_x(static_cast<short>(LOWORD(wparam)));
 940     invalid_rect.set_y(static_cast<short>(HIWORD(wparam)));
 941     invalid_rect.set_width(static_cast<short>(LOWORD(lparam)));
 942     invalid_rect.set_height(static_cast<short>(HIWORD(lparam)));
 943
 944     RECT window_rect;
 945     GetWindowRect(hwnd, &window_rect);
 946     invalid_rect.Offset(-window_rect.left, -window_rect.top);
 947
 948     // The plugin window might have non-client area.   If we don't pass in
 949     // RDW_FRAME then the children don't receive WM_NCPAINT messages while
 950     // scrolling, which causes painting problems (http://b/issue?id=923945).
 951     uint32 flags = RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_FRAME;
 952
 953     // If a plugin (like Google Earth or Java) has child windows that are hosted
 954     // in a different process, then RedrawWindow with UPDATENOW will
 955     // synchronously wait for this call to complete.  Some messages are pumped
 956     // but not others, which could lead to a deadlock.  So avoid reentrancy by
 957     // only synchronously calling RedrawWindow once at a time.
 958     if (old_message != custom_msg)
 959       flags |= RDW_UPDATENOW;
 960     RECT rect = invalid_rect.ToRECT();
 961     RedrawWindow(hwnd, &rect, NULL, flags);
 962     result = FALSE;
 963   } else {
 964     delegate->is_calling_wndproc = true;
 965
 966     if (!delegate->user_gesture_message_posted_ &&
 967         IsUserGestureMessage(message)) {
 968       delegate->user_gesture_message_posted_ = true;
 969
 970       delegate->instance()->PushPopupsEnabledState(true);
 971
 972       base::MessageLoop::current()->PostDelayedTask(
 973           FROM_HERE,
 974           base::Bind(&WebPluginDelegateImpl::OnUserGestureEnd,
 975                      delegate->user_gesture_msg_factory_.GetWeakPtr()),
 976           base::TimeDelta::FromMilliseconds(kWindowedPluginPopupTimerMs));
 977     }
 978
 979     HandleCaptureForMessage(hwnd, message);
 980
 981     // Maintain a local/global stack for the g_current_plugin_instance variable
 982     // as this may be a nested invocation.
 983     WebPluginDelegateImpl* last_plugin_instance = g_current_plugin_instance;
 984
 985     g_current_plugin_instance = delegate;
 986
 987     result = CallWindowProc(
 988         delegate->plugin_wnd_proc_, hwnd, message, wparam, lparam);
 989
 990     // The plugin instance may have been destroyed in the CallWindowProc call
 991     // above. This will also destroy the plugin window. Before attempting to
 992     // access the WebPluginDelegateImpl instance we validate if the window is
 993     // still valid.
 994     if (::IsWindow(hwnd))
 995       delegate->is_calling_wndproc = false;
 996
 997     g_current_plugin_instance = last_plugin_instance;
 998
 999     if (message == WM_NCDESTROY) {
1000       RemoveProp(hwnd, kWebPluginDelegateProperty);
1001       ClearThrottleQueueForWindow(hwnd);
1002     }
1003   }
1004   if (::IsWindow(hwnd))
1005     delegate->last_message_ = old_message;
1006   return result;
1007 }
1008
1009 void WebPluginDelegateImpl::WindowlessUpdateGeometry(
1010     const gfx::Rect& window_rect,
1011     const gfx::Rect& clip_rect) {
1012   bool window_rect_changed = (window_rect_ != window_rect);
1013   // Only resend to the instance if the geometry has changed.
1014   if (!window_rect_changed && clip_rect == clip_rect_)
1015     return;
1016
1017   clip_rect_ = clip_rect;
1018   window_rect_ = window_rect;
1019
1020   WindowlessSetWindow();
1021
1022   if (window_rect_changed) {
1023     WINDOWPOS win_pos = {0};
1024     win_pos.x = window_rect_.x();
1025     win_pos.y = window_rect_.y();
1026     win_pos.cx = window_rect_.width();
1027     win_pos.cy = window_rect_.height();
1028
1029     NPEvent pos_changed_event;
1030     pos_changed_event.event = WM_WINDOWPOSCHANGED;
1031     pos_changed_event.wParam = 0;
1032     pos_changed_event.lParam = reinterpret_cast<uintptr_t>(&win_pos);
1033
1034     instance()->NPP_HandleEvent(&pos_changed_event);
1035   }
1036 }
1037
1038 void WebPluginDelegateImpl::WindowlessPaint(HDC hdc,
1039                                             const gfx::Rect& damage_rect) {
1040   DCHECK(hdc);
1041
1042   RECT damage_rect_win;
1043   damage_rect_win.left   = damage_rect.x();  // + window_rect_.x();
1044   damage_rect_win.top    = damage_rect.y();  // + window_rect_.y();
1045   damage_rect_win.right  = damage_rect_win.left + damage_rect.width();
1046   damage_rect_win.bottom = damage_rect_win.top + damage_rect.height();
1047
1048   // Save away the old HDC as this could be a nested invocation.
1049   void* old_dc = window_.window;
1050   window_.window = hdc;
1051
1052   NPEvent paint_event;
1053   paint_event.event = WM_PAINT;
1054   paint_event.wParam = PtrToUlong(hdc);
1055   paint_event.lParam = reinterpret_cast<uintptr_t>(&damage_rect_win);
1056   base::StatsRate plugin_paint("Plugin.Paint");
1057   base::StatsScope<base::StatsRate> scope(plugin_paint);
1058   instance()->NPP_HandleEvent(&paint_event);
1059   window_.window = old_dc;
1060 }
1061
1062 void WebPluginDelegateImpl::WindowlessSetWindow() {
1063   if (!instance())
1064     return;
1065
1066   if (window_rect_.IsEmpty())  // wait for geometry to be set.
1067     return;
1068
1069   DCHECK(instance()->windowless());
1070
1071   window_.clipRect.top = clip_rect_.y();
1072   window_.clipRect.left = clip_rect_.x();
1073   window_.clipRect.bottom = clip_rect_.y() + clip_rect_.height();
1074   window_.clipRect.right = clip_rect_.x() + clip_rect_.width();
1075   window_.height = window_rect_.height();
1076   window_.width = window_rect_.width();
1077   window_.x = window_rect_.x();
1078   window_.y = window_rect_.y();
1079   window_.type = NPWindowTypeDrawable;
1080   DrawableContextEnforcer enforcer(&window_);
1081
1082   NPError err = instance()->NPP_SetWindow(&window_);
1083   DCHECK(err == NPERR_NO_ERROR);
1084 }
1085
1086 bool WebPluginDelegateImpl::PlatformSetPluginHasFocus(bool focused) {
1087   DCHECK(instance()->windowless());
1088
1089   NPEvent focus_event;
1090   focus_event.event = focused ? WM_SETFOCUS : WM_KILLFOCUS;
1091   focus_event.wParam = 0;
1092   focus_event.lParam = 0;
1093
1094   instance()->NPP_HandleEvent(&focus_event);
1095   return true;
1096 }
1097
1098 static bool NPEventFromWebMouseEvent(const WebMouseEvent& event,
1099                                      NPEvent* np_event) {
1100   np_event->lParam = static_cast<uint32>(MAKELPARAM(event.windowX,
1101                                                    event.windowY));
1102   np_event->wParam = 0;
1103
1104   if (event.modifiers & WebInputEvent::ControlKey)
1105     np_event->wParam |= MK_CONTROL;
1106   if (event.modifiers & WebInputEvent::ShiftKey)
1107     np_event->wParam |= MK_SHIFT;
1108   if (event.modifiers & WebInputEvent::LeftButtonDown)
1109     np_event->wParam |= MK_LBUTTON;
1110   if (event.modifiers & WebInputEvent::MiddleButtonDown)
1111     np_event->wParam |= MK_MBUTTON;
1112   if (event.modifiers & WebInputEvent::RightButtonDown)
1113     np_event->wParam |= MK_RBUTTON;
1114
1115   switch (event.type) {
1116     case WebInputEvent::MouseMove:
1117     case WebInputEvent::MouseLeave:
1118     case WebInputEvent::MouseEnter:
1119       np_event->event = WM_MOUSEMOVE;
1120       return true;
1121     case WebInputEvent::MouseDown:
1122       switch (event.button) {
1123         case WebMouseEvent::ButtonLeft:
1124           np_event->event = WM_LBUTTONDOWN;
1125           break;
1126         case WebMouseEvent::ButtonMiddle:
1127           np_event->event = WM_MBUTTONDOWN;
1128           break;
1129         case WebMouseEvent::ButtonRight:
1130           np_event->event = WM_RBUTTONDOWN;
1131           break;
1132       }
1133       return true;
1134     case WebInputEvent::MouseUp:
1135       switch (event.button) {
1136         case WebMouseEvent::ButtonLeft:
1137           np_event->event = WM_LBUTTONUP;
1138           break;
1139         case WebMouseEvent::ButtonMiddle:
1140           np_event->event = WM_MBUTTONUP;
1141           break;
1142         case WebMouseEvent::ButtonRight:
1143           np_event->event = WM_RBUTTONUP;
1144           break;
1145       }
1146       return true;
1147     default:
1148       NOTREACHED();
1149       return false;
1150   }
1151 }
1152
1153 static bool NPEventFromWebKeyboardEvent(const WebKeyboardEvent& event,
1154                                         NPEvent* np_event) {
1155   np_event->wParam = event.windowsKeyCode;
1156
1157   switch (event.type) {
1158     case WebInputEvent::KeyDown:
1159       np_event->event = WM_KEYDOWN;
1160       np_event->lParam = 0;
1161       return true;
1162     case WebInputEvent::Char:
1163       np_event->event = WM_CHAR;
1164       np_event->lParam = 0;
1165       return true;
1166     case WebInputEvent::KeyUp:
1167       np_event->event = WM_KEYUP;
1168       np_event->lParam = 0x8000;
1169       return true;
1170     default:
1171       NOTREACHED();
1172       return false;
1173   }
1174 }
1175
1176 static bool NPEventFromWebInputEvent(const WebInputEvent& event,
1177                                      NPEvent* np_event) {
1178   switch (event.type) {
1179     case WebInputEvent::MouseMove:
1180     case WebInputEvent::MouseLeave:
1181     case WebInputEvent::MouseEnter:
1182     case WebInputEvent::MouseDown:
1183     case WebInputEvent::MouseUp:
1184       if (event.size < sizeof(WebMouseEvent)) {
1185         NOTREACHED();
1186         return false;
1187       }
1188       return NPEventFromWebMouseEvent(
1189           *static_cast<const WebMouseEvent*>(&event), np_event);
1190     case WebInputEvent::KeyDown:
1191     case WebInputEvent::Char:
1192     case WebInputEvent::KeyUp:
1193       if (event.size < sizeof(WebKeyboardEvent)) {
1194         NOTREACHED();
1195         return false;
1196       }
1197       return NPEventFromWebKeyboardEvent(
1198           *static_cast<const WebKeyboardEvent*>(&event), np_event);
1199     default:
1200       return false;
1201   }
1202 }
1203
1204 bool WebPluginDelegateImpl::PlatformHandleInputEvent(
1205     const WebInputEvent& event, WebCursor::CursorInfo* cursor_info) {
1206   DCHECK(cursor_info != NULL);
1207
1208   NPEvent np_event;
1209   if (!NPEventFromWebInputEvent(event, &np_event)) {
1210     return false;
1211   }
1212
1213   // Allow this plug-in to access this IME emulator through IMM32 API while the
1214   // plug-in is processing this event.
1215   if (GetQuirks() & PLUGIN_QUIRK_EMULATE_IME) {
1216     if (!plugin_ime_)
1217       plugin_ime_.reset(new WebPluginIMEWin);
1218   }
1219   WebPluginIMEWin::ScopedLock lock(
1220       event.isKeyboardEventType(event.type) ? plugin_ime_.get() : NULL);
1221
1222   HWND last_focus_window = NULL;
1223
1224   if (ShouldTrackEventForModalLoops(&np_event)) {
1225     // A windowless plugin can enter a modal loop in a NPP_HandleEvent call.
1226     // For e.g. Flash puts up a context menu when we right click on the
1227     // windowless plugin area. We detect this by setting up a message filter
1228     // hook pror to calling NPP_HandleEvent on the plugin and unhook on
1229     // return from NPP_HandleEvent. If the plugin does enter a modal loop
1230     // in that context we unhook on receiving the first notification in
1231     // the message filter hook.
1232     handle_event_message_filter_hook_ =
1233         SetWindowsHookEx(WH_MSGFILTER, HandleEventMessageFilterHook, NULL,
1234                          GetCurrentThreadId());
1235     // To ensure that the plugin receives keyboard events we set focus to the
1236     // dummy window.
1237     // TODO(iyengar) We need a framework in the renderer to identify which
1238     // windowless plugin is under the mouse and to handle this. This would
1239     // also require some changes in RenderWidgetHost to detect this in the
1240     // WM_MOUSEACTIVATE handler and inform the renderer accordingly.
1241     bool valid = GetParent(dummy_window_for_activation_) != GetDesktopWindow();
1242     if (valid) {
1243       last_focus_window = ::SetFocus(dummy_window_for_activation_);
1244     } else {
1245       NOTREACHED() << "Dummy window not parented";
1246     }
1247   }
1248
1249   bool old_task_reentrancy_state =
1250       base::MessageLoop::current()->NestableTasksAllowed();
1251
1252   // Maintain a local/global stack for the g_current_plugin_instance variable
1253   // as this may be a nested invocation.
1254   WebPluginDelegateImpl* last_plugin_instance = g_current_plugin_instance;
1255
1256   g_current_plugin_instance = this;
1257
1258   handle_event_depth_++;
1259
1260   bool popups_enabled = false;
1261
1262   if (IsUserGestureMessage(np_event.event)) {
1263     instance()->PushPopupsEnabledState(true);
1264     popups_enabled = true;
1265   }
1266
1267   bool ret = instance()->NPP_HandleEvent(&np_event) != 0;
1268
1269   if (popups_enabled) {
1270     instance()->PopPopupsEnabledState();
1271   }
1272
1273   // Flash and SilverLight always return false, even when they swallow the
1274   // event.  Flash does this because it passes the event to its window proc,
1275   // which is supposed to return 0 if an event was handled.  There are few
1276   // exceptions, such as IME, where it sometimes returns true.
1277   ret = true;
1278
1279   if (np_event.event == WM_MOUSEMOVE) {
1280     current_windowless_cursor_.InitFromExternalCursor(GetCursor());
1281     // Snag a reference to the current cursor ASAP in case the plugin modified
1282     // it. There is a nasty race condition here with the multiprocess browser
1283     // as someone might be setting the cursor in the main process as well.
1284     current_windowless_cursor_.GetCursorInfo(cursor_info);
1285   }
1286
1287   handle_event_depth_--;
1288
1289   g_current_plugin_instance = last_plugin_instance;
1290
1291   // We could have multiple NPP_HandleEvent calls nested together in case
1292   // the plugin enters a modal loop. Reset the pump messages event when
1293   // the outermost NPP_HandleEvent call unwinds.
1294   if (handle_event_depth_ == 0) {
1295     ResetEvent(handle_event_pump_messages_event_);
1296   }
1297
1298   // If we didn't enter a modal loop, need to unhook the filter.
1299   if (handle_event_message_filter_hook_) {
1300     UnhookWindowsHookEx(handle_event_message_filter_hook_);
1301     handle_event_message_filter_hook_ = NULL;
1302   }
1303
1304   if (::IsWindow(last_focus_window)) {
1305     // Restore the nestable tasks allowed state in the message loop and reset
1306     // the os modal loop state as the plugin returned from the TrackPopupMenu
1307     // API call.
1308     base::MessageLoop::current()->SetNestableTasksAllowed(
1309         old_task_reentrancy_state);
1310     base::MessageLoop::current()->set_os_modal_loop(false);
1311     // The Flash plugin at times sets focus to its hidden top level window
1312     // with class name SWFlash_PlaceholderX. This causes the chrome browser
1313     // window to receive a WM_ACTIVATEAPP message as a top level window from
1314     // another thread is now active. We end up in a state where the chrome
1315     // browser window is not active even though the user clicked on it.
1316     // Our workaround for this is to send over a raw
1317     // WM_LBUTTONDOWN/WM_LBUTTONUP combination to the last focus window, which
1318     // does the trick.
1319     if (dummy_window_for_activation_ != ::GetFocus()) {
1320       INPUT input_info = {0};
1321       input_info.type = INPUT_MOUSE;
1322       input_info.mi.dwFlags = MOUSEEVENTF_LEFTDOWN;
1323       ::SendInput(1, &input_info, sizeof(INPUT));
1324
1325       input_info.type = INPUT_MOUSE;
1326       input_info.mi.dwFlags = MOUSEEVENTF_LEFTUP;
1327       ::SendInput(1, &input_info, sizeof(INPUT));
1328     } else {
1329       ::SetFocus(last_focus_window);
1330     }
1331   }
1332   return ret;
1333 }
1334
1335
1336 void WebPluginDelegateImpl::OnModalLoopEntered() {
1337   DCHECK(handle_event_pump_messages_event_ != NULL);
1338   SetEvent(handle_event_pump_messages_event_);
1339
1340   base::MessageLoop::current()->SetNestableTasksAllowed(true);
1341   base::MessageLoop::current()->set_os_modal_loop(true);
1342
1343   UnhookWindowsHookEx(handle_event_message_filter_hook_);
1344   handle_event_message_filter_hook_ = NULL;
1345 }
1346
1347 bool WebPluginDelegateImpl::ShouldTrackEventForModalLoops(NPEvent* event) {
1348   if (event->event == WM_RBUTTONDOWN)
1349     return true;
1350   return false;
1351 }
1352
1353 void WebPluginDelegateImpl::OnUserGestureEnd() {
1354   user_gesture_message_posted_ = false;
1355   instance()->PopPopupsEnabledState();
1356 }
1357
1358 BOOL WINAPI WebPluginDelegateImpl::TrackPopupMenuPatch(
1359     HMENU menu, unsigned int flags, int x, int y, int reserved,
1360     HWND window, const RECT* rect) {
1361
1362   if (g_current_plugin_instance) {
1363     unsigned long window_process_id = 0;
1364     unsigned long window_thread_id =
1365         GetWindowThreadProcessId(window, &window_process_id);
1366     // TrackPopupMenu fails if the window passed in belongs to a different
1367     // thread.
1368     if (::GetCurrentThreadId() != window_thread_id) {
1369       bool valid =
1370           GetParent(g_current_plugin_instance->dummy_window_for_activation_) !=
1371               GetDesktopWindow();
1372       if (valid) {
1373         window = g_current_plugin_instance->dummy_window_for_activation_;
1374       } else {
1375         NOTREACHED() << "Dummy window not parented";
1376       }
1377     }
1378   }
1379
1380   BOOL result = TrackPopupMenu(menu, flags, x, y, reserved, window, rect);
1381   return result;
1382 }
1383
1384 HCURSOR WINAPI WebPluginDelegateImpl::SetCursorPatch(HCURSOR cursor) {
1385   // The windowless flash plugin periodically calls SetCursor in a wndproc
1386   // instantiated on the plugin thread. This causes annoying cursor flicker
1387   // when the mouse is moved on a foreground tab, with a windowless plugin
1388   // instance in a background tab. We just ignore the call here.
1389   if (!g_current_plugin_instance) {
1390     HCURSOR current_cursor = GetCursor();
1391     if (current_cursor != cursor) {
1392       ::SetCursor(cursor);
1393     }
1394     return current_cursor;
1395   }
1396   return ::SetCursor(cursor);
1397 }
1398
1399 LONG WINAPI WebPluginDelegateImpl::RegEnumKeyExWPatch(
1400     HKEY key, DWORD index, LPWSTR name, LPDWORD name_size, LPDWORD reserved,
1401     LPWSTR class_name, LPDWORD class_size, PFILETIME last_write_time) {
1402   DWORD orig_size = *name_size;
1403   LONG rv = RegEnumKeyExW(key, index, name, name_size, reserved, class_name,
1404                           class_size, last_write_time);
1405   if (rv == ERROR_SUCCESS &&
1406       GetKeyPath(key).find(L"Microsoft\\MediaPlayer\\ShimInclusionList") !=
1407           std::wstring::npos) {
1408     static const wchar_t kChromeExeName[] = L"chrome.exe";
1409     wcsncpy_s(name, orig_size, kChromeExeName, arraysize(kChromeExeName));
1410     *name_size =
1411         std::min(orig_size, static_cast<DWORD>(arraysize(kChromeExeName)));
1412   }
1413
1414   return rv;
1415 }
1416
1417 void WebPluginDelegateImpl::ImeCompositionUpdated(
1418     const base::string16& text,
1419     const std::vector<int>& clauses,
1420     const std::vector<int>& target,
1421     int cursor_position) {
1422   if (!plugin_ime_)
1423     plugin_ime_.reset(new WebPluginIMEWin);
1424
1425   plugin_ime_->CompositionUpdated(text, clauses, target, cursor_position);
1426   plugin_ime_->SendEvents(instance());
1427 }
1428
1429 void WebPluginDelegateImpl::ImeCompositionCompleted(
1430     const base::string16& text) {
1431   if (!plugin_ime_)
1432     plugin_ime_.reset(new WebPluginIMEWin);
1433   plugin_ime_->CompositionCompleted(text);
1434   plugin_ime_->SendEvents(instance());
1435 }
1436
1437 bool WebPluginDelegateImpl::GetIMEStatus(int* input_type,
1438                                          gfx::Rect* caret_rect) {
1439   if (!plugin_ime_)
1440     return false;
1441   return plugin_ime_->GetStatus(input_type, caret_rect);
1442 }
1443
1444 // static
1445 FARPROC WINAPI WebPluginDelegateImpl::GetProcAddressPatch(HMODULE module,
1446                                                           LPCSTR name) {
1447   FARPROC imm_function = WebPluginIMEWin::GetProcAddress(name);
1448   if (imm_function)
1449     return imm_function;
1450   return ::GetProcAddress(module, name);
1451 }
1452
1453 HWND WINAPI WebPluginDelegateImpl::WindowFromPointPatch(POINT point) {
1454   HWND window = WindowFromPoint(point);
1455   if (::ScreenToClient(window, &point)) {
1456     HWND child = ChildWindowFromPoint(window, point);
1457     if (::IsWindow(child) &&
1458         ::GetProp(child, content::kPluginDummyParentProperty))
1459       return child;
1460   }
1461   return window;
1462 }
1463
1464 void WebPluginDelegateImpl::HandleCaptureForMessage(HWND window,
1465                                                     UINT message) {
1466   if (gfx::GetClassName(window) != base::string16(kNativeWindowClassName))
1467     return;
1468
1469   switch (message) {
1470     case WM_LBUTTONDOWN:
1471     case WM_MBUTTONDOWN:
1472     case WM_RBUTTONDOWN:
1473       ::SetCapture(window);
1474       // As per documentation the WM_PARENTNOTIFY message is sent to the parent
1475       // window chain if mouse input is received by the child window. However
1476       // the parent receives the WM_PARENTNOTIFY message only if we doubleclick
1477       // on the window. We send the WM_PARENTNOTIFY message for mouse input
1478       // messages to the parent to indicate that user action is expected.
1479       ::SendMessage(::GetParent(window), WM_PARENTNOTIFY, message, 0);
1480       break;
1481
1482     case WM_LBUTTONUP:
1483     case WM_MBUTTONUP:
1484     case WM_RBUTTONUP:
1485       ::ReleaseCapture();
1486       break;
1487
1488     default:
1489       break;
1490   }
1491 }
1492
1493 }  // namespace content