Support IMM32 reconversion on Windows

views/ime/input_method_win.cc

Index: views/ime/input_method_win.cc
diff --git a/views/ime/input_method_win.cc b/views/ime/input_method_win.cc
index 4ab1a187378d389ba70bf8dc6d3131b107afa847..d9c74305ec24c7daa0427bc8ffaf6f21bd3bc268 100644
--- a/views/ime/input_method_win.cc
+++ b/views/ime/input_method_win.cc
@@ -115,6 +115,9 @@ LRESULT InputMethodWin::OnImeMessages(
     case WM_IME_ENDCOMPOSITION:
       result = OnImeEndComposition(message, w_param, l_param, handled);
       break;
+    case WM_IME_REQUEST:
+      result = OnImeRequest(message, w_param, l_param, handled);
+      break;
     case WM_CHAR:
     case WM_SYSCHAR:
       result = OnChar(message, w_param, l_param, handled);
@@ -219,6 +222,29 @@ LRESULT InputMethodWin::OnImeEndComposition(
   return 0;
 }
 
+LRESULT InputMethodWin::OnImeRequest(
+    UINT message, WPARAM wparam, LPARAM lparam, BOOL* handled) {
+  *handled = FALSE;
+
+  // Should not receive WM_IME_REQUEST message, if IME is disabled.
+  const ui::TextInputType type = GetTextInputType();
+  if (type == ui::TEXT_INPUT_TYPE_NONE ||
+      type == ui::TEXT_INPUT_TYPE_PASSWORD) {
+    return 0;
+  }
+
+  switch (wparam) {
+    case IMR_RECONVERTSTRING:
+      *handled = TRUE;
+      return OnReconvertString(reinterpret_cast<RECONVERTSTRING*>(lparam));
+    case IMR_DOCUMENTFEED:
+      *handled = TRUE;
+      return OnDocumentFeed(reinterpret_cast<RECONVERTSTRING*>(lparam));
+    default:
+      return 0;
+  }
+}
+
 LRESULT InputMethodWin::OnChar(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL* handled) {
   *handled = TRUE;
@@ -254,6 +280,107 @@ LRESULT InputMethodWin::OnDeadChar(
   return 0;
 }
 
+LRESULT InputMethodWin::OnDocumentFeed(RECONVERTSTRING *reconv) {
+  TextInputClient* client = GetTextInputClient();
+  if (!client)
+    return 0;
+
+  ui::Range text_range;
+  if (!client->GetTextRange(&text_range) || text_range.is_empty())
+    return 0;
+
+  bool result = false;
+  ui::Range target_range;
+  if (client->HasCompositionText())
+    result = client->GetCompositionTextRange(&target_range);
+
+  if (!result || target_range.is_empty()) {
+    if (!client->GetSelectionRange(&target_range) ||
+        !target_range.IsValid()) {
+      return 0;
+    }
+  }
+
+  if (!text_range.Contains(target_range))
+    return 0;
+
+  size_t len = text_range.length();
+  size_t need_size = sizeof(RECONVERTSTRING) + len * sizeof(WCHAR);
+
+  if (!reconv)
+    return need_size;
+
+  if (reconv->dwSize < need_size)
+    return 0;
+
+  string16 text;
+  if (!GetTextInputClient()->GetTextFromRange(text_range, &text))
+    return 0;
+
+  reconv->dwVersion = 0;
+  reconv->dwStrLen = len;
+  reconv->dwStrOffset = sizeof(RECONVERTSTRING);
+  reconv->dwCompStrLen =
+      client->HasCompositionText() ? target_range.length() : 0;
+  reconv->dwCompStrOffset =
+      (target_range.GetMin() - text_range.start()) * sizeof(WCHAR);
+  reconv->dwTargetStrLen = target_range.length();
+  reconv->dwTargetStrOffset = reconv->dwCompStrOffset;
+
+  memcpy((char*)reconv + sizeof(RECONVERTSTRING),
+      text.c_str(), len * sizeof(WCHAR));
+
+  return reinterpret_cast<LRESULT>(reconv);
+}
+
+LRESULT InputMethodWin::OnReconvertString(RECONVERTSTRING *reconv) {
+  TextInputClient* client = GetTextInputClient();
+  if (!client)
+    return 0;
+
+  // If there is a composition string already, we don't allow reconversion.
+  if (client->HasCompositionText())
+    return 0;
+
+  ui::Range text_range;
+  if (!client->GetTextRange(&text_range) || text_range.is_empty())
+    return 0;
+
+  ui::Range selection_range;
+  if (!client->GetSelectionRange(&selection_range) ||
+      selection_range.is_empty()) {
+    return 0;
+  }
+
+  DCHECK(text_range.Contains(selection_range));
+
+  size_t len = selection_range.length();
+  size_t need_size = sizeof(RECONVERTSTRING) + len * sizeof(WCHAR);

[Peng, 2011/10/27 00:28:00]

I checked document of IMR_RECONVERTSTRING & IMR_DOCUMENTFEED. It is just for IME
requiring a piece of text which application want to reconvert. If IME want to
make it more accurate, the IME could use IMR_DOCUMENTFEED for more content.

[James Su, 2011/10/27 04:56:39]

When doing reconversion, the IME can use the surrounding context provided by
IMR_RECONVERTSTRING to improve the accuracy.
IMR_DOCUMENTFEED is used when the IME wants to improve the accuracy of normal
input, e.g. inserting new text in the middle of existing document.

[Peng, 2011/10/27 16:12:24]

Because we do not implement the logic to allow IME adjust the reconvert range.
And providing extra text to IME can also cause information leaking. So I decide
to just return the text in the selection range right now until we can support
adjusting the reconvert range and figure out the privacy impact.

I am also wondering if I should remove OnDocumentFeed(). I tested with some
IMEs, did not find any IME use this message. But this function may have security
issue.

[James Su, 2011/10/27 18:39:49]

You still don't get the point.
1) This method has nothing to do with the "set reconvert range" thing. They are
independent functionalities.
2) Returning some extra surrounding context along with the selection text can
improve the reconversion accuracy if the input method can make use the
information.
3) I don't think the privacy impact is a big issue, as we already return the
text inside the selection range. Returning a little more text won't make the
situation worse.
It may not be very easy to find out whether an IME uses this feature or not.
Because the IME method will still work without this feature. it'll only affect
the conversion accuracy.
I think this method is nice to have. And the privacy issue should not be a big
deal. As we already support similar feature on Mac.

+
+  if (!reconv)
+    return need_size;
+
+  if (reconv->dwSize < need_size)
+    return 0;
+
+  string16 text;
+  if (!GetTextInputClient()->GetTextFromRange(selection_range, &text))
+    return 0;
+
+  reconv->dwVersion = 0;
+  reconv->dwStrLen = len;
+  reconv->dwStrOffset = sizeof(RECONVERTSTRING);
+  reconv->dwCompStrLen = len;
+  reconv->dwCompStrOffset = 0;
+  reconv->dwTargetStrLen = len;
+  reconv->dwTargetStrOffset = 0;
+
+  memcpy(reinterpret_cast<char*>(reconv) + sizeof(RECONVERTSTRING),
+      text.c_str(), len * sizeof(WCHAR));
+
+  return reinterpret_cast<LRESULT>(reconv);
+}
+
 void InputMethodWin::ConfirmCompositionText() {
   if (!IsTextInputTypeNone()) {
     ime_input_.CleanupComposition(hwnd());