ui/base/ime/input_method_chromeos.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/base/ime/input_method_chromeos.h"
   6
   7 #include <algorithm>
   8 #include <cstring>
   9 #include <set>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/bind.h"
  14 #include "base/i18n/char_iterator.h"
  15 #include "base/logging.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "base/sys_info.h"
  19 #include "base/third_party/icu/icu_utf.h"
  20 #include "chromeos/ime/composition_text.h"
  21 #include "chromeos/ime/ime_keyboard.h"
  22 #include "chromeos/ime/input_method_manager.h"
  23 #include "ui/base/ime/text_input_client.h"
  24 #include "ui/events/event.h"
  25 #include "ui/gfx/rect.h"
  26
  27 namespace {
  28 chromeos::IMEEngineHandlerInterface* GetEngine() {
  29   return chromeos::IMEBridge::Get()->GetCurrentEngineHandler();
  30 }
  31 }  // namespace
  32
  33 namespace ui {
  34
  35 // InputMethodChromeOS implementation -----------------------------------------
  36 InputMethodChromeOS::InputMethodChromeOS(
  37     internal::InputMethodDelegate* delegate)
  38     : composing_text_(false),
  39       composition_changed_(false),
  40       current_keyevent_id_(0),
  41       weak_ptr_factory_(this) {
  42   SetDelegate(delegate);
  43   chromeos::IMEBridge::Get()->SetInputContextHandler(this);
  44
  45   UpdateContextFocusState();
  46 }
  47
  48 InputMethodChromeOS::~InputMethodChromeOS() {
  49   AbandonAllPendingKeyEvents();
  50   ConfirmCompositionText();
  51   // We are dead, so we need to ask the client to stop relying on us.
  52   OnInputMethodChanged();
  53
  54   chromeos::IMEBridge::Get()->SetInputContextHandler(NULL);
  55 }
  56
  57 void InputMethodChromeOS::OnFocus() {
  58   InputMethodBase::OnFocus();
  59   OnTextInputTypeChanged(GetTextInputClient());
  60 }
  61
  62 void InputMethodChromeOS::OnBlur() {
  63   ConfirmCompositionText();
  64   InputMethodBase::OnBlur();
  65   OnTextInputTypeChanged(GetTextInputClient());
  66 }
  67
  68 bool InputMethodChromeOS::OnUntranslatedIMEMessage(
  69     const base::NativeEvent& event,
  70     NativeEventResult* result) {
  71   return false;
  72 }
  73
  74 void InputMethodChromeOS::ProcessKeyEventDone(uint32 id,
  75                                               ui::KeyEvent* event,
  76                                               bool is_handled) {
  77   if (pending_key_events_.find(id) == pending_key_events_.end())
  78    return;  // Abandoned key event.
  79
  80   DCHECK(event);
  81   if (event->type() == ET_KEY_PRESSED) {
  82     if (is_handled) {
  83       // IME event has a priority to be handled, so that character composer
  84       // should be reset.
  85       character_composer_.Reset();
  86     } else {
  87       // If IME does not handle key event, passes keyevent to character composer
  88       // to be able to compose complex characters.
  89       is_handled = ExecuteCharacterComposer(*event);
  90     }
  91   }
  92
  93   if (event->type() == ET_KEY_PRESSED || event->type() == ET_KEY_RELEASED)
  94     ProcessKeyEventPostIME(*event, is_handled);
  95
  96   // ProcessKeyEventPostIME may change the |pending_key_events_|.
  97   pending_key_events_.erase(id);
  98 }
  99
 100 bool InputMethodChromeOS::DispatchKeyEvent(const ui::KeyEvent& event) {
 101   DCHECK(event.type() == ET_KEY_PRESSED || event.type() == ET_KEY_RELEASED);
 102   DCHECK(system_toplevel_window_focused());
 103
 104   // For linux_chromeos, the ime keyboard cannot track the caps lock state by
 105   // itself, so need to call SetCapsLockEnabled() method to reflect the caps
 106   // lock state by the key event.
 107   if (!base::SysInfo::IsRunningOnChromeOS()) {
 108     chromeos::input_method::InputMethodManager* manager =
 109         chromeos::input_method::InputMethodManager::Get();
 110     if (manager) {
 111       chromeos::input_method::ImeKeyboard* keyboard = manager->GetImeKeyboard();
 112       if (keyboard && event.type() == ui::ET_KEY_PRESSED) {
 113         bool caps = (event.key_code() == ui::VKEY_CAPITAL)
 114             ? !keyboard->CapsLockIsEnabled()
 115             : (event.flags() & EF_CAPS_LOCK_DOWN);
 116         keyboard->SetCapsLockEnabled(caps);
 117       }
 118     }
 119   }
 120
 121   // If |context_| is not usable, then we can only dispatch the key event as is.
 122   // We only dispatch the key event to input method when the |context_| is an
 123   // normal input field (not a password field).
 124   // Note: We need to send the key event to ibus even if the |context_| is not
 125   // enabled, so that ibus can have a chance to enable the |context_|.
 126   if (!IsInputFieldFocused() || !GetEngine()) {
 127     if (event.type() == ET_KEY_PRESSED) {
 128       if (ExecuteCharacterComposer(event)) {
 129         // Treating as PostIME event if character composer handles key event and
 130         // generates some IME event,
 131         ProcessKeyEventPostIME(event, true);
 132         return true;
 133       }
 134       ProcessUnfilteredKeyPressEvent(event);
 135     } else {
 136       DispatchKeyEventPostIME(event);
 137     }
 138     return true;
 139   }
 140
 141   pending_key_events_.insert(current_keyevent_id_);
 142
 143   ui::KeyEvent* copied_event = new ui::KeyEvent(event);
 144   GetEngine()->ProcessKeyEvent(
 145       event,
 146       base::Bind(&InputMethodChromeOS::ProcessKeyEventDone,
 147                  weak_ptr_factory_.GetWeakPtr(),
 148                  current_keyevent_id_,
 149                  // Pass the ownership of |copied_event|.
 150                  base::Owned(copied_event)));
 151
 152   ++current_keyevent_id_;
 153   return true;
 154 }
 155
 156 void InputMethodChromeOS::OnTextInputTypeChanged(
 157     const TextInputClient* client) {
 158   if (!IsTextInputClientFocused(client))
 159     return;
 160
 161   UpdateContextFocusState();
 162
 163   chromeos::IMEEngineHandlerInterface* engine = GetEngine();
 164   if (engine) {
 165     // When focused input client is not changed, a text input type change should
 166     // cause blur/focus events to engine.
 167     // The focus in to or out from password field should also notify engine.
 168     engine->FocusOut();
 169     chromeos::IMEEngineHandlerInterface::InputContext context(
 170         GetTextInputType(), GetTextInputMode());
 171     engine->FocusIn(context);
 172   }
 173
 174   InputMethodBase::OnTextInputTypeChanged(client);
 175 }
 176
 177 void InputMethodChromeOS::OnCaretBoundsChanged(const TextInputClient* client) {
 178   if (!IsInputFieldFocused() || !IsTextInputClientFocused(client))
 179     return;
 180
 181   // The current text input type should not be NONE if |context_| is focused.
 182   DCHECK(!IsTextInputTypeNone());
 183   const gfx::Rect rect = GetTextInputClient()->GetCaretBounds();
 184
 185   gfx::Rect composition_head;
 186   if (!GetTextInputClient()->GetCompositionCharacterBounds(0,
 187                                                            &composition_head)) {
 188     composition_head = rect;
 189   }
 190
 191   chromeos::IMECandidateWindowHandlerInterface* candidate_window =
 192       chromeos::IMEBridge::Get()->GetCandidateWindowHandler();
 193   if (!candidate_window)
 194     return;
 195   candidate_window->SetCursorBounds(rect, composition_head);
 196
 197   gfx::Range text_range;
 198   gfx::Range selection_range;
 199   base::string16 surrounding_text;
 200   if (!GetTextInputClient()->GetTextRange(&text_range) ||
 201       !GetTextInputClient()->GetTextFromRange(text_range, &surrounding_text) ||
 202       !GetTextInputClient()->GetSelectionRange(&selection_range)) {
 203     previous_surrounding_text_.clear();
 204     previous_selection_range_ = gfx::Range::InvalidRange();
 205     return;
 206   }
 207
 208   if (previous_selection_range_ == selection_range &&
 209       previous_surrounding_text_ == surrounding_text)
 210     return;
 211
 212   previous_selection_range_ = selection_range;
 213   previous_surrounding_text_ = surrounding_text;
 214
 215   if (!selection_range.IsValid()) {
 216     // TODO(nona): Ideally selection_range should not be invalid.
 217     // TODO(nona): If javascript changes the focus on page loading, even (0,0)
 218     //             can not be obtained. Need investigation.
 219     return;
 220   }
 221
 222   // Here SetSurroundingText accepts relative position of |surrounding_text|, so
 223   // we have to convert |selection_range| from node coordinates to
 224   // |surrounding_text| coordinates.
 225   if (!GetEngine())
 226     return;
 227   GetEngine()->SetSurroundingText(base::UTF16ToUTF8(surrounding_text),
 228                                   selection_range.start() - text_range.start(),
 229                                   selection_range.end() - text_range.start());
 230 }
 231
 232 void InputMethodChromeOS::CancelComposition(const TextInputClient* client) {
 233   if (IsInputFieldFocused() && IsTextInputClientFocused(client))
 234     ResetContext();
 235 }
 236
 237 void InputMethodChromeOS::OnInputLocaleChanged() {
 238   // Not supported.
 239 }
 240
 241 std::string InputMethodChromeOS::GetInputLocale() {
 242   // Not supported.
 243   return "";
 244 }
 245
 246 bool InputMethodChromeOS::IsActive() {
 247   return true;
 248 }
 249
 250 bool InputMethodChromeOS::IsCandidatePopupOpen() const {
 251   // TODO(yukishiino): Implement this method.
 252   return false;
 253 }
 254
 255 void InputMethodChromeOS::OnWillChangeFocusedClient(
 256     TextInputClient* focused_before,
 257     TextInputClient* focused) {
 258   ConfirmCompositionText();
 259
 260   if (GetEngine())
 261     GetEngine()->FocusOut();
 262 }
 263
 264 void InputMethodChromeOS::OnDidChangeFocusedClient(
 265     TextInputClient* focused_before,
 266     TextInputClient* focused) {
 267   // Force to update the input type since client's TextInputStateChanged()
 268   // function might not be called if text input types before the client loses
 269   // focus and after it acquires focus again are the same.
 270   UpdateContextFocusState();
 271
 272   if (GetEngine()) {
 273     chromeos::IMEEngineHandlerInterface::InputContext context(
 274         GetTextInputType(), GetTextInputMode());
 275     GetEngine()->FocusIn(context);
 276   }
 277 }
 278
 279 void InputMethodChromeOS::ConfirmCompositionText() {
 280   TextInputClient* client = GetTextInputClient();
 281   if (client && client->HasCompositionText())
 282     client->ConfirmCompositionText();
 283
 284   ResetContext();
 285 }
 286
 287 void InputMethodChromeOS::ResetContext() {
 288   if (!IsInputFieldFocused() || !GetTextInputClient())
 289     return;
 290
 291   DCHECK(system_toplevel_window_focused());
 292
 293   composition_.Clear();
 294   result_text_.clear();
 295   composing_text_ = false;
 296   composition_changed_ = false;
 297
 298   // We need to abandon all pending key events, but as above comment says, there
 299   // is no reliable way to abandon all results generated by these abandoned key
 300   // events.
 301   AbandonAllPendingKeyEvents();
 302
 303   // This function runs asynchronously.
 304   // Note: some input method engines may not support reset method, such as
 305   // ibus-anthy. But as we control all input method engines by ourselves, we can
 306   // make sure that all of the engines we are using support it correctly.
 307   if (GetEngine())
 308     GetEngine()->Reset();
 309
 310   character_composer_.Reset();
 311 }
 312
 313 void InputMethodChromeOS::UpdateContextFocusState() {
 314   ResetContext();
 315   OnInputMethodChanged();
 316
 317   // Propagate the focus event to the candidate window handler which also
 318   // manages the input method mode indicator.
 319   chromeos::IMECandidateWindowHandlerInterface* candidate_window =
 320       chromeos::IMEBridge::Get()->GetCandidateWindowHandler();
 321   if (candidate_window)
 322     candidate_window->FocusStateChanged(IsInputFieldFocused());
 323
 324   chromeos::IMEBridge::Get()->SetCurrentTextInputType(GetTextInputType());
 325
 326   if (!IsTextInputTypeNone())
 327     OnCaretBoundsChanged(GetTextInputClient());
 328 }
 329
 330 void InputMethodChromeOS::ProcessKeyEventPostIME(
 331     const ui::KeyEvent& event,
 332     bool handled) {
 333   TextInputClient* client = GetTextInputClient();
 334   if (!client) {
 335     // As ibus works asynchronously, there is a chance that the focused client
 336     // loses focus before this method gets called.
 337     DispatchKeyEventPostIME(event);
 338     return;
 339   }
 340
 341   if (event.type() == ET_KEY_PRESSED && handled)
 342     ProcessFilteredKeyPressEvent(event);
 343
 344   // In case the focus was changed by the key event. The |context_| should have
 345   // been reset when the focused window changed.
 346   if (client != GetTextInputClient())
 347     return;
 348
 349   if (HasInputMethodResult())
 350     ProcessInputMethodResult(event, handled);
 351
 352   // In case the focus was changed when sending input method results to the
 353   // focused window.
 354   if (client != GetTextInputClient())
 355     return;
 356
 357   if (event.type() == ET_KEY_PRESSED && !handled)
 358     ProcessUnfilteredKeyPressEvent(event);
 359   else if (event.type() == ET_KEY_RELEASED)
 360     DispatchKeyEventPostIME(event);
 361 }
 362
 363 void InputMethodChromeOS::ProcessFilteredKeyPressEvent(
 364     const ui::KeyEvent& event) {
 365   if (NeedInsertChar()) {
 366     DispatchKeyEventPostIME(event);
 367   } else {
 368     const ui::KeyEvent fabricated_event(ET_KEY_PRESSED,
 369                                         VKEY_PROCESSKEY,
 370                                         event.flags());
 371     DispatchKeyEventPostIME(fabricated_event);
 372   }
 373 }
 374
 375 void InputMethodChromeOS::ProcessUnfilteredKeyPressEvent(
 376     const ui::KeyEvent& event) {
 377   const TextInputClient* prev_client = GetTextInputClient();
 378   DispatchKeyEventPostIME(event);
 379
 380   // We shouldn't dispatch the character anymore if the key event dispatch
 381   // caused focus change. For example, in the following scenario,
 382   // 1. visit a web page which has a <textarea>.
 383   // 2. click Omnibox.
 384   // 3. enable Korean IME, press A, then press Tab to move the focus to the web
 385   //    page.
 386   // We should return here not to send the Tab key event to RWHV.
 387   TextInputClient* client = GetTextInputClient();
 388   if (!client || client != prev_client)
 389     return;
 390
 391   // If a key event was not filtered by |context_| and |character_composer_|,
 392   // then it means the key event didn't generate any result text. So we need
 393   // to send corresponding character to the focused text input client.
 394   uint16 ch = event.GetCharacter();
 395   if (ch)
 396     client->InsertChar(ch, event.flags());
 397 }
 398
 399 void InputMethodChromeOS::ProcessInputMethodResult(const ui::KeyEvent& event,
 400                                                bool handled) {
 401   TextInputClient* client = GetTextInputClient();
 402   DCHECK(client);
 403
 404   if (result_text_.length()) {
 405     if (handled && NeedInsertChar()) {
 406       for (base::string16::const_iterator i = result_text_.begin();
 407            i != result_text_.end(); ++i) {
 408         client->InsertChar(*i, event.flags());
 409       }
 410     } else {
 411       client->InsertText(result_text_);
 412       composing_text_ = false;
 413     }
 414   }
 415
 416   if (composition_changed_ && !IsTextInputTypeNone()) {
 417     if (composition_.text.length()) {
 418       composing_text_ = true;
 419       client->SetCompositionText(composition_);
 420     } else if (result_text_.empty()) {
 421       client->ClearCompositionText();
 422     }
 423   }
 424
 425   // We should not clear composition text here, as it may belong to the next
 426   // composition session.
 427   result_text_.clear();
 428   composition_changed_ = false;
 429 }
 430
 431 bool InputMethodChromeOS::NeedInsertChar() const {
 432   return GetTextInputClient() &&
 433       (IsTextInputTypeNone() ||
 434        (!composing_text_ && result_text_.length() == 1));
 435 }
 436
 437 bool InputMethodChromeOS::HasInputMethodResult() const {
 438   return result_text_.length() || composition_changed_;
 439 }
 440
 441 void InputMethodChromeOS::SendFakeProcessKeyEvent(bool pressed) const {
 442   if (!GetTextInputClient())
 443     return;
 444   KeyEvent evt(pressed ? ET_KEY_PRESSED : ET_KEY_RELEASED,
 445                pressed ? VKEY_PROCESSKEY : VKEY_UNKNOWN,
 446                EF_IME_FABRICATED_KEY);
 447   DispatchKeyEventPostIME(evt);
 448 }
 449
 450 void InputMethodChromeOS::AbandonAllPendingKeyEvents() {
 451   pending_key_events_.clear();
 452 }
 453
 454 void InputMethodChromeOS::CommitText(const std::string& text) {
 455   if (text.empty())
 456     return;
 457
 458   // We need to receive input method result even if the text input type is
 459   // TEXT_INPUT_TYPE_NONE, to make sure we can always send correct
 460   // character for each key event to the focused text input client.
 461   if (!GetTextInputClient())
 462     return;
 463
 464   const base::string16 utf16_text = base::UTF8ToUTF16(text);
 465   if (utf16_text.empty())
 466     return;
 467
 468   // Append the text to the buffer, because commit signal might be fired
 469   // multiple times when processing a key event.
 470   result_text_.append(utf16_text);
 471
 472   // If we are not handling key event, do not bother sending text result if the
 473   // focused text input client does not support text input.
 474   if (pending_key_events_.empty() && !IsTextInputTypeNone()) {
 475     SendFakeProcessKeyEvent(true);
 476     GetTextInputClient()->InsertText(utf16_text);
 477     SendFakeProcessKeyEvent(false);
 478     result_text_.clear();
 479   }
 480 }
 481
 482 void InputMethodChromeOS::UpdateCompositionText(
 483     const chromeos::CompositionText& text,
 484     uint32 cursor_pos,
 485     bool visible) {
 486   if (IsTextInputTypeNone())
 487     return;
 488
 489   if (!CanComposeInline()) {
 490     chromeos::IMECandidateWindowHandlerInterface* candidate_window =
 491         chromeos::IMEBridge::Get()->GetCandidateWindowHandler();
 492     if (candidate_window)
 493       candidate_window->UpdatePreeditText(text.text(), cursor_pos, visible);
 494   }
 495
 496   // |visible| argument is very confusing. For example, what's the correct
 497   // behavior when:
 498   // 1. OnUpdatePreeditText() is called with a text and visible == false, then
 499   // 2. OnShowPreeditText() is called afterwards.
 500   //
 501   // If it's only for clearing the current preedit text, then why not just use
 502   // OnHidePreeditText()?
 503   if (!visible) {
 504     HidePreeditText();
 505     return;
 506   }
 507
 508   ExtractCompositionText(text, cursor_pos, &composition_);
 509
 510   composition_changed_ = true;
 511
 512   // In case OnShowPreeditText() is not called.
 513   if (composition_.text.length())
 514     composing_text_ = true;
 515
 516   // If we receive a composition text without pending key event, then we need to
 517   // send it to the focused text input client directly.
 518   if (pending_key_events_.empty()) {
 519     SendFakeProcessKeyEvent(true);
 520     GetTextInputClient()->SetCompositionText(composition_);
 521     SendFakeProcessKeyEvent(false);
 522     composition_changed_ = false;
 523     composition_.Clear();
 524   }
 525 }
 526
 527 void InputMethodChromeOS::HidePreeditText() {
 528   if (composition_.text.empty() || IsTextInputTypeNone())
 529     return;
 530
 531   // Intentionally leaves |composing_text_| unchanged.
 532   composition_changed_ = true;
 533   composition_.Clear();
 534
 535   if (pending_key_events_.empty()) {
 536     TextInputClient* client = GetTextInputClient();
 537     if (client && client->HasCompositionText()) {
 538       SendFakeProcessKeyEvent(true);
 539       client->ClearCompositionText();
 540       SendFakeProcessKeyEvent(false);
 541     }
 542     composition_changed_ = false;
 543   }
 544 }
 545
 546 void InputMethodChromeOS::DeleteSurroundingText(int32 offset, uint32 length) {
 547   if (!composition_.text.empty())
 548     return;  // do nothing if there is ongoing composition.
 549   if (offset < 0 && static_cast<uint32>(-1 * offset) != length)
 550     return;  // only preceding text can be deletable.
 551   if (GetTextInputClient())
 552     GetTextInputClient()->ExtendSelectionAndDelete(length, 0U);
 553 }
 554
 555 bool InputMethodChromeOS::ExecuteCharacterComposer(const ui::KeyEvent& event) {
 556   if (!character_composer_.FilterKeyPress(event))
 557     return false;
 558
 559   // CharacterComposer consumed the key event.  Update the composition text.
 560   chromeos::CompositionText preedit;
 561   preedit.set_text(character_composer_.preedit_string());
 562   UpdateCompositionText(preedit, preedit.text().size(),
 563                         !preedit.text().empty());
 564   std::string commit_text =
 565       base::UTF16ToUTF8(character_composer_.composed_character());
 566   if (!commit_text.empty()) {
 567     CommitText(commit_text);
 568   }
 569   return true;
 570 }
 571
 572 void InputMethodChromeOS::ExtractCompositionText(
 573     const chromeos::CompositionText& text,
 574     uint32 cursor_position,
 575     CompositionText* out_composition) const {
 576   out_composition->Clear();
 577   out_composition->text = text.text();
 578
 579   if (out_composition->text.empty())
 580     return;
 581
 582   // ibus uses character index for cursor position and attribute range, but we
 583   // use char16 offset for them. So we need to do conversion here.
 584   std::vector<size_t> char16_offsets;
 585   size_t length = out_composition->text.length();
 586   base::i18n::UTF16CharIterator char_iterator(&out_composition->text);
 587   do {
 588     char16_offsets.push_back(char_iterator.array_pos());
 589   } while (char_iterator.Advance());
 590
 591   // The text length in Unicode characters.
 592   uint32 char_length = static_cast<uint32>(char16_offsets.size());
 593   // Make sure we can convert the value of |char_length| as well.
 594   char16_offsets.push_back(length);
 595
 596   size_t cursor_offset =
 597       char16_offsets[std::min(char_length, cursor_position)];
 598
 599   out_composition->selection = gfx::Range(cursor_offset);
 600
 601   const std::vector<chromeos::CompositionText::UnderlineAttribute>&
 602       underline_attributes = text.underline_attributes();
 603   if (!underline_attributes.empty()) {
 604     for (size_t i = 0; i < underline_attributes.size(); ++i) {
 605       const uint32 start = underline_attributes[i].start_index;
 606       const uint32 end = underline_attributes[i].end_index;
 607       if (start >= end)
 608         continue;
 609       CompositionUnderline underline(char16_offsets[start],
 610                                      char16_offsets[end],
 611                                      SK_ColorBLACK,
 612                                      false /* thick */,
 613                                      SK_ColorTRANSPARENT);
 614       if (underline_attributes[i].type ==
 615           chromeos::CompositionText::COMPOSITION_TEXT_UNDERLINE_DOUBLE)
 616         underline.thick = true;
 617       else if (underline_attributes[i].type ==
 618                chromeos::CompositionText::COMPOSITION_TEXT_UNDERLINE_ERROR)
 619         underline.color = SK_ColorRED;
 620       out_composition->underlines.push_back(underline);
 621     }
 622   }
 623
 624   DCHECK(text.selection_start() <= text.selection_end());
 625   if (text.selection_start() < text.selection_end()) {
 626     const uint32 start = text.selection_start();
 627     const uint32 end = text.selection_end();
 628     CompositionUnderline underline(char16_offsets[start],
 629                                    char16_offsets[end],
 630                                    SK_ColorBLACK,
 631                                    true /* thick */,
 632                                    SK_ColorTRANSPARENT);
 633     out_composition->underlines.push_back(underline);
 634
 635     // If the cursor is at start or end of this underline, then we treat
 636     // it as the selection range as well, but make sure to set the cursor
 637     // position to the selection end.
 638     if (underline.start_offset == cursor_offset) {
 639       out_composition->selection.set_start(underline.end_offset);
 640       out_composition->selection.set_end(cursor_offset);
 641     } else if (underline.end_offset == cursor_offset) {
 642       out_composition->selection.set_start(underline.start_offset);
 643       out_composition->selection.set_end(cursor_offset);
 644     }
 645   }
 646
 647   // Use a black thin underline by default.
 648   if (out_composition->underlines.empty()) {
 649     out_composition->underlines.push_back(CompositionUnderline(
 650         0, length, SK_ColorBLACK, false /* thick */, SK_ColorTRANSPARENT));
 651   }
 652 }
 653
 654 bool InputMethodChromeOS::IsInputFieldFocused() {
 655   TextInputType type = GetTextInputType();
 656   return (type != TEXT_INPUT_TYPE_NONE) && (type != TEXT_INPUT_TYPE_PASSWORD);
 657 }
 658
 659 }  // namespace ui