Simplify handling of BiDi cursor movement

ui/views/controls/textfield/textfield_views_model.cc

 // 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 "ui/views/controls/textfield/textfield_views_model.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 327 matching lines @@
     return true;
   }
   if (HasSelection()) {
     DeleteSelection();
     return true;
   }
   if (GetText().length() > GetCursorPosition()) {
     size_t cursor_position = GetCursorPosition();
     size_t next_grapheme_index = render_text_->IndexOfAdjacentGrapheme(
         cursor_position, gfx::CURSOR_FORWARD);
-    ExecuteAndRecordDelete(cursor_position, next_grapheme_index, true);
+    ExecuteAndRecordDelete(ui::Range(cursor_position, next_grapheme_index),
+                           true);
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::Backspace() {
   if (HasCompositionText()) {
     // No undo/redo for composition text.
     CancelCompositionText();
     return true;
   }
   if (HasSelection()) {
     DeleteSelection();
     return true;
   }
   if (GetCursorPosition() > 0) {
     size_t cursor_position = GetCursorPosition();
-    ExecuteAndRecordDelete(cursor_position, cursor_position - 1, true);
+    ExecuteAndRecordDelete(ui::Range(cursor_position, cursor_position - 1),
+                           true);
     return true;
   }
   return false;
 }
 
 size_t TextfieldViewsModel::GetCursorPosition() const {
-  return render_text_->GetCursorPosition();
+  return render_text_->cursor_position();
 }
 
 void TextfieldViewsModel::MoveCursor(gfx::BreakType break_type,
                                      gfx::VisualCursorDirection direction,
                                      bool select) {
   if (HasCompositionText())
     ConfirmCompositionText();
   render_text_->MoveCursor(break_type, direction, select);
 }
 
-bool TextfieldViewsModel::MoveCursorTo(const gfx::SelectionModel& selection) {
+bool TextfieldViewsModel::MoveCursorTo(const gfx::SelectionModel& model) {
   if (HasCompositionText()) {
     ConfirmCompositionText();
     // ConfirmCompositionText() updates cursor position. Need to reflect it in
     // the SelectionModel parameter of MoveCursorTo().
-    if (render_text_->GetSelectionStart() != selection.selection_end())
-      return render_text_->SelectRange(ui::Range(
-          render_text_->GetSelectionStart(), selection.selection_end()));
-    gfx::SelectionModel sel(selection.selection_end(),
-                            selection.caret_pos(),
-                            selection.caret_placement());
-    return render_text_->MoveCursorTo(sel);
+    ui::Range range(render_text_->selection().start(), model.caret_pos());
+    if (!range.is_empty())
+      return render_text_->SelectRange(range);
+    return render_text_->MoveCursorTo(
+        gfx::SelectionModel(model.caret_pos(), model.caret_affinity()));
   }
-  return render_text_->MoveCursorTo(selection);
+  return render_text_->MoveCursorTo(model);
 }
 
 bool TextfieldViewsModel::MoveCursorTo(const gfx::Point& point, bool select) {
   if (HasCompositionText())
     ConfirmCompositionText();
   return render_text_->MoveCursorTo(point, select);
 }
 
 string16 TextfieldViewsModel::GetSelectedText() const {
-  return GetText().substr(render_text_->MinOfSelection(),
-      (render_text_->MaxOfSelection() - render_text_->MinOfSelection()));
+  return GetText().substr(render_text_->selection().GetMin(),
+                          render_text_->selection().length());
 }
 
 void TextfieldViewsModel::GetSelectedRange(ui::Range* range) const {
-  range->set_start(render_text_->GetSelectionStart());
-  range->set_end(render_text_->GetCursorPosition());
+  *range = render_text_->selection();
 }
 
 void TextfieldViewsModel::SelectRange(const ui::Range& range) {
   if (HasCompositionText())
     ConfirmCompositionText();
   render_text_->SelectRange(range);
 }
 
 void TextfieldViewsModel::GetSelectionModel(gfx::SelectionModel* sel) const {
   *sel = render_text_->selection_model();
@@ skipping 75 matching lines @@
 
 bool TextfieldViewsModel::Cut() {
   if (!HasCompositionText() && HasSelection()) {
     ui::ScopedClipboardWriter(views::ViewsDelegate::views_delegate
         ->GetClipboard()).WriteText(GetSelectedText());
     // A trick to let undo/redo handle cursor correctly.
     // Undoing CUT moves the cursor to the end of the change rather
     // than beginning, unlike Delete/Backspace.
     // TODO(oshima): Change Delete/Backspace to use DeleteSelection,
     // update DeleteEdit and remove this trick.
-    render_text_->SelectRange(ui::Range(render_text_->GetCursorPosition(),
-                                        render_text_->GetSelectionStart()));
+    const ui::Range& selection = render_text_->selection();
+    render_text_->SelectRange(ui::Range(selection.end(), selection.start()));
     DeleteSelection();
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::Copy() {
   if (!HasCompositionText() && HasSelection()) {
     ui::ScopedClipboardWriter(views::ViewsDelegate::views_delegate
         ->GetClipboard()).WriteText(GetSelectedText());
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::Paste() {
   string16 result;
   views::ViewsDelegate::views_delegate->GetClipboard()
       ->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
   if (!result.empty()) {
     InsertTextInternal(result, false);
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::HasSelection() const {
-  return !render_text_->EmptySelection();
+  return !render_text_->selection().is_empty();
 }
 
 void TextfieldViewsModel::DeleteSelection() {
   DCHECK(!HasCompositionText());
   DCHECK(HasSelection());
-  ExecuteAndRecordDelete(render_text_->GetSelectionStart(),
-                         render_text_->GetCursorPosition(), false);
+  ExecuteAndRecordDelete(render_text_->selection(), false);
 }
 
 void TextfieldViewsModel::DeleteSelectionAndInsertTextAt(
     const string16& text, size_t position) {
   if (HasCompositionText())
     CancelCompositionText();
   ExecuteAndRecordReplace(DO_NOT_MERGE,
                           GetCursorPosition(),
                           position + text.length(),
                           text,
@@ skipping 94 matching lines @@
                                               bool mergeable) {
   if (HasCompositionText()) {
     CancelCompositionText();
   } else if (!HasSelection()) {
     size_t cursor = GetCursorPosition();
     const gfx::SelectionModel& model = render_text_->selection_model();
     // When there is no selection, the default is to replace the next grapheme
     // with |text|. So, need to find the index of next grapheme first.
     size_t next =
         render_text_->IndexOfAdjacentGrapheme(cursor, gfx::CURSOR_FORWARD);
-    if (next == model.selection_end())
+    if (next == model.caret_pos())
       render_text_->MoveCursorTo(model);
     else
-      render_text_->SelectRange(ui::Range(next, model.selection_end()));
+      render_text_->SelectRange(ui::Range(next, model.caret_pos()));
   }
   // Edit history is recorded in InsertText.
   InsertTextInternal(text, mergeable);
 }
 
 void TextfieldViewsModel::ClearEditHistory() {
   STLDeleteContainerPointers(edit_history_.begin(),
                              edit_history_.end());
   edit_history_.clear();
   current_edit_ = edit_history_.end();
 }
 
 void TextfieldViewsModel::ClearRedoHistory() {
   if (edit_history_.begin() == edit_history_.end())
     return;
   if (current_edit_ == edit_history_.end()) {
     ClearEditHistory();
     return;
   }
   EditHistory::iterator delete_start = current_edit_;
   delete_start++;
   STLDeleteContainerPointers(delete_start, edit_history_.end());
   edit_history_.erase(delete_start, edit_history_.end());
 }
 
-void TextfieldViewsModel::ExecuteAndRecordDelete(size_t from,
-                                                 size_t to,
+void TextfieldViewsModel::ExecuteAndRecordDelete(ui::Range range,
                                                  bool mergeable) {
-  size_t old_text_start = std::min(from, to);
-  const string16 text = GetText().substr(old_text_start,
-      std::abs(static_cast<long>(from - to)));
-  bool backward = from > to;
+  size_t old_text_start = range.GetMin();
+  const string16 text = GetText().substr(old_text_start, range.length());
+  bool backward = range.is_reversed();
   Edit* edit = new DeleteEdit(mergeable, text, old_text_start, backward);
   bool delete_edit = AddOrMergeEditHistory(edit);
   edit->Redo(this);
   if (delete_edit)
     delete edit;
 }
 
 void TextfieldViewsModel::ExecuteAndRecordReplaceSelection(
     MergeType merge_type, const string16& new_text) {
-  size_t new_text_start = render_text_->MinOfSelection();
+  size_t new_text_start = render_text_->selection().GetMin();
   size_t new_cursor_pos = new_text_start + new_text.length();
   ExecuteAndRecordReplace(merge_type,
                           GetCursorPosition(),
                           new_cursor_pos,
                           new_text,
                           new_text_start);
 }
 
 void TextfieldViewsModel::ExecuteAndRecordReplace(MergeType merge_type,
                                                   size_t old_cursor_pos,
                                                   size_t new_cursor_pos,
                                                   const string16& new_text,
                                                   size_t new_text_start) {
-  size_t old_text_start = render_text_->MinOfSelection();
-  bool backward =
-      render_text_->GetSelectionStart() > render_text_->GetCursorPosition();
+  size_t old_text_start = render_text_->selection().GetMin();
+  bool backward = render_text_->selection().is_reversed();
   Edit* edit = new ReplaceEdit(merge_type,
                                GetSelectedText(),
                                old_cursor_pos,
                                old_text_start,
                                backward,
                                new_cursor_pos,
                                new_text,
                                new_text_start);
   bool delete_edit = AddOrMergeEditHistory(edit);
   edit->Redo(this);
@@ skipping 42 matching lines @@
   if (delete_from != delete_to)
     render_text_->SetText(text.erase(delete_from, delete_to - delete_from));
   if (!new_text.empty())
     render_text_->SetText(text.insert(new_text_insert_at, new_text));
   render_text_->SetCursorPosition(new_cursor_pos);
   // TODO(oshima): mac selects the text that is just undone (but gtk doesn't).
   // This looks fine feature and we may want to do the same.
 }
 
 }  // namespace views