Send IME events to windowless plug-ins (Chromium side)

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 14 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/plugins/npapi/default_plugin_shared.h"
 #include "webkit/plugins/npapi/plugin_constants_win.h"
 #include "webkit/plugins/npapi/plugin_group.h"
 #include "webkit/plugins/npapi/plugin_instance.h"
 #include "webkit/plugins/npapi/plugin_lib.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/npapi/plugin_stream_url.h"
 #include "webkit/plugins/npapi/webplugin.h"
+#include "webkit/plugins/npapi/webplugin_ime_win.h"
 
 using WebKit::WebCursorInfo;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
+using WebKit::WebCompositionEvent;
 
 namespace webkit {
 namespace npapi {
 
 namespace {
 
 const wchar_t kWebPluginDelegateProperty[] = L"WebPluginDelegateProperty";
 const wchar_t kPluginNameAtomProperty[] = L"PluginNameAtom";
 const wchar_t kDummyActivationWindowName[] = L"DummyWindowForActivation";
 const wchar_t kPluginFlashThrottle[] = L"FlashThrottle";
@@ skipping 29 matching lines @@
     base::LINKER_INITIALIZED);
 
 // Helper object for patching the SetCursor API.
 base::LazyInstance<app::win::IATPatchFunction> g_iat_patch_set_cursor(
     base::LINKER_INITIALIZED);
 
 // Helper object for patching the RegEnumKeyExW API.
 base::LazyInstance<app::win::IATPatchFunction> g_iat_patch_reg_enum_key_ex_w(
     base::LINKER_INITIALIZED);
 
+// Helper object for patching the GetProcAddress API.
+base::LazyInstance<app::win::IATPatchFunction> g_iat_patch_get_proc_address(
+    base::LINKER_INITIALIZED);
+
 // 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 192 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;
+    quirks_ |= PLUGIN_QUIRK_EMULATE_IME;
   } 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 116 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);
   }
 
+  // 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);
+  }
+
   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 717 matching lines @@
           *static_cast<const WebMouseEvent*>(&event), np_event);
     case WebInputEvent::KeyDown:
     case WebInputEvent::Char:
     case WebInputEvent::KeyUp:
       if (event.size < sizeof(WebKeyboardEvent)) {
         NOTREACHED();
         return false;
       }
       return NPEventFromWebKeyboardEvent(
           *static_cast<const WebKeyboardEvent*>(&event), np_event);
+    case WebInputEvent::RawCompositionSet:
+    case WebInputEvent::RawCompositionConfirm:
+      return WebPluginIMEWin::NPEventFromWebCompositionEvent(&event, np_event);
     default:
       return false;
   }
 }
 
 bool WebPluginDelegateImpl::PlatformHandleInputEvent(
     const WebInputEvent& event, WebCursorInfo* cursor_info) {
   DCHECK(cursor_info != NULL);
 
   NPEvent np_event;
   if (!NPEventFromWebInputEvent(event, &np_event)) {
     return false;
   }
 
+  // Send an IME event to our IME emulator to update its status. (We create an
+  // IME emulator when we receive the first IME event because not all plug-ins
+  // need the emulator.)
+  if (WebInputEvent::isCompositionEventType(event.type)) {
+    if (!plugin_ime_.get())
+      plugin_ime_.reset(new WebPluginIMEWin);
+    plugin_ime_->Update(&event);
+  }
+
   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.
@@ skipping 20 matching lines @@
 
   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;
+  // Send the input event to the plug-in. When the input event is an IME event,
+  // we call WebPluginIMEWin::SendEvent() to send all window messages stored in
+  // the IME emulator to the plug-in. (This function internally uses a mutex to
+  // prevent two or more plug-ins from accessing an IME emulator though its hook
+  // functions at once.) On the other hand, we send non-IME events directly to
+  // the plug-in because the IME emulator allows accessing its data only while
+  // it sends IME mesages.
+  bool ret = true;
+  if (WebInputEvent::isCompositionEventType(event.type) && plugin_ime_.get()) {
+    ret = plugin_ime_->SendEvents(instance());
+  } else {
+    ret = instance()->NPP_HandleEvent(&np_event) != 0;
+  }
 
   if (popups_enabled) {
     instance()->PopPopupsEnabledState();
   }
 
   // Flash and SilverLight always return false, even when they swallow the
   // event.  Flash does this because it passes the event to its window proc,
   // which is supposed to return 0 if an event was handled.  There are few
   // exceptions, such as IME, where it sometimes returns true.
   ret = true;
@@ skipping 126 matching lines @@
           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;
 }
 
+bool WebPluginDelegateImpl::GetIMEStatus(int* input_type,
+                                         gfx::Rect* caret_rect) {
+  if (!plugin_ime_.get())
+    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);
+}
+
 void WebPluginDelegateImpl::HandleCaptureForMessage(HWND window,
                                                     UINT message) {
   if (!WebPluginDelegateImpl::IsPluginDelegateWindow(window))
     return;
 
   switch (message) {
     case WM_LBUTTONDOWN:
     case WM_MBUTTONDOWN:
     case WM_RBUTTONDOWN:
       ::SetCapture(window);
@@ skipping 11 matching lines @@
       ::ReleaseCapture();
       break;
 
     default:
       break;
   }
 }
 
 }  // namespace npapi
 }  // namespace webkit