Revert of Remove a bunch of NPAPI quirks and related support code

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 <stdint.h>
 #include <string.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/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.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/webplugin.h"
+#include "content/child/npapi/webplugin_ime_win.h"
 #include "content/common/cursors/webcursor.h"
 #include "content/common/plugin_constants_win.h"
 #include "content/public/common/content_constants.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/gfx/win/dpi.h"
 #include "ui/gfx/win/hwnd_util.h"
 
 using blink::WebKeyboardEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 
 namespace content {
 
 namespace {
 
+const wchar_t kWebPluginDelegateProperty[] = L"WebPluginDelegateProperty";
+
+// 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
+// this seems to work well enough.
+const int kFlashWMUSERMessageThrottleDelayMs = 5;
+
+// The current instance of the plugin which entered the modal loop.
+WebPluginDelegateImpl* g_current_plugin_instance = NULL;
+
+typedef std::deque<MSG> ThrottleQueue;
+base::LazyInstance<ThrottleQueue> g_throttle_queue = LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<std::map<HWND, WNDPROC> > g_window_handle_proc_map =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Helper object for patching the TrackPopupMenu API.
+base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_track_popup_menu =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Helper object for patching the SetCursor API.
+base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_set_cursor =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Helper object for patching the RegEnumKeyExW API.
+base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_reg_enum_key_ex_w =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Helper object for patching the GetProcAddress API.
+base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_get_proc_address =
+    LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_window_from_point =
+    LAZY_INSTANCE_INITIALIZER;
+
 // http://crbug.com/16114
 // Enforces providing a valid device context in NPWindow, so that NPP_SetWindow
 // is never called with NPNWindoTypeDrawable and NPWindow set to NULL.
 // Doing so allows removing NPP_SetWindow call during painting a windowless
 // plugin, which otherwise could trigger layout change while painting by
 // invoking NPN_Evaluate. Which would cause bad, bad crashes. Bad crashes.
 // TODO(dglazkov): If this approach doesn't produce regressions, move class to
 // webplugin_delegate_impl.h and implement for other platforms.
 class DrawableContextEnforcer {
  public:
@@ skipping 12 matching lines @@
 
     DeleteDC(static_cast<HDC>(window_->window));
     window_->window = NULL;
   }
 
  private:
   NPWindow* window_;
   bool disposable_dc_;
 };
 
+// These are from ntddk.h
+typedef LONG NTSTATUS;
+
+#ifndef STATUS_SUCCESS
+#define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
+#endif
+
+#ifndef STATUS_BUFFER_TOO_SMALL
+#define STATUS_BUFFER_TOO_SMALL ((NTSTATUS)0xC0000023L)
+#endif
+
+typedef enum _KEY_INFORMATION_CLASS {
+  KeyBasicInformation,
+  KeyNodeInformation,
+  KeyFullInformation,
+  KeyNameInformation,
+  KeyCachedInformation,
+  KeyVirtualizationInformation
+} KEY_INFORMATION_CLASS;
+
+typedef struct _KEY_NAME_INFORMATION {
+  ULONG NameLength;
+  WCHAR Name[1];
+} KEY_NAME_INFORMATION, *PKEY_NAME_INFORMATION;
+
+typedef DWORD (__stdcall *ZwQueryKeyType)(
+    HANDLE  key_handle,
+    int key_information_class,
+    PVOID  key_information,
+    ULONG  length,
+    PULONG  result_length);
+
+// Returns a key's full path.
+std::wstring GetKeyPath(HKEY key) {
+  if (key == NULL)
+    return L"";
+
+  HMODULE dll = GetModuleHandle(L"ntdll.dll");
+  if (dll == NULL)
+    return L"";
+
+  ZwQueryKeyType func = reinterpret_cast<ZwQueryKeyType>(
+      ::GetProcAddress(dll, "ZwQueryKey"));
+  if (func == NULL)
+    return L"";
+
+  DWORD size = 0;
+  DWORD result = 0;
+  result = func(key, KeyNameInformation, 0, 0, &size);
+  if (result != static_cast<DWORD>(STATUS_BUFFER_TOO_SMALL))
+    return L"";
+
+  scoped_ptr<char[]> buffer(new char[size]);
+  if (buffer.get() == NULL)
+    return L"";
+
+  result = func(key, KeyNameInformation, buffer.get(), size, &size);
+  if (result != static_cast<DWORD>(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));
+}
+
+uint32_t GetPluginMajorVersion(const WebPluginInfo& plugin_info) {
+  Version plugin_version;
+  WebPluginInfo::CreateVersionFromString(plugin_info.version, &plugin_version);
+
+  uint32_t major_version = 0;
+  if (plugin_version.IsValid())
+    major_version = plugin_version.components()[0];
+
+  return major_version;
+}
+
 }  // namespace
 
+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);
+}
+
 WebPluginDelegateImpl::WebPluginDelegateImpl(WebPlugin* plugin,
                                              PluginInstance* instance)
     : plugin_(plugin),
       instance_(instance),
       quirks_(0),
+      dummy_window_for_activation_(NULL),
+      dummy_window_parent_(NULL),
+      old_dummy_window_proc_(NULL),
+      handle_event_message_filter_hook_(NULL),
+      handle_event_pump_messages_event_(NULL),
       handle_event_depth_(0),
       first_set_window_call_(true),
       plugin_has_focus_(false),
       has_webkit_focus_(false),
       containing_view_has_focus_(true),
       creation_succeeded_(false),
       user_gesture_msg_factory_(this) {
   memset(&window_, 0, sizeof(window_));
+
+  const WebPluginInfo& plugin_info = instance_->plugin_lib()->plugin_info();
+  base::string16 filename =
+      base::ToLowerASCII(plugin_info.path.BaseName().value());
+
+  if (instance_->mime_type() == kFlashPluginSwfMimeType ||
+      filename == kFlashPlugin) {
+    // Flash only requests windowless plugins if we return a Mozilla user
+    // agent.
+    instance_->set_use_mozilla_user_agent();
+    quirks_ |= PLUGIN_QUIRK_THROTTLE_WM_USER_PLUS_ONE;
+    quirks_ |= PLUGIN_QUIRK_PATCH_SETCURSOR;
+    quirks_ |= PLUGIN_QUIRK_ALWAYS_NOTIFY_SUCCESS;
+    quirks_ |= PLUGIN_QUIRK_HANDLE_MOUSE_CAPTURE;
+    quirks_ |= PLUGIN_QUIRK_EMULATE_IME;
+    quirks_ |= PLUGIN_QUIRK_FAKE_WINDOW_FROM_POINT;
+  } else if (filename == kAcrobatReaderPlugin) {
+    // Check for the version number above or equal 9.
+    uint32_t major_version = GetPluginMajorVersion(plugin_info);
+    if (major_version >= 9) {
+      quirks_ |= PLUGIN_QUIRK_DIE_AFTER_UNLOAD;
+      // 9.2 needs this.
+      quirks_ |= PLUGIN_QUIRK_SETWINDOW_TWICE;
+    }
+    quirks_ |= PLUGIN_QUIRK_BLOCK_NONSTANDARD_GETURL_REQUESTS;
+  } else if (plugin_info.name.find(L"Windows Media Player") !=
+             std::wstring::npos) {
+    // Windows Media Player needs two NPP_SetWindow calls.
+    quirks_ |= PLUGIN_QUIRK_SETWINDOW_TWICE;
+
+    // Windowless mode doesn't work in the WMP NPAPI plugin.
+    quirks_ |= PLUGIN_QUIRK_NO_WINDOWLESS;
+
+    // The media player plugin sets its size on the first NPP_SetWindow call
+    // and never updates its size. We should call the underlying NPP_SetWindow
+    // only when we have the correct size.
+    quirks_ |= PLUGIN_QUIRK_IGNORE_FIRST_SETWINDOW_CALL;
+
+    if (filename == kOldWMPPlugin) {
+      // Non-admin users on XP couldn't modify the key to force the new UI.
+      quirks_ |= PLUGIN_QUIRK_PATCH_REGENUMKEYEXW;
+    }
+  } else if (instance_->mime_type() == "audio/x-pn-realaudio-plugin" ||
+             filename == kRealPlayerPlugin) {
+    quirks_ |= PLUGIN_QUIRK_DONT_CALL_WND_PROC_RECURSIVELY;
+  } else if (plugin_info.name.find(L"VLC Multimedia Plugin") !=
+             std::wstring::npos ||
+             plugin_info.name.find(L"VLC Multimedia Plug-in") !=
+             std::wstring::npos) {
+    // VLC hangs on NPP_Destroy if we call NPP_SetWindow with a null window
+    // handle
+    quirks_ |= PLUGIN_QUIRK_DONT_SET_NULL_WINDOW_HANDLE_ON_DESTROY;
+    uint32_t major_version = GetPluginMajorVersion(plugin_info);
+    if (major_version == 0) {
+      // VLC 0.8.6d and 0.8.6e crash if multiple instances are created.
+      quirks_ |= PLUGIN_QUIRK_DONT_ALLOW_MULTIPLE_INSTANCES;
+    }
+  } else if (filename == kSilverlightPlugin) {
+    // Explanation for this quirk can be found in
+    // WebPluginDelegateImpl::Initialize.
+    quirks_ |= PLUGIN_QUIRK_PATCH_SETCURSOR;
+  } else if (plugin_info.name.find(L"DivX Web Player") !=
+             std::wstring::npos) {
+    // The divx plugin sets its size on the first NPP_SetWindow call and never
+    // updates its size. We should call the underlying NPP_SetWindow only when
+    // we have the correct size.
+    quirks_ |= PLUGIN_QUIRK_IGNORE_FIRST_SETWINDOW_CALL;
+  }
 }
 
 WebPluginDelegateImpl::~WebPluginDelegateImpl() {
+  if (::IsWindow(dummy_window_for_activation_)) {
+    WNDPROC current_wnd_proc = reinterpret_cast<WNDPROC>(
+        GetWindowLongPtr(dummy_window_for_activation_, GWLP_WNDPROC));
+    if (current_wnd_proc == DummyWindowProc) {
+      SetWindowLongPtr(dummy_window_for_activation_,
+                       GWLP_WNDPROC,
+                       reinterpret_cast<LONG_PTR>(old_dummy_window_proc_));
+    }
+    ::DestroyWindow(dummy_window_for_activation_);
+  }
+
   DestroyInstance();
+
+  if (handle_event_pump_messages_event_) {
+    CloseHandle(handle_event_pump_messages_event_);
+  }
 }
 
 bool WebPluginDelegateImpl::PlatformInitialize() {
+  CreateDummyWindowForActivation();
+  handle_event_pump_messages_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
+  plugin_->SetWindowlessData(
+      handle_event_pump_messages_event_,
+      reinterpret_cast<gfx::NativeViewId>(dummy_window_for_activation_));
+
+  // Windowless plugins call the WindowFromPoint API and passes the result of
+  // that to the TrackPopupMenu API call as the owner window. This causes the
+  // API to fail as the API expects the window handle to live on the same
+  // thread as the caller. It works in the other browsers as the plugin lives
+  // on the browser thread. Our workaround is to intercept the TrackPopupMenu
+  // API and replace the window handle with the dummy activation window.
+  if (!g_iat_patch_track_popup_menu.Pointer()->is_patched()) {
+    g_iat_patch_track_popup_menu.Pointer()->Patch(
+        GetPluginPath().value().c_str(), "user32.dll", "TrackPopupMenu",
+        WebPluginDelegateImpl::TrackPopupMenuPatch);
+  }
+
+  // Windowless plugins can set cursors by calling the SetCursor API. This
+  // works because the thread inputs of the browser UI thread and the plugin
+  // thread are attached. We intercept the SetCursor API for windowless
+  // plugins and remember the cursor being set. This is shipped over to the
+  // browser in the HandleEvent call, which ensures that the cursor does not
+  // change when a windowless plugin instance changes the cursor
+  // in a background tab.
+  if (!g_iat_patch_set_cursor.Pointer()->is_patched() &&
+      (quirks_ & PLUGIN_QUIRK_PATCH_SETCURSOR)) {
+    g_iat_patch_set_cursor.Pointer()->Patch(
+        GetPluginPath().value().c_str(), "user32.dll", "SetCursor",
+        WebPluginDelegateImpl::SetCursorPatch);
+  }
+
+  // On XP, WMP will use its old UI unless a registry key under HKLM has the
+  // name of the current process.  We do it in the installer for admin users,
+  // for the rest patch this function.
+  if ((quirks_ & PLUGIN_QUIRK_PATCH_REGENUMKEYEXW) &&
+      base::win::GetVersion() == base::win::VERSION_XP &&
+      (base::win::RegKey().Open(HKEY_LOCAL_MACHINE,
+          L"SOFTWARE\\Microsoft\\MediaPlayer\\ShimInclusionList\\chrome.exe",
+          KEY_READ) != ERROR_SUCCESS) &&
+      !g_iat_patch_reg_enum_key_ex_w.Pointer()->is_patched()) {
+    g_iat_patch_reg_enum_key_ex_w.Pointer()->Patch(
+        L"wmpdxm.dll", "advapi32.dll", "RegEnumKeyExW",
+        WebPluginDelegateImpl::RegEnumKeyExWPatch);
+  }
+
+  // Flash retrieves the pointers to IMM32 functions with GetProcAddress() calls
+  // and use them to retrieve IME data. We add a patch to this function so we
+  // can dispatch these IMM32 calls to the WebPluginIMEWin class, which emulates
+  // IMM32 functions for Flash.
+  if (!g_iat_patch_get_proc_address.Pointer()->is_patched() &&
+      (quirks_ & PLUGIN_QUIRK_EMULATE_IME)) {
+    g_iat_patch_get_proc_address.Pointer()->Patch(
+        GetPluginPath().value().c_str(), "kernel32.dll", "GetProcAddress",
+        GetProcAddressPatch);
+  }
+
+  if (!g_iat_patch_window_from_point.Pointer()->is_patched() &&
+      (quirks_ & PLUGIN_QUIRK_FAKE_WINDOW_FROM_POINT)) {
+    g_iat_patch_window_from_point.Pointer()->Patch(
+        GetPluginPath().value().c_str(), "user32.dll", "WindowFromPoint",
+        WebPluginDelegateImpl::WindowFromPointPatch);
+  }
+
   return true;
 }
 
 void WebPluginDelegateImpl::PlatformDestroyInstance() {
+  if (!instance_->plugin_lib())
+    return;
+
+  // Unpatch if this is the last plugin instance.
+  if (instance_->plugin_lib()->instance_count() != 1)
+    return;
+
+  if (g_iat_patch_set_cursor.Pointer()->is_patched())
+    g_iat_patch_set_cursor.Pointer()->Unpatch();
+
+  if (g_iat_patch_track_popup_menu.Pointer()->is_patched())
+    g_iat_patch_track_popup_menu.Pointer()->Unpatch();
+
+  if (g_iat_patch_reg_enum_key_ex_w.Pointer()->is_patched())
+    g_iat_patch_reg_enum_key_ex_w.Pointer()->Unpatch();
+
+  if (g_iat_patch_window_from_point.Pointer()->is_patched())
+    g_iat_patch_window_from_point.Pointer()->Unpatch();
 }
 
 void WebPluginDelegateImpl::Paint(SkCanvas* canvas, const gfx::Rect& rect) {
   if (skia::SupportsPlatformPaint(canvas)) {
     skia::ScopedPlatformPaint scoped_platform_paint(canvas);
     HDC hdc = scoped_platform_paint.GetPlatformSurface();
     WindowlessPaint(hdc, rect);
   }
 }
 
+// Erase all messages in the queue destined for a particular window.
+// When windows are closing, callers should use this function to clear
+// the queue.
+// static
+void WebPluginDelegateImpl::ClearThrottleQueueForWindow(HWND window) {
+  ThrottleQueue* throttle_queue = g_throttle_queue.Pointer();
+
+  ThrottleQueue::iterator it;
+  for (it = throttle_queue->begin(); it != throttle_queue->end(); ) {
+    if (it->hwnd == window) {
+      it = throttle_queue->erase(it);
+    } else {
+      it++;
+    }
+  }
+}
+
+// Delayed callback for processing throttled messages.
+// Throttled messages are aggregated globally across all plugins.
+// static
+void WebPluginDelegateImpl::OnThrottleMessage() {
+  // The current algorithm walks the list and processes the first
+  // message it finds for each plugin.  It is important to service
+  // all active plugins with each pass through the throttle, otherwise
+  // we see video jankiness.  Copy the set to notify before notifying
+  // since we may re-enter OnThrottleMessage from CallWindowProc!
+  ThrottleQueue* throttle_queue = g_throttle_queue.Pointer();
+  ThrottleQueue notify_queue;
+  std::set<HWND> processed;
+
+  ThrottleQueue::iterator it = throttle_queue->begin();
+  while (it != throttle_queue->end()) {
+    const MSG& msg = *it;
+    if (processed.find(msg.hwnd) == processed.end()) {
+      processed.insert(msg.hwnd);
+      notify_queue.push_back(msg);
+      it = throttle_queue->erase(it);
+    } else {
+      it++;
+    }
+  }
+
+  // Due to re-entrancy, we must save our queue state now.  Otherwise, we may
+  // self-post below, and *also* start up another delayed task when the first
+  // entry is pushed onto the queue in ThrottleMessage().
+  bool throttle_queue_was_empty = throttle_queue->empty();
+
+  for (it = notify_queue.begin(); it != notify_queue.end(); ++it) {
+    const MSG& msg = *it;
+    WNDPROC proc = reinterpret_cast<WNDPROC>(msg.time);
+    // It is possible that the window was closed after we queued
+    // this message.  This is a rare event; just verify the window
+    // is alive.  (see also bug 1259488)
+    if (IsWindow(msg.hwnd))
+      CallWindowProc(proc, msg.hwnd, msg.message, msg.wParam, msg.lParam);
+  }
+
+  if (!throttle_queue_was_empty) {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&WebPluginDelegateImpl::OnThrottleMessage),
+        base::TimeDelta::FromMilliseconds(kFlashWMUSERMessageThrottleDelayMs));
+  }
+}
+
+// Schedule a windows message for delivery later.
+// static
+void WebPluginDelegateImpl::ThrottleMessage(WNDPROC proc, HWND hwnd,
+                                            UINT message, WPARAM wParam,
+                                            LPARAM lParam) {
+  MSG msg;
+  // Cast through uintptr_t and then DWORD to make the truncation explicit.
+  msg.time = static_cast<DWORD>(reinterpret_cast<uintptr_t>(proc));
+  msg.hwnd = hwnd;
+  msg.message = message;
+  msg.wParam = wParam;
+  msg.lParam = lParam;
+
+  ThrottleQueue* throttle_queue = g_throttle_queue.Pointer();
+
+  throttle_queue->push_back(msg);
+
+  if (throttle_queue->size() == 1) {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&WebPluginDelegateImpl::OnThrottleMessage),
+        base::TimeDelta::FromMilliseconds(kFlashWMUSERMessageThrottleDelayMs));
+  }
+}
+
+// We go out of our way to find the hidden windows created by Flash for
+// windowless plugins.  We throttle the rate at which they deliver messages
+// so that they will not consume outrageous amounts of CPU.
+// static
+LRESULT CALLBACK WebPluginDelegateImpl::FlashWindowlessWndProc(
+    HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
+  std::map<HWND, WNDPROC>::iterator index =
+      g_window_handle_proc_map.Get().find(hwnd);
+
+  WNDPROC old_proc = (*index).second;
+  DCHECK(old_proc);
+
+  switch (message) {
+    case WM_NCDESTROY: {
+      WebPluginDelegateImpl::ClearThrottleQueueForWindow(hwnd);
+      g_window_handle_proc_map.Get().erase(index);
+      break;
+    }
+    // Flash may flood the message queue with WM_USER+1 message causing 100% CPU
+    // usage.  See https://bugzilla.mozilla.org/show_bug.cgi?id=132759.  We
+    // prevent this by throttling the messages.
+    case WM_USER + 1: {
+      WebPluginDelegateImpl::ThrottleMessage(old_proc, hwnd, message, wparam,
+                                             lparam);
+      return TRUE;
+    }
+
+    default: {
+      break;
+    }
+  }
+  return CallWindowProc(old_proc, hwnd, message, wparam, lparam);
+}
+
+LRESULT CALLBACK WebPluginDelegateImpl::DummyWindowProc(
+    HWND hwnd, UINT message, WPARAM w_param, LPARAM l_param) {
+  WebPluginDelegateImpl* delegate = reinterpret_cast<WebPluginDelegateImpl*>(
+      GetProp(hwnd, kWebPluginDelegateProperty));
+  CHECK(delegate);
+  if (message == WM_WINDOWPOSCHANGING) {
+    // We need to know when the dummy window is parented because windowless
+    // plugins need the parent window for things like menus. There's no message
+    // for a parent being changed, but a WM_WINDOWPOSCHANGING is sent so we
+    // check every time we get it.
+    // For non-aura builds, this never changes since RenderWidgetHostViewWin's
+    // window is constant. For aura builds, this changes every time the tab gets
+    // dragged to a new window.
+    HWND parent = GetParent(hwnd);
+    if (parent != delegate->dummy_window_parent_) {
+      delegate->dummy_window_parent_ = parent;
+
+      // Set the containing window handle as the instance window handle. This is
+      // what Safari does. Not having a valid window handle causes subtle bugs
+      // with plugins which retrieve the window handle and use it for things
+      // like context menus. The window handle can be retrieved via
+      // NPN_GetValue of NPNVnetscapeWindow.
+      delegate->instance_->set_window_handle(parent);
+
+      // The plugin caches the result of NPNVnetscapeWindow when we originally
+      // called NPP_SetWindow, so force it to get the new value.
+      delegate->WindowlessSetWindow();
+    }
+  } else if (message == WM_NCDESTROY) {
+    RemoveProp(hwnd, kWebPluginDelegateProperty);
+  }
+  return CallWindowProc(
+      delegate->old_dummy_window_proc_, hwnd, message, w_param, l_param);
+}
+
+// Callback for enumerating the Flash windows.
+BOOL CALLBACK EnumFlashWindows(HWND window, LPARAM arg) {
+  WNDPROC wnd_proc = reinterpret_cast<WNDPROC>(arg);
+  TCHAR class_name[1024];
+  if (!RealGetWindowClass(window, class_name,
+                          sizeof(class_name)/sizeof(TCHAR))) {
+    LOG(ERROR) << "RealGetWindowClass failure: " << GetLastError();
+    return FALSE;
+  }
+
+  if (wcscmp(class_name, L"SWFlash_PlaceholderX"))
+    return TRUE;
+
+  WNDPROC current_wnd_proc = reinterpret_cast<WNDPROC>(
+        GetWindowLongPtr(window, GWLP_WNDPROC));
+  if (current_wnd_proc != wnd_proc) {
+    WNDPROC old_flash_proc = reinterpret_cast<WNDPROC>(SetWindowLongPtr(
+        window, GWLP_WNDPROC,
+        reinterpret_cast<LONG_PTR>(wnd_proc)));
+    DCHECK(old_flash_proc);
+    g_window_handle_proc_map.Get()[window] = old_flash_proc;
+  }
+
+  return TRUE;
+}
+
+bool WebPluginDelegateImpl::CreateDummyWindowForActivation() {
+  DCHECK(!dummy_window_for_activation_);
+
+  dummy_window_for_activation_ = CreateWindowEx(
+    0,
+    L"Static",
+    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.
+    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();
+  old_dummy_window_proc_ = reinterpret_cast<WNDPROC>(SetWindowLongPtr(
+      dummy_window_for_activation_, GWLP_WNDPROC,
+      reinterpret_cast<LONG_PTR>(DummyWindowProc)));
+
+  // Flash creates background windows which use excessive CPU in our
+  // environment; we wrap these windows and throttle them so that they don't
+  // get out of hand.
+  if (!EnumThreadWindows(::GetCurrentThreadId(), EnumFlashWindows,
+      reinterpret_cast<LPARAM>(
+      &WebPluginDelegateImpl::FlashWindowlessWndProc))) {
+    // Log that this happened.  Flash will still work; it just means the
+    // throttle isn't installed (and Flash will use more CPU).
+    NOTREACHED();
+    LOG(ERROR) << "Failed to wrap all windowless Flash windows";
+  }
+  return true;
+}
+
 // Returns true if the message passed in corresponds to a user gesture.
 static bool IsUserGestureMessage(unsigned int message) {
   switch (message) {
     case WM_LBUTTONDOWN:
     case WM_LBUTTONUP:
     case WM_RBUTTONDOWN:
     case WM_RBUTTONUP:
     case WM_MBUTTONDOWN:
     case WM_MBUTTONUP:
     case WM_KEYDOWN:
@@ skipping 202 matching lines @@
 
 bool WebPluginDelegateImpl::PlatformHandleInputEvent(
     const WebInputEvent& event, WebCursor::CursorInfo* cursor_info) {
   DCHECK(cursor_info != NULL);
 
   NPEvent np_event;
   if (!NPEventFromWebInputEvent(event, &np_event)) {
     return false;
   }
 
+  // Allow this plugin to access this IME emulator through IMM32 API while the
+  // plugin is processing this event.
+  if (GetQuirks() & PLUGIN_QUIRK_EMULATE_IME) {
+    if (!plugin_ime_)
+      plugin_ime_.reset(new WebPluginIMEWin);
+  }
+  WebPluginIMEWin::ScopedLock lock(
+      event.isKeyboardEventType(event.type) ? plugin_ime_.get() : NULL);
+
+  HWND last_focus_window = NULL;
+
+  if (ShouldTrackEventForModalLoops(&np_event)) {
+    // A windowless plugin can enter a modal loop in a NPP_HandleEvent call.
+    // For e.g. Flash puts up a context menu when we right click on the
+    // windowless plugin area. We detect this by setting up a message filter
+    // hook pror to calling NPP_HandleEvent on the plugin and unhook on
+    // return from NPP_HandleEvent. If the plugin does enter a modal loop
+    // in that context we unhook on receiving the first notification in
+    // 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_) != 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();
+
+  // Maintain a local/global stack for the g_current_plugin_instance variable
+  // as this may be a nested invocation.
+  WebPluginDelegateImpl* last_plugin_instance = g_current_plugin_instance;
+
+  g_current_plugin_instance = this;
+
   handle_event_depth_++;
 
   bool popups_enabled = false;
 
   if (IsUserGestureMessage(np_event.event)) {
     instance()->PushPopupsEnabledState(true);
     popups_enabled = true;
   }
 
   bool ret = instance()->NPP_HandleEvent(&np_event) != 0;
@@ skipping 11 matching lines @@
   if (np_event.event == WM_MOUSEMOVE) {
     current_windowless_cursor_.InitFromExternalCursor(GetCursor());
     // Snag a reference to the current cursor ASAP in case the plugin modified
     // it. There is a nasty race condition here with the multiprocess browser
     // as someone might be setting the cursor in the main process as well.
     current_windowless_cursor_.GetCursorInfo(cursor_info);
   }
 
   handle_event_depth_--;
 
+  g_current_plugin_instance = last_plugin_instance;
+
+  // We could have multiple NPP_HandleEvent calls nested together in case
+  // the plugin enters a modal loop. Reset the pump messages event when
+  // the outermost NPP_HandleEvent call unwinds.
+  if (handle_event_depth_ == 0) {
+    ResetEvent(handle_event_pump_messages_event_);
+  }
+
+  // If we didn't enter a modal loop, need to unhook the filter.
+  if (handle_event_message_filter_hook_) {
+    UnhookWindowsHookEx(handle_event_message_filter_hook_);
+    handle_event_message_filter_hook_ = NULL;
+  }
+
+  if (::IsWindow(last_focus_window)) {
+    // Restore the nestable tasks allowed state in the message loop and reset
+    // the os modal loop state as the plugin returned from the TrackPopupMenu
+    // API call.
+    base::MessageLoop::current()->SetNestableTasksAllowed(
+        old_task_reentrancy_state);
+    base::MessageLoop::current()->set_os_modal_loop(false);
+    // The Flash plugin at times sets focus to its hidden top level window
+    // with class name SWFlash_PlaceholderX. This causes the chrome browser
+    // window to receive a WM_ACTIVATEAPP message as a top level window from
+    // another thread is now active. We end up in a state where the chrome
+    // browser window is not active even though the user clicked on it.
+    // Our workaround for this is to send over a raw
+    // WM_LBUTTONDOWN/WM_LBUTTONUP combination to the last focus window, which
+    // does the trick.
+    if (dummy_window_for_activation_ != ::GetFocus()) {
+      INPUT input_info = {0};
+      input_info.type = INPUT_MOUSE;
+      input_info.mi.dwFlags = MOUSEEVENTF_LEFTDOWN;
+      ::SendInput(1, &input_info, sizeof(INPUT));
+
+      input_info.type = INPUT_MOUSE;
+      input_info.mi.dwFlags = MOUSEEVENTF_LEFTUP;
+      ::SendInput(1, &input_info, sizeof(INPUT));
+    } else {
+      ::SetFocus(last_focus_window);
+    }
+  }
   return ret;
 }
 
+
+void WebPluginDelegateImpl::OnModalLoopEntered() {
+  DCHECK(handle_event_pump_messages_event_ != NULL);
+  SetEvent(handle_event_pump_messages_event_);
+
+  base::MessageLoop::current()->SetNestableTasksAllowed(true);
+  base::MessageLoop::current()->set_os_modal_loop(true);
+
+  UnhookWindowsHookEx(handle_event_message_filter_hook_);
+  handle_event_message_filter_hook_ = NULL;
+}
+
+bool WebPluginDelegateImpl::ShouldTrackEventForModalLoops(NPEvent* event) {
+  if (event->event == WM_RBUTTONDOWN)
+    return true;
+  return false;
+}
+
+BOOL WINAPI WebPluginDelegateImpl::TrackPopupMenuPatch(
+    HMENU menu, unsigned int flags, int x, int y, int reserved,
+    HWND window, const RECT* rect) {
+
+  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_) !=
+              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;
+}
+
+HCURSOR WINAPI WebPluginDelegateImpl::SetCursorPatch(HCURSOR cursor) {
+  // The windowless flash plugin periodically calls SetCursor in a wndproc
+  // instantiated on the plugin thread. This causes annoying cursor flicker
+  // when the mouse is moved on a foreground tab, with a windowless plugin
+  // instance in a background tab. We just ignore the call here.
+  if (!g_current_plugin_instance) {
+    HCURSOR current_cursor = GetCursor();
+    if (current_cursor != cursor) {
+      ::SetCursor(cursor);
+    }
+    return current_cursor;
+  }
+  return ::SetCursor(cursor);
+}
+
+LONG WINAPI WebPluginDelegateImpl::RegEnumKeyExWPatch(
+    HKEY key, DWORD index, LPWSTR name, LPDWORD name_size, LPDWORD reserved,
+    LPWSTR class_name, LPDWORD class_size, PFILETIME last_write_time) {
+  DWORD orig_size = *name_size;
+  LONG rv = RegEnumKeyExW(key, index, name, name_size, reserved, class_name,
+                          class_size, last_write_time);
+  if (rv == ERROR_SUCCESS &&
+      GetKeyPath(key).find(L"Microsoft\\MediaPlayer\\ShimInclusionList") !=
+          std::wstring::npos) {
+    static const wchar_t kChromeExeName[] = L"chrome.exe";
+    wcsncpy_s(name, orig_size, kChromeExeName, arraysize(kChromeExeName));
+    *name_size =
+        std::min(orig_size, static_cast<DWORD>(arraysize(kChromeExeName)));
+  }
+
+  return rv;
+}
+
+void WebPluginDelegateImpl::ImeCompositionUpdated(
+    const base::string16& text,
+    const std::vector<int>& clauses,
+    const std::vector<int>& target,
+    int cursor_position) {
+  if (!plugin_ime_)
+    plugin_ime_.reset(new WebPluginIMEWin);
+
+  plugin_ime_->CompositionUpdated(text, clauses, target, cursor_position);
+  plugin_ime_->SendEvents(instance());
+}
+
+void WebPluginDelegateImpl::ImeCompositionCompleted(
+    const base::string16& text) {
+  if (!plugin_ime_)
+    plugin_ime_.reset(new WebPluginIMEWin);
+  plugin_ime_->CompositionCompleted(text);
+  plugin_ime_->SendEvents(instance());
+}
+
+bool WebPluginDelegateImpl::GetIMEStatus(int* input_type,
+                                         gfx::Rect* caret_rect) {
+  if (!plugin_ime_)
+    return false;
+  return plugin_ime_->GetStatus(input_type, caret_rect);
+}
+
+// static
+FARPROC WINAPI WebPluginDelegateImpl::GetProcAddressPatch(HMODULE module,
+                                                          LPCSTR name) {
+  FARPROC imm_function = WebPluginIMEWin::GetProcAddress(name);
+  if (imm_function)
+    return imm_function;
+  return ::GetProcAddress(module, name);
+}
+
+HWND WINAPI WebPluginDelegateImpl::WindowFromPointPatch(POINT point) {
+  HWND window = WindowFromPoint(point);
+  if (::ScreenToClient(window, &point)) {
+    HWND child = ChildWindowFromPoint(window, point);
+    if (::IsWindow(child) &&
+        ::GetProp(child, content::kPluginDummyParentProperty))
+      return child;
+  }
+  return window;
+}
+
 }  // namespace content