Move some common ime code to ui/base/

chrome/browser/renderer_host/gtk_im_context_wrapper.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 "chrome/browser/renderer_host/gtk_im_context_wrapper.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/third_party/icu/icu_utf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_gtk.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/common/native_web_keyboard_event.h"
 #include "grit/generated_resources.h"
 #include "third_party/skia/include/core/SkColor.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
+#include "ui/base/gtk/gtk_im_context_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/rect.h"
 
 #if !defined(TOOLKIT_VIEWS)
 #include "chrome/browser/ui/gtk/menu_gtk.h"
 #endif
 
 namespace {
 // Copied from third_party/WebKit/Source/WebCore/page/EventHandler.cpp
 //
 // Match key code of composition keydown event on windows.
 // IE sends VK_PROCESSKEY which has value 229;
 //
 // Please refer to following documents for detals:
 // - Virtual-Key Codes
 //   http://msdn.microsoft.com/en-us/library/ms645540(VS.85).aspx
 // - How the IME System Works
 //   http://msdn.microsoft.com/en-us/library/cc194848.aspx
 // - ImmGetVirtualKey Function
 //   http://msdn.microsoft.com/en-us/library/dd318570(VS.85).aspx
 const int kCompositionEventKeyCode = 229;
 }  // namespace
 
+// ui::CompositionUnderline should be identical to
+// WebKit::WebCompositionUnderline, so that we can do reinterpret_cast safely.
+// TODO(suzhe): remove it after migrating all code in chrome to use
+// ui::CompositionUnderline.
+COMPILE_ASSERT(sizeof(ui::CompositionUnderline) ==
+               sizeof(WebKit::WebCompositionUnderline),
+               ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff);
+
 GtkIMContextWrapper::GtkIMContextWrapper(RenderWidgetHostViewGtk* host_view)
     : host_view_(host_view),
       context_(gtk_im_multicontext_new()),
       context_simple_(gtk_im_context_simple_new()),
       is_focused_(false),
       is_composing_text_(false),
       is_enabled_(false),
       is_in_key_event_handler_(false),
-      preedit_selection_start_(0),
-      preedit_selection_end_(0),
-      is_preedit_changed_(false),
+      is_composition_changed_(false),
       suppress_next_commit_(false),
       last_key_code_(0),
       last_key_was_up_(false),
       last_key_filtered_no_result_(false) {
   DCHECK(context_);
   DCHECK(context_simple_);
 
   // context_ and context_simple_ share the same callback handlers.
   // All data come from them are treated equally.
   // context_ is for full input method support.
@@ skipping 37 matching lines @@
 }
 
 void GtkIMContextWrapper::ProcessKeyEvent(GdkEventKey* event) {
   suppress_next_commit_ = false;
 
   // Indicates preedit-changed and commit signal handlers that we are
   // processing a key event.
   is_in_key_event_handler_ = true;
   // Reset this flag so that we can know if preedit is changed after
   // processing this key event.
-  is_preedit_changed_ = false;
+  is_composition_changed_ = false;
   // Clear it so that we can know if something needs committing after
   // processing this key event.
   commit_text_.clear();
 
   // According to Document Object Model (DOM) Level 3 Events Specification
   // Appendix A: Keyboard events and key identifiers
   // http://www.w3.org/TR/DOM-Level-3-Events/keyset.html:
   // The event sequence would be:
   // 1. keydown
   // 2. textInput
@@ skipping 210 matching lines @@
   gtk_im_context_reset(context_simple_);
 
   if (is_focused_) {
     // Some input methods may not honour the reset call. Focusing out/in the
     // |context_| to make sure it gets reset correctly.
     gtk_im_context_focus_out(context_);
     gtk_im_context_focus_in(context_);
   }
 
   is_composing_text_ = false;
-  preedit_text_.clear();
-  preedit_underlines_.clear();
+  composition_.Clear();
   commit_text_.clear();
 
   is_in_key_event_handler_ = false;
 }
 
 bool GtkIMContextWrapper::NeedCommitByForwardingCharEvent() const {
   // If there is no composition text and has only one character to be
   // committed, then the character will be send to webkit as a Char event
   // instead of a confirmed composition text.
   // It should be fine to handle BMP character only, as non-BMP characters
   // can always be committed as confirmed composition text.
   return !is_composing_text_ && commit_text_.length() == 1;
 }
 
 bool GtkIMContextWrapper::HasInputMethodResult() const {
-  return commit_text_.length() || is_preedit_changed_;
+  return commit_text_.length() || is_composition_changed_;
 }
 
 void GtkIMContextWrapper::ProcessFilteredKeyPressEvent(
     NativeWebKeyboardEvent* wke) {
   // If IME has filtered this event, then replace virtual key code with
   // VK_PROCESSKEY. See comment in ProcessKeyEvent() for details.
   // It's only required for keydown events.
   // To emulate windows behavior, when input method is enabled, if the commit
   // text can be emulated by a Char event, then don't do this replacement.
   if (!NeedCommitByForwardingCharEvent()) {
@@ skipping 61 matching lines @@
       host->ImeConfirmComposition(commit_text_);
       // Set this flag to false, as this composition session has been
       // finished.
       is_composing_text_ = false;
     }
   }
 
   // Send preedit text only if it's changed.
   // If a text has been committed, then we don't need to send the empty
   // preedit text again.
-  if (is_preedit_changed_) {
-    if (preedit_text_.length()) {
+  if (is_composition_changed_) {
+    if (composition_.text.length()) {
       // Another composition session has been started.
       is_composing_text_ = true;
-      host->ImeSetComposition(preedit_text_, preedit_underlines_,
-                              preedit_selection_start_, preedit_selection_end_);
+      // TODO(suzhe): convert both renderer_host and renderer to use
+      // ui::CompositionText.
+      const std::vector<WebKit::WebCompositionUnderline>& underlines =
+          reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
+              composition_.underlines);
+      host->ImeSetComposition(composition_.text, underlines,
+                              composition_.selection.start(),
+                              composition_.selection.end());
     } else if (!committed) {
       host->ImeCancelComposition();
     }
   }
 }
 
 void GtkIMContextWrapper::ConfirmComposition() {
   if (!is_enabled_)
     return;
 
@@ skipping 38 matching lines @@
   is_composing_text_ = true;
 }
 
 void GtkIMContextWrapper::HandlePreeditChanged(const gchar* text,
                                                PangoAttrList* attrs,
                                                int cursor_position) {
   // Ignore preedit related signals triggered by CancelComposition() method.
   if (suppress_next_commit_)
     return;
 
-  // Don't set is_preedit_changed_ to false if there is no change, because
+  // Don't set is_composition_changed_ to false if there is no change, because
   // this handler might be called multiple times with the same data.
-  is_preedit_changed_ = true;
-  preedit_text_.clear();
-  preedit_underlines_.clear();
-  preedit_selection_start_ = 0;
-  preedit_selection_end_ = 0;
+  is_composition_changed_ = true;
+  composition_.Clear();
 
-  ExtractCompositionInfo(text, attrs, cursor_position, &preedit_text_,
-                         &preedit_underlines_, &preedit_selection_start_,
-                         &preedit_selection_end_);
+  ui::ExtractCompositionTextFromGtkPreedit(text, attrs, cursor_position,
+                                           &composition_);
+
+  // TODO(suzhe): due to a bug of webkit, we currently can't use selection range
+  // with composition string. See: https://bugs.webkit.org/show_bug.cgi?id=40805
+  composition_.selection = ui::Range(cursor_position);
 
   // In case we are using a buggy input method which doesn't fire
   // "preedit_start" signal.
-  if (preedit_text_.length())
+  if (composition_.text.length())
     is_composing_text_ = true;
 
   // Nothing needs to do, if it's currently in ProcessKeyEvent()
   // handler, which will send preedit text to webkit later.
   // Otherwise, we need send it here if it's been changed.
   if (!is_in_key_event_handler_ && is_composing_text_ &&
       host_view_->GetRenderWidgetHost()) {
     // Workaround http://crbug.com/45478 by sending fake key down/up events.
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::RawKeyDown);
+    // TODO(suzhe): convert both renderer_host and renderer to use
+    // ui::CompositionText.
+    const std::vector<WebKit::WebCompositionUnderline>& underlines =
+        reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
+            composition_.underlines);
     host_view_->GetRenderWidgetHost()->ImeSetComposition(
-        preedit_text_, preedit_underlines_, preedit_selection_start_,
-        preedit_selection_end_);
+        composition_.text, underlines, composition_.selection.start(),
+        composition_.selection.end());
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
   }
 }
 
 void GtkIMContextWrapper::HandlePreeditEnd() {
-  if (preedit_text_.length()) {
+  if (composition_.text.length()) {
     // The composition session has been finished.
-    preedit_text_.clear();
-    preedit_underlines_.clear();
-    is_preedit_changed_ = true;
+    composition_.Clear();
+    is_composition_changed_ = true;
 
     // If there is still a preedit text when firing "preedit-end" signal,
     // we need inform webkit to clear it.
     // It's only necessary when it's not in ProcessKeyEvent ().
     if (!is_in_key_event_handler_ && host_view_->GetRenderWidgetHost())
       host_view_->GetRenderWidgetHost()->ImeCancelComposition();
   }
 
   // Don't set is_composing_text_ to false here, because "preedit_end"
   // signal may be fired before "commit" signal.
@@ skipping 51 matching lines @@
 
 void GtkIMContextWrapper::HandleHostViewRealizeThunk(
     GtkWidget* widget, GtkIMContextWrapper* self) {
   self->HandleHostViewRealize(widget);
 }
 
 void GtkIMContextWrapper::HandleHostViewUnrealizeThunk(
     GtkWidget* widget, GtkIMContextWrapper* self) {
   self->HandleHostViewUnrealize();
 }
-
-void GtkIMContextWrapper::ExtractCompositionInfo(
-      const gchar* utf8_text,
-      PangoAttrList* attrs,
-      int cursor_position,
-      string16* utf16_text,
-      std::vector<WebKit::WebCompositionUnderline>* underlines,
-      int* selection_start,
-      int* selection_end) {
-  *utf16_text = UTF8ToUTF16(utf8_text);
-
-  if (utf16_text->empty())
-    return;
-
-  // Gtk/Pango uses character index for cursor position and byte index for
-  // attribute range, but we use char16 offset for them. So we need to do
-  // conversion here.
-  std::vector<int> char16_offsets;
-  int length = static_cast<int>(utf16_text->length());
-  for (int offset = 0; offset < length; ++offset) {
-    char16_offsets.push_back(offset);
-    if (CBU16_IS_SURROGATE((*utf16_text)[offset]))
-      ++offset;
-  }
-
-  // The text length in Unicode characters.
-  int char_length = static_cast<int>(char16_offsets.size());
-  // Make sure we can convert the value of |char_length| as well.
-  char16_offsets.push_back(length);
-
-  int cursor_offset =
-      char16_offsets[std::max(0, std::min(char_length, cursor_position))];
-
-  // TODO(suzhe): due to a bug of webkit, we currently can't use selection range
-  // with composition string. See: https://bugs.webkit.org/show_bug.cgi?id=40805
-  *selection_start = *selection_end = cursor_offset;
-
-  if (attrs) {
-    int utf8_length = strlen(utf8_text);
-    PangoAttrIterator* iter = pango_attr_list_get_iterator(attrs);
-
-    // We only care about underline and background attributes and convert
-    // background attribute into selection if possible.
-    do {
-      gint start, end;
-      pango_attr_iterator_range(iter, &start, &end);
-
-      start = std::min(start, utf8_length);
-      end = std::min(end, utf8_length);
-      if (start >= end)
-        continue;
-
-      start = g_utf8_pointer_to_offset(utf8_text, utf8_text + start);
-      end = g_utf8_pointer_to_offset(utf8_text, utf8_text + end);
-
-      // Double check, in case |utf8_text| is not a valid utf-8 string.
-      start = std::min(start, char_length);
-      end = std::min(end, char_length);
-      if (start >= end)
-        continue;
-
-      PangoAttribute* background_attr =
-          pango_attr_iterator_get(iter, PANGO_ATTR_BACKGROUND);
-      PangoAttribute* underline_attr =
-          pango_attr_iterator_get(iter, PANGO_ATTR_UNDERLINE);
-
-      if (background_attr || underline_attr) {
-        // Use a black thin underline by default.
-        WebKit::WebCompositionUnderline underline(
-            char16_offsets[start], char16_offsets[end], SK_ColorBLACK, false);
-
-        // Always use thick underline for a range with background color, which
-        // is usually the selection range.
-        if (background_attr)
-          underline.thick = true;
-        if (underline_attr) {
-          int type = reinterpret_cast<PangoAttrInt*>(underline_attr)->value;
-          if (type == PANGO_UNDERLINE_DOUBLE)
-            underline.thick = true;
-          else if (type == PANGO_UNDERLINE_ERROR)
-            underline.color = SK_ColorRED;
-        }
-        underlines->push_back(underline);
-      }
-    } while (pango_attr_iterator_next(iter));
-    pango_attr_iterator_destroy(iter);
-  }
-
-  // Use a black thin underline by default.
-  if (underlines->empty()) {
-    underlines->push_back(
-        WebKit::WebCompositionUnderline(0, length, SK_ColorBLACK, false));
-  }
-}