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

webkit/plugins/npapi/webplugin_ime_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_ime_win.h"
+
+#include <string>
+#include <vector>
+
+#include "app/win/iat_patch_function.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/synchronization/lock.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
+#include "webkit/plugins/npapi/plugin_constants_win.h"
+#include "webkit/plugins/npapi/plugin_instance.h"
+
+#pragma comment(lib, "imm32.lib")
+
+using WebKit::WebInputEvent;
+using WebKit::WebCompositionEvent;
+
+namespace webkit {
+namespace npapi {
+
+// A critical section that prevents two or more plug-ins from accessing a
+// WebPluginIMEWin instance through our patch function.
+base::LazyInstance<base::Lock> g_webplugin_ime_lock(base::LINKER_INITIALIZED);
+
+WebPluginIMEWin* WebPluginIMEWin::instance_ = NULL;
+
+WebPluginIMEWin::WebPluginIMEWin()
+    : cursor_position_(0),
+      delta_start_(0),
+      composing_text_(false),
+      support_ime_messages_(false),
+      status_updated_(false),
+      input_type_(1) {
+}
+
+WebPluginIMEWin::~WebPluginIMEWin() {
+}
+
+void WebPluginIMEWin::Update(const WebInputEvent* event) {
+  if (!WebInputEvent::isCompositionEventType(event->type))
+    return;
+
+  const WebCompositionEvent* e =
+      static_cast<const WebCompositionEvent*>(event);
+
+  NPEvent np_event;
+  if (e->type == WebInputEvent::RawCompositionSet) {
+    // We need to send a WM_IME_STARTCOMPOSITION message when a user starts an
+    // IME composition.
+    if (!composing_text_) {
+      composing_text_ = true;
+      result_text_.clear();
+
+      np_event.event = WM_IME_STARTCOMPOSITION;
+      np_event.wParam = 0;
+      np_event.lParam = 0;
+      events_.push_back(np_event);
+    }
+

[cpu_(ooo_6.6-7.5), 2011/06/10 18:38:06]

I worry that Justin's new UIPI sandbox hardening has broken this.

[jschuh, 2011/06/11 17:31:50]

Yeah, this definitely needs to be tested against the current trunk. With UIPI
now enabled, I'm not sure these IME messages can get through.

[Hironori Bono, 2011/06/13 09:51:09]

Thank you for your comments. This change sends these IME messages to windowless
Flash with NPP_HandleEvent(), i.e. this change does not send these messages with
SendMesssage() or PostMessage(). Even though I have not built Chrome to test
this change, I wonder if UIPI prevents sending these messages via
NPP_HandleEvent().

+    // We can update the following values from a RawCompositionSet event:
+    // GCS_COMPSTR, GCS_COMPATTR, GCSCOMPCLAUSE, GCS_CURSORPOS, and
+    // GCS_DELTASTART. We send a WM_IME_COMPOSITION message to notify the list
+    // of updated values.
+    np_event.event = WM_IME_COMPOSITION;
+    np_event.wParam = 0;
+    np_event.lParam = GCS_COMPSTR | GCS_COMPATTR | GCS_COMPCLAUSE |
+        GCS_CURSORPOS | GCS_DELTASTART;
+    events_.push_back(np_event);
+
+    // Converts the given WebCompositionEvent to the platform-dependent IME
+    // data. (See the comment in the WebPluginCompositionData object above for
+    // the parameters.)
+    composition_text_.assign(e->text, e->textLength);
+
+    // Create the composition clauses returned when a plug-in calls
+    // ImmGetCompositionString() with GCS_COMPCLAUSE.
+    composition_clauses_.clear();
+    const WebKit::WebCompositionUnderline* target = NULL;
+    for (int i = 0; i < e->underlineSize; ++i) {
+      const WebKit::WebCompositionUnderline* underline = &e->underlines[i];
+      composition_clauses_.push_back(underline->startOffset);
+      composition_clauses_.push_back(underline->endOffset);
+      if (underline->thick)
+        target = underline;
+    }
+
+    // Create the composition attributes used by GCS_COMPATTR.
+    if (target) {
+      composition_attributes_.assign(e->textLength, ATTR_CONVERTED);
+      for (unsigned int i = target->startOffset; i < target->endOffset; ++i)
+          composition_attributes_[i] = ATTR_TARGET_CONVERTED;
+    } else {
+      composition_attributes_.assign(e->textLength, ATTR_INPUT);
+    }
+
+    cursor_position_ = e->selectionEnd;
+    delta_start_ = e->selectionEnd;
+  } else if (e->type == WebInputEvent::RawCompositionConfirm) {
+    composing_text_ = false;
+
+    // We can update the following values from a RawCompositionConfirm event:
+    // GCS_RESULTSTR, GCS_RESULTCLAUSE, GCS_CURSORPOS, and GCS_DELTASTART. We
+    // send a WM_IME_COMPOSITION message to notify the list of updated values.
+    np_event.event = WM_IME_COMPOSITION;
+    np_event.wParam = 0;
+    np_event.lParam = GCS_CURSORPOS | GCS_DELTASTART | GCS_RESULTSTR |
+        GCS_RESULTCLAUSE;
+    events_.push_back(np_event);
+
+    // We also send a WM_IME_ENDCOMPOSITION message after the final
+    // WM_IME_COMPOSITION message (i.e. after finishing a composition).
+    np_event.event = WM_IME_ENDCOMPOSITION;
+    np_event.wParam = 0;
+    np_event.lParam = 0;
+    events_.push_back(np_event);
+
+    // If the target plug-in does not seem to support IME messages, we send
+    // each character in IME text with a WM_CHAR message so the plug-in can
+    // insert the IME text.
+    if (!support_ime_messages_) {
+      np_event.event = WM_CHAR;
+      np_event.wParam = 0;
+      np_event.lParam = 0;
+      for (size_t i = 0; i < result_text_.length(); ++i) {
+        np_event.wParam = result_text_[i];
+        events_.push_back(np_event);
+      }
+    }
+
+    // Updated the result text and its clause.
+    result_text_.assign(e->text, e->textLength);
+
+    result_clauses_[0] = 0;
+    result_clauses_[0] = e->textLength;
+
+    cursor_position_ = e->selectionEnd;
+    delta_start_ = e->selectionEnd;
+  } else {
+    NOTREACHED();
+  }
+}
+
+bool WebPluginIMEWin::SendEvents(PluginInstance* instance) {
+  // We allow the patch functions to access this WebPluginIMEWin instance only
+  // while we send IME events to the plug-in.
+  ScopedLock lock(this);
+
+  bool ret = true;
+  for (std::vector<NPEvent>::iterator it = events_.begin();
+       it != events_.end(); ++it) {
+    if (!instance->NPP_HandleEvent(&(*it)))
+      ret = false;
+  }
+
+  events_.clear();
+  return ret;
+}
+
+bool WebPluginIMEWin::GetStatus(int* input_type, gfx::Rect* caret_rect) {
+  bool status_updated = status_updated_;
+  if (status_updated) {
+    *input_type = input_type_;
+    *caret_rect = caret_rect_;
+    status_updated_ = false;
+  }
+  return status_updated;
+}
+
+// static
+bool WebPluginIMEWin::NPEventFromWebCompositionEvent(const WebInputEvent* event,
+                                                     NPEvent* np_event) {
+  switch (event->type) {
+    case WebInputEvent::RawCompositionSet:
+      np_event->event = WM_IME_COMPOSITION;
+      np_event->wParam = 0;
+      np_event->lParam = GCS_COMPSTR | GCS_COMPATTR | GCS_COMPCLAUSE |
+          GCS_CURSORPOS | GCS_DELTASTART;
+      return true;
+    case WebInputEvent::RawCompositionConfirm:
+      np_event->event = WM_IME_COMPOSITION;
+      np_event->wParam = 0;
+      np_event->lParam = GCS_CURSORPOS | GCS_DELTASTART | GCS_RESULTSTR |
+          GCS_RESULTCLAUSE;
+      return true;
+    default:
+      return false;
+  }
+}
+
+// static
+FARPROC WebPluginIMEWin::GetProcAddress(LPCSTR name) {
+  static const struct {
+    const char* name;
+    FARPROC function;
+  } kImm32Functions[] = {
+    { "ImmAssociateContextEx",
+        reinterpret_cast<FARPROC>(ImmAssociateContextEx) },
+    { "ImmGetCompositionStringW",
+        reinterpret_cast<FARPROC>(ImmGetCompositionStringW) },
+    { "ImmGetContext", reinterpret_cast<FARPROC>(ImmGetContext) },
+    { "ImmReleaseContext", reinterpret_cast<FARPROC>(ImmReleaseContext) },
+    { "ImmSetCandidateWindow",
+        reinterpret_cast<FARPROC>(ImmSetCandidateWindow) },
+    { "ImmSetOpenStatus", reinterpret_cast<FARPROC>(ImmSetOpenStatus) },
+  };
+  for (int i = 0; i < arraysize(kImm32Functions); ++i) {
+    if (!lstrcmpiA(name, kImm32Functions[i].name))
+      return kImm32Functions[i].function;
+  }
+  return NULL;
+}
+
+void WebPluginIMEWin::Lock() {
+  g_webplugin_ime_lock.Pointer()->Acquire();
+  instance_ = this;
+}
+
+void WebPluginIMEWin::Unlock() {
+  instance_ = NULL;
+  g_webplugin_ime_lock.Pointer()->Release();
+}
+
+// static
+WebPluginIMEWin* WebPluginIMEWin::GetInstance(HIMC context) {
+  return instance_ && context == reinterpret_cast<HIMC>(instance_) ?
+      instance_ : NULL;
+}
+
+// static
+BOOL WINAPI WebPluginIMEWin::ImmAssociateContextEx(HWND window,
+                                                   HIMC context,
+                                                   DWORD flags) {
+  return TRUE;
+}
+
+// static
+LONG WINAPI WebPluginIMEWin::ImmGetCompositionStringW(HIMC context,
+                                                      DWORD index,
+                                                      LPVOID dst_data,
+                                                      DWORD dst_size) {
+  WebPluginIMEWin* instance = GetInstance(context);
+  if (!instance)
+    return ::ImmGetCompositionStringW(context, index, dst_data, dst_size);
+
+  const void* src_data = NULL;
+  DWORD src_size = 0;
+  switch (index) {
+    case GCS_COMPSTR:
+      src_data = instance->composition_text_.c_str();
+      src_size = instance->composition_text_.length() * sizeof(wchar_t);
+      break;
+
+    case GCS_COMPATTR:
+      src_data = instance->composition_attributes_.c_str();
+      src_size = instance->composition_attributes_.length();
+      break;
+
+    case GCS_COMPCLAUSE:
+      src_data = &instance->composition_clauses_[0];
+      src_size = instance->composition_clauses_.size() * sizeof(uint32);
+      break;
+
+    case GCS_CURSORPOS:
+      return instance->cursor_position_;
+
+    case GCS_DELTASTART:
+      return instance->delta_start_;
+
+    case GCS_RESULTSTR:
+      src_data = instance->result_text_.c_str();
+      src_size = instance->result_text_.length() * sizeof(wchar_t);
+      break;
+
+    case GCS_RESULTCLAUSE:
+      src_data = &instance->result_clauses_[0];
+      src_size = sizeof(instance->result_clauses_);
+      break;
+
+    default:
+      break;
+  }
+  if (!src_data || !src_size)
+    return IMM_ERROR_NODATA;
+
+  if (dst_size >= src_size)
+    memcpy(dst_data, src_data, src_size);
+
+  return src_size;
+}
+
+// static
+HIMC WINAPI WebPluginIMEWin::ImmGetContext(HWND window) {
+  // Call the original ImmGetContext() function if the given window is the one
+  // created in WebPluginDelegateImpl::WindowedCreatePlugin(). (We attached IME
+  // context only with the windows created in this function.) On the other hand,
+  // some windowless plug-ins (such as Flash) call this function with a dummy
+  // window handle. We return our dummy IME context for these plug-ins so they
+  // can use our IME emulator.
+  if (IsWindow(window)) {
+    wchar_t name[128];
+    GetClassName(window, &name[0], arraysize(name));
+    if (!wcscmp(&name[0], kNativeWindowClassName))
+      return ::ImmGetContext(window);
+  }
+
+  WebPluginIMEWin* instance = instance_;
+  if (instance)
+    instance->support_ime_messages_ = true;
+  return reinterpret_cast<HIMC>(instance);
+}
+
+// static
+BOOL WINAPI WebPluginIMEWin::ImmReleaseContext(HWND window, HIMC context) {
+  if (!GetInstance(context))
+    return ::ImmReleaseContext(window, context);
+  return TRUE;
+}
+
+// static
+BOOL WINAPI WebPluginIMEWin::ImmSetCandidateWindow(HIMC context,
+                                                   CANDIDATEFORM* candidate) {
+  WebPluginIMEWin* instance = GetInstance(context);
+  if (!instance)
+    return ::ImmSetCandidateWindow(context, candidate);
+
+  gfx::Rect caret_rect(candidate->rcArea);
+  if ((candidate->dwStyle & CFS_EXCLUDE) &&
+      instance->caret_rect_ != caret_rect) {
+    instance->caret_rect_ = caret_rect;
+    instance->status_updated_ = true;
+  }
+  return TRUE;
+}
+
+// static
+BOOL WINAPI WebPluginIMEWin::ImmSetOpenStatus(HIMC context, BOOL open) {
+  WebPluginIMEWin* instance = GetInstance(context);
+  if (!instance)
+    return ::ImmSetOpenStatus(context, open);
+
+  int input_type = open ? 1 : 0;
+  if (instance->input_type_ != input_type) {
+    instance->input_type_ = input_type;
+    instance->status_updated_ = true;
+  }
+
+  return TRUE;
+}
+
+}  // namespace npapi
+}  // namespace webkit