Clean up of SelectionModel

views/controls/textfield/textfield_views_model.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 "views/controls/textfield/textfield_views_model.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 372 matching lines @@
   if (HasCompositionText())
     ConfirmCompositionText();
   render_text_->MoveCursorRight(break_type, select);
 }
 
 bool TextfieldViewsModel::MoveCursorTo(const gfx::SelectionModel& selection) {
   if (HasCompositionText()) {
     ConfirmCompositionText();
     // ConfirmCompositionText() updates cursor position. Need to reflect it in
     // the SelectionModel parameter of MoveCursorTo().
-    gfx::SelectionModel sel(selection);
-    sel.set_selection_start(render_text_->GetSelectionStart());
+    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);
   }
   return render_text_->MoveCursorTo(selection);
 }
 
 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()));
 }
 
+void TextfieldViewsModel::GetSelectedRange(ui::Range* range) const {
+  range->set_start(render_text_->GetSelectionStart());
+  range->set_end(render_text_->GetCursorPosition());
+}
+
+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();
 }
 
 void TextfieldViewsModel::SelectSelectionModel(const gfx::SelectionModel& sel) {
   if (HasCompositionText())
     ConfirmCompositionText();
   render_text_->MoveCursorTo(sel);
 }
 
@@ skipping 71 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.
-    gfx::SelectionModel sel(render_text_->GetCursorPosition(),
-                            render_text_->GetSelectionStart(),
-                            render_text_->GetSelectionStart(),
-                            gfx::SelectionModel::LEADING);
-    render_text_->MoveCursorTo(sel);
+    render_text_->SelectRange(ui::Range(render_text_->GetCursorPosition(),
+                                        render_text_->GetSelectionStart()));
     DeleteSelection();
     return true;
   }
   return false;
 }
 
 void TextfieldViewsModel::Copy() {
   if (!HasCompositionText() && HasSelection()) {
     ui::ScopedClipboardWriter(views::ViewsDelegate::views_delegate
         ->GetClipboard()).WriteText(GetSelectedText());
@@ skipping 58 matching lines @@
   render_text_->SetText(new_text.insert(cursor, composition.text));
   ui::Range range(cursor, cursor + composition.text.length());
   render_text_->SetCompositionRange(range);
   // TODO(msw): Support multiple composition underline ranges.
 
   if (composition.selection.IsValid()) {
     size_t start =
         std::min(range.start() + composition.selection.start(), range.end());
     size_t end =
         std::min(range.start() + composition.selection.end(), range.end());
-    gfx::SelectionModel sel(start, end);
-    render_text_->MoveCursorTo(sel);
+    render_text_->SelectRange(ui::Range(start, end));
   } else {
     render_text_->SetCursorPosition(range.end());
   }
 }
 
 void TextfieldViewsModel::ConfirmCompositionText() {
   DCHECK(HasCompositionText());
   ui::Range range = render_text_->GetCompositionRange();
   string16 text = GetText().substr(range.start(), range.length());
   // TODO(oshima): current behavior on ChromeOS is a bit weird and not
@@ skipping 50 matching lines @@
     ExecuteAndRecordInsert(text, mergeable);
   }
 }
 
 void TextfieldViewsModel::ReplaceTextInternal(const string16& text,
                                               bool mergeable) {
   if (HasCompositionText()) {
     CancelCompositionText();
   } else if (!HasSelection()) {
     size_t cursor = GetCursorPosition();
-    gfx::SelectionModel sel(render_text_->selection_model());
-    sel.set_selection_start(render_text_->GetIndexOfNextGrapheme(cursor));
-    render_text_->MoveCursorTo(sel);
+    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_->GetIndexOfNextGrapheme(cursor);
+    if (next == model.selection_end())
+      render_text_->MoveCursorTo(model);
+    else
+      render_text_->SelectRange(ui::Range(next, model.selection_end()));
   }
   // 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();
@@ skipping 100 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