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

content/child/npapi/webplugin_ime_win.cc

Index: content/child/npapi/webplugin_ime_win.cc
diff --git a/content/child/npapi/webplugin_ime_win.cc b/content/child/npapi/webplugin_ime_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..752349598028d745d68474830c9ccf62d978b252
--- /dev/null
+++ b/content/child/npapi/webplugin_ime_win.cc
@@ -0,0 +1,314 @@
+// 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_ime_win.h"
+
+#include <stddef.h>
+#include <string.h>
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/synchronization/lock.h"
+#include "content/child/npapi/plugin_instance.h"
+#include "content/common/plugin_constants_win.h"
+
+#pragma comment(lib, "imm32.lib")
+
+namespace content {
+
+// A critical section that prevents two or more plugins from accessing a
+// WebPluginIMEWin instance through our patch function.
+base::LazyInstance<base::Lock>::Leaky
+    g_webplugin_ime_lock = LAZY_INSTANCE_INITIALIZER;
+
+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) {
+  memset(result_clauses_, 0, sizeof(result_clauses_));
+}
+
+WebPluginIMEWin::~WebPluginIMEWin() {
+}
+
+void WebPluginIMEWin::CompositionUpdated(const base::string16& text,
+                                         std::vector<int> clauses,
+                                         std::vector<int> target,
+                                         int cursor_position) {
+  // Send a WM_IME_STARTCOMPOSITION message when a user starts a composition.
+  NPEvent np_event;
+  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);
+  }
+
+  // We can update the following values from this 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 this event to the IMM32 data so we do not have to convert it every
+  // time when a plugin call an IMM32 function.
+  composition_text_ = text;
+
+  // Create the composition clauses returned when a plugin calls
+  // ImmGetCompositionString() with GCS_COMPCLAUSE.
+  composition_clauses_.clear();
+  for (size_t i = 0; i < clauses.size(); ++i)
+    composition_clauses_.push_back(clauses[i]);
+
+  // Create the composition attributes used by GCS_COMPATTR.
+  if (target.size() == 2) {
+    composition_attributes_.assign(text.length(), ATTR_CONVERTED);
+    for (int i = target[0]; i < target[1]; ++i)
+        composition_attributes_[i] = ATTR_TARGET_CONVERTED;
+  } else {
+    composition_attributes_.assign(text.length(), ATTR_INPUT);
+  }
+
+  cursor_position_ = cursor_position;
+  delta_start_ = cursor_position;
+}
+
+void WebPluginIMEWin::CompositionCompleted(const base::string16& text) {
+  composing_text_ = false;
+
+  // We should update the following values when we finish a composition:
+  // GCS_RESULTSTR, GCS_RESULTCLAUSE, GCS_CURSORPOS, and GCS_DELTASTART. We
+  // send a WM_IME_COMPOSITION message to notify the list of updated values.
+  NPEvent np_event;
+  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 plugin does not seem to support IME messages, we send
+  // each character in IME text with a WM_CHAR message so the plugin 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. (Unlike composition clauses, a
+  // result clause consists of only one region.)
+  result_text_ = text;
+
+  result_clauses_[0] = 0;
+  result_clauses_[1] = result_text_.length();
+
+  cursor_position_ = result_clauses_[1];
+  delta_start_ = result_clauses_[1];
+}
+
+bool WebPluginIMEWin::SendEvents(PluginInstance* instance) {
+  // We allow the patch functions to access this WebPluginIMEWin instance only
+  // while we send IME events to the plugin.
+  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) {
+  *input_type = input_type_;
+  *caret_rect = caret_rect_;
+  return true;
+}
+
+// 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 (size_t 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) {
+  WebPluginIMEWin* instance = GetInstance(context);
+  if (!instance)
+    return ::ImmAssociateContextEx(window, context, flags);
+
+  int input_type = !context && !flags;
+  instance->input_type_ = input_type;
+  instance->status_updated_ = true;
+  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_t);
+      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) {
+  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 content