Implement GetTextFromRange(), GetTextRange() and GetSelectionRange() for ArcImeService.

components/arc/ime/arc_ime_service.cc

 // Copyright 2016 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 "components/arc/ime/arc_ime_service.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/arc/ime/arc_ime_bridge_impl.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/surface.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
+#include "ui/gfx/range/range.h"
 
 namespace arc {
 
 namespace {
 
 class ArcWindowDelegateImpl : public ArcImeService::ArcWindowDelegate {
  public:
   explicit ArcWindowDelegateImpl(ArcImeService* ime_service)
     : ime_service_(ime_service) {}
 
@@ skipping 171 matching lines @@
   if (ime_type_ == type)
     return;
   ime_type_ = type;
 
   ui::InputMethod* const input_method = GetInputMethod();
   if (input_method)
     input_method->OnTextInputTypeChanged(this);
 }
 
 void ArcImeService::OnCursorRectChanged(const gfx::Rect& rect) {
+  InvalidateSurroundingTextAndSelectionRange();
   if (cursor_rect_ == rect)
     return;
   cursor_rect_ = rect;
 
   ui::InputMethod* const input_method = GetInputMethod();
   if (input_method)
     input_method->OnCaretBoundsChanged(this);
 }
 
 void ArcImeService::OnCancelComposition() {
+  InvalidateSurroundingTextAndSelectionRange();
   ui::InputMethod* const input_method = GetInputMethod();
   if (input_method)
     input_method->CancelComposition(this);
 }
 
 void ArcImeService::ShowImeIfNeeded() {
   ui::InputMethod* const input_method = GetInputMethod();
   if (input_method && input_method->GetTextInputClient() == this) {
     input_method->ShowImeIfNeeded();
   }
 }
 
+void ArcImeService::OnCursorRectChangedWithSurroundingText(
+    const gfx::Rect& rect,
+    const gfx::Range& text_range,
+    const base::string16& text_in_range,
+    const gfx::Range& selection_range) {
+  text_range_ = text_range;
+  text_in_range_ = text_in_range;
+  selection_range_ = selection_range;
+
+  if (cursor_rect_ == rect)
+    return;
+  cursor_rect_ = rect;
+
+  ui::InputMethod* const input_method = GetInputMethod();
+  if (input_method)
+    input_method->OnCaretBoundsChanged(this);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Overridden from keyboard::KeyboardControllerObserver
 void ArcImeService::OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) {
   if (!focused_arc_window_)
     return;
   aura::Window* window = focused_arc_window_;
   // Multiply by the scale factor. To convert from DPI to physical pixels.
   gfx::Rect bounds_in_px = gfx::ScaleToEnclosingRect(
       new_bounds, window->layer()->device_scale_factor());
   ime_bridge_->SendOnKeyboardBoundsChanging(bounds_in_px);
 }
 
 void ArcImeService::OnKeyboardClosed() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // Overridden from ui::TextInputClient:
 
 void ArcImeService::SetCompositionText(
     const ui::CompositionText& composition) {
+  InvalidateSurroundingTextAndSelectionRange();
   has_composition_text_ = !composition.text.empty();
   ime_bridge_->SendSetCompositionText(composition);
 }
 
 void ArcImeService::ConfirmCompositionText() {
+  InvalidateSurroundingTextAndSelectionRange();
   has_composition_text_ = false;
   ime_bridge_->SendConfirmCompositionText();
 }
 
 void ArcImeService::ClearCompositionText() {
+  InvalidateSurroundingTextAndSelectionRange();
   if (has_composition_text_) {
     has_composition_text_ = false;
     ime_bridge_->SendInsertText(base::string16());
   }
 }
 
 void ArcImeService::InsertText(const base::string16& text) {
+  InvalidateSurroundingTextAndSelectionRange();
   has_composition_text_ = false;
   ime_bridge_->SendInsertText(text);
 }
 
 void ArcImeService::InsertChar(const ui::KeyEvent& event) {
   // According to the document in text_input_client.h, InsertChar() is called
   // even when the text input type is NONE. We ignore such events, since for
   // ARC we are only interested in the event as a method of text input.
   if (ime_type_ == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
+  InvalidateSurroundingTextAndSelectionRange();
+
   // For apps that doesn't handle hardware keyboard events well, keys that are
   // typically on software keyboard and lack of them are fatal, namely,
   // unmodified enter and backspace keys are sent through IME.
   constexpr int kModifierMask = ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
                                 ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN |
                                 ui::EF_ALTGR_DOWN | ui::EF_MOD3_DOWN;
   if ((event.flags() & kModifierMask) == 0) {
     if (event.key_code() ==  ui::VKEY_RETURN) {
       has_composition_text_ = false;
       ime_bridge_->SendInsertText(base::ASCIIToUTF16("\n"));
@@ skipping 39 matching lines @@
 
   // Add the offset of the window showing the ARC app.
   // TODO(yoshiki): Support for non-arc toplevel window. The following code do
   // not work correctly with arc windows inside non-arc toplevel window (eg.
   // notification).
   converted.Offset(
       window->GetToplevelWindow()->GetBoundsInScreen().OffsetFromOrigin());
   return converted;
 }
 
+bool ArcImeService::GetTextRange(gfx::Range* range) const {
+  if (!text_range_.IsValid())
+    return false;
+  *range = text_range_;
+  return true;
+}
+
+bool ArcImeService::GetSelectionRange(gfx::Range* range) const {
+  if (!selection_range_.IsValid())
+    return false;
+  *range = selection_range_;
+  return true;
+}
+
+bool ArcImeService::GetTextFromRange(const gfx::Range& range,
+                                     base::string16* text) const {
+  // It's supposed that this method is called only from
+  // InputMethod::OnCaretBoundsChanged(). In that method, the range obtained
+  // from GetTextRange() is used as the argument of this method. To prevent an
+  // unexpected usage, the check, |range != text_range_|, is added.
+  if (!text_range_.IsValid() || range != text_range_)
+    return false;
+  *text = text_in_range_;
+  return true;
+}
+
 ui::TextInputMode ArcImeService::GetTextInputMode() const {
   return ui::TEXT_INPUT_MODE_DEFAULT;
 }
 
 base::i18n::TextDirection ArcImeService::GetTextDirection() const {
   return base::i18n::UNKNOWN_DIRECTION;
 }
 
 void ArcImeService::ExtendSelectionAndDelete(size_t before, size_t after) {
+  InvalidateSurroundingTextAndSelectionRange();
   ime_bridge_->SendExtendSelectionAndDelete(before, after);
 }
 
 int ArcImeService::GetTextInputFlags() const {
   return ui::TEXT_INPUT_FLAG_NONE;
 }
 
 bool ArcImeService::CanComposeInline() const {
   return true;
 }
 
 bool ArcImeService::GetCompositionCharacterBounds(
     uint32_t index, gfx::Rect* rect) const {
   return false;
 }
 
 bool ArcImeService::HasCompositionText() const {
   return has_composition_text_;
 }
 
-bool ArcImeService::GetTextRange(gfx::Range* range) const {
-  return false;
-}
-
 bool ArcImeService::GetCompositionTextRange(gfx::Range* range) const {
   return false;
 }
 
-bool ArcImeService::GetSelectionRange(gfx::Range* range) const {
-  return false;
-}
-
 bool ArcImeService::SetSelectionRange(const gfx::Range& range) {
   return false;
 }
 
 bool ArcImeService::DeleteRange(const gfx::Range& range) {
   return false;
 }
 
-bool ArcImeService::GetTextFromRange(
-    const gfx::Range& range, base::string16* text) const {
-  return false;
-}
-
 bool ArcImeService::ChangeTextDirectionAndLayoutAlignment(
     base::i18n::TextDirection direction) {
   return false;
 }
 
 bool ArcImeService::IsTextEditCommandEnabled(
     ui::TextEditCommand command) const {
   return false;
 }
 
+void ArcImeService::InvalidateSurroundingTextAndSelectionRange() {
+  text_range_ = gfx::Range::InvalidRange();
+  text_in_range_ = base::string16();
+  selection_range_ = gfx::Range::InvalidRange();
+}
+
 }  // namespace arc