Maintain key state in the plugin delegate if UIPI is enabled.

webkit/plugins/npapi/webplugin_delegate_impl_win.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 68 matching lines @@
     base::LINKER_INITIALIZED);
 
 // Helper object for patching the SetCursor API.
 base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_set_cursor(
     base::LINKER_INITIALIZED);
 
 // Helper object for patching the RegEnumKeyExW API.
 base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_reg_enum_key_ex_w(
     base::LINKER_INITIALIZED);
 
+// Helper object for patching the GetKeyState API.
+base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_get_key_state(
+    base::LINKER_INITIALIZED);
+
+// Saved key state globals and helper access functions
+SHORT (WINAPI *g_iat_orig_get_key_state)(int vkey);
+size_t g_saved_key_state[256 / sizeof(size_t)];

[jam, 2011/08/09 16:26:18]

I'm not sure I follow why size_t is used here?

[jschuh, 2011/08/09 16:48:04]

No major reason. I figured it made sense to use a machine-word type width. Is
there a better type to use?

[jschuh, 2011/08/09 18:06:45]

Just talked to you but I figured I'd record for reference. I'd intended to write
this as a static bit-array, but I see that I forgot one important detail. I'll
have new patch up shortly.

+
+void SetSavedKeyState(WPARAM vkey) {
+  g_saved_key_state[vkey / sizeof(size_t)] |= 1 << (vkey % sizeof(size_t));
+}
+
+void UnsetSavedKeyState(WPARAM vkey) {
+  g_saved_key_state[vkey / sizeof(size_t)] &= ~(1 << (vkey % sizeof(size_t)));
+}
+
+void ClearSavedKeyState() {
+  ::ZeroMemory(g_saved_key_state, sizeof(g_saved_key_state));
+}
+
+
 // 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 151 matching lines @@
     int code, WPARAM wParam, LPARAM lParam) {
   if (code == HC_ACTION) {
     MOUSEHOOKSTRUCT* hook_struct = reinterpret_cast<MOUSEHOOKSTRUCT*>(lParam);
     if (hook_struct)
       HandleCaptureForMessage(hook_struct->hwnd, wParam);
   }
 
   return CallNextHookEx(NULL, code, wParam, lParam);
 }
 
+// In addition to the key state we maintain, we also mask in the original
+// return value. This is done because it system keys (e.g. tab, enter, shift)
+// and toggles (e.g. capslock) don't ever seem to be blocked.
+SHORT WINAPI WebPluginDelegateImpl::GetKeyStatePatch(int vkey) {
+  if (g_saved_key_state[vkey / sizeof(size_t)] & 1 << (vkey % sizeof(size_t)))
+    return 0x8000 | g_iat_orig_get_key_state(vkey);
+  return g_iat_orig_get_key_state(vkey);
+}
+
 WebPluginDelegateImpl::WebPluginDelegateImpl(
     gfx::PluginWindowHandle containing_view,
     PluginInstance *instance)
     : parent_(containing_view),
       instance_(instance),
       quirks_(0),
       plugin_(NULL),
       windowless_(false),
       windowed_handle_(NULL),
       windowed_did_set_window_(false),
@@ skipping 23 matching lines @@
   if (instance_->mime_type() == "application/x-shockwave-flash" ||
       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;
     if (filename == kBuiltinFlashPlugin)
-      quirks_ |= PLUGIN_QUIRK_REPARENT_IN_BROWSER;
+      quirks_ |= PLUGIN_QUIRK_REPARENT_IN_BROWSER |
+                 PLUGIN_QUIRK_PATCH_GETKEYSTATE;
   } else if (filename == kAcrobatReaderPlugin) {
     // Check for the version number above or equal 9.
     int 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") !=
@@ skipping 120 matching lines @@
       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);
   }
 
+  // Under UIPI the key state does not get forwarded properly to the child
+  // plugin window. So, instead we track the key state manually and intercept
+  // GetKeyState.
+  if ((quirks_ & PLUGIN_QUIRK_PATCH_GETKEYSTATE) &&
+      base::win::GetVersion() >= base::win::VERSION_VISTA &&

[jam, 2011/08/09 16:26:18]

nit: probably you want to do this OS check when you enable the quirk

[jschuh, 2011/08/09 16:48:04]

Done.

+      !g_iat_patch_get_key_state.Pointer()->is_patched()) {
+    g_iat_orig_get_key_state = ::GetKeyState;
+    g_iat_patch_get_key_state.Pointer()->Patch(
+        L"gcswf32.dll", "user32.dll", "GetKeyState",
+        WebPluginDelegateImpl::GetKeyStatePatch);
+  }
+
   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;
@@ skipping 480 matching lines @@
   // 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.
   if (message == WM_USER + 1 &&
       delegate->GetQuirks() & PLUGIN_QUIRK_THROTTLE_WM_USER_PLUS_ONE) {
     WebPluginDelegateImpl::ThrottleMessage(delegate->plugin_wnd_proc_, hwnd,
                                            message, wparam, lparam);
     return FALSE;
   }
 
+  // Track the keystate to work around a UIPI issue.
+  if (delegate->GetQuirks() & PLUGIN_QUIRK_PATCH_GETKEYSTATE) {
+    switch (message) {
+      case WM_KEYDOWN:
+        SetSavedKeyState(wparam);
+        break;
+
+      case WM_KEYUP:
+        UnsetSavedKeyState(wparam);
+        break;
+
+      // Clear out the saved keystate whenever the Flash thread loses focus.
+      case WM_KILLFOCUS:
+      case WM_SETFOCUS:
+        if (::GetCurrentThreadId() != ::GetWindowThreadProcessId(
+            reinterpret_cast<HWND>(wparam), NULL)) {
+          ClearSavedKeyState();
+        }
+        break;
+
+      default:
+        break;
+    }
+  }
+
   LRESULT result;
   uint32 old_message = delegate->last_message_;
   delegate->last_message_ = message;
 
   static UINT custom_msg = RegisterWindowMessage(kPaintMessageName);
   if (message == custom_msg) {
     // Get the invalid rect which is in screen coordinates and convert to
     // window coordinates.
     gfx::Rect invalid_rect;
     invalid_rect.set_x(wparam >> 16);
@@ skipping 478 matching lines @@
       ::ReleaseCapture();
       break;
 
     default:
       break;
   }
 }
 
 }  // namespace npapi
 }  // namespace webkit