Clean up of SelectionModel

views/controls/textfield/native_textfield_views.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/native_textfield_views.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 208 matching lines @@
   if (move) {
     gfx::SelectionModel selected;
     model_->GetSelectionModel(&selected);
     // Adjust the drop destination if it is on or after the current selection.
     size_t max_of_selected_range = std::max(selected.selection_start(),
                                             selected.selection_end());
     size_t min_of_selected_range = std::min(selected.selection_start(),
                                             selected.selection_end());
     size_t selected_range_length = max_of_selected_range -
                                    min_of_selected_range;
-    if (max_of_selected_range <= drop_destination.selection_end())
-      drop_destination.set_selection_end(
-          drop_destination.selection_end() - selected_range_length);
-    else if (min_of_selected_range <= drop_destination.selection_end())
-      drop_destination.set_selection_end(min_of_selected_range);
-    model_->DeleteSelectionAndInsertTextAt(text,
-                                           drop_destination.selection_end());
+    size_t drop_destination_end = drop_destination.selection_end();
+    if (max_of_selected_range <= drop_destination_end)
+      drop_destination_end -= selected_range_length;
+    else if (min_of_selected_range <= drop_destination_end)
+      drop_destination_end = min_of_selected_range;
+    model_->DeleteSelectionAndInsertTextAt(text, drop_destination_end);
   } else {
-    drop_destination.set_selection_start(drop_destination.selection_end());
     model_->MoveCursorTo(drop_destination);
     // Drop always inserts text even if the textfield is not in insert mode.
     model_->InsertText(text);
   }
   skip_input_method_cancel_composition_ = false;
   UpdateAfterChange(true, true);
   OnAfterUserAction();
   return move ? ui::DragDropTypes::DRAG_MOVE : ui::DragDropTypes::DRAG_COPY;
 }
 
@@ skipping 23 matching lines @@
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   gfx::SelectionModel start_pos = GetRenderText()->FindCursorPosition(start);
   gfx::SelectionModel end_pos = GetRenderText()->FindCursorPosition(end);
 
   OnBeforeUserAction();
   // Merge selection models of "start_pos" and "end_pos" so that
   // selection start is the value from "start_pos", while selection end,
   // caret position, and caret placement are values from "end_pos".
-  gfx::SelectionModel sel(end_pos);
-  sel.set_selection_start(start_pos.selection_start());
-  model_->SelectSelectionModel(sel);
+  if (start_pos.selection_start() == end_pos.selection_end())

[msw, 2011/10/07 20:54:20]

Is it always safe to just use the SelectRange statement? Could the end_pos
caret/placement differ from those that would be set by SelectRange?

[xji, 2011/10/07 21:42:04]

I think you are asking about line 282.
When there is non-empty selection, using SelectRange (instead of setting only
the selection_start) is the right way.

For example, logical text "abcDEFhij", visually display as "abcFEDhij", if end's
selection model is (3, 3, 2, trailing), which means cursor is at "abc|FEDhij",
and if start's logical index is 4. the selection should be (4, 3) and [D] is
selected. The selection model should be (4, 3, 3, leading) which is what
SelectRange computed, not as (4, 3, 2, trailing) which is what we get by only
set_selection_start.

+    model_->SelectSelectionModel(end_pos);
+  else
+    model_->SelectRange(ui::Range(start_pos.selection_start(),
+                                  end_pos.selection_end()));
 
   OnCaretBoundsChanged();
   SchedulePaint();
   OnAfterUserAction();
 }
 
 gfx::NativeCursor NativeTextfieldViews::GetCursor(const MouseEvent& event) {
   bool in_selection = GetRenderText()->IsPointInSelection(event.location());
   bool drag_event = event.type() == ui::ET_MOUSE_DRAGGED;
   bool text_cursor = !initiating_drag_ && (drag_event || !in_selection);
@@ skipping 189 matching lines @@
 
 gfx::NativeView NativeTextfieldViews::GetTestingHandle() const {
   NOTREACHED();
   return NULL;
 }
 
 bool NativeTextfieldViews::IsIMEComposing() const {
   return model_->HasCompositionText();
 }
 
+void NativeTextfieldViews::GetSelectedRange(ui::Range* range) const {
+  model_->GetSelectedRange(range);
+}
+
+void NativeTextfieldViews::SelectRange(const ui::Range& range) {
+  model_->SelectRange(range);
+  OnCaretBoundsChanged();
+  SchedulePaint();
+}
+
 void NativeTextfieldViews::GetSelectionModel(gfx::SelectionModel* sel) const {
   model_->GetSelectionModel(sel);
 }
 
 void NativeTextfieldViews::SelectSelectionModel(
     const gfx::SelectionModel& sel) {
   model_->SelectSelectionModel(sel);
   OnCaretBoundsChanged();
   SchedulePaint();
 }
@@ skipping 248 matching lines @@
   range->set_start(sel.selection_start());
   range->set_end(sel.selection_end());
   return true;
 }
 
 bool NativeTextfieldViews::SetSelectionRange(const ui::Range& range) {
   if (GetTextInputType() != ui::TEXT_INPUT_TYPE_TEXT || !range.IsValid())
     return false;
 
   OnBeforeUserAction();
-  SelectSelectionModel(gfx::SelectionModel(range.start(), range.end()));
+  SelectRange(range);
   OnAfterUserAction();
   return true;
 }
 
 bool NativeTextfieldViews::DeleteRange(const ui::Range& range) {
   if (GetTextInputType() != ui::TEXT_INPUT_TYPE_TEXT || range.is_empty())
     return false;
 
   OnBeforeUserAction();
-  gfx::SelectionModel selection(range.start(), range.end());
-  model_->SelectSelectionModel(selection);
+  model_->SelectRange(range);
   if (model_->HasSelection()) {
     model_->DeleteSelection();
     UpdateAfterChange(true, true);
   }
   OnAfterUserAction();
   return true;
 }
 
 bool NativeTextfieldViews::GetTextFromRange(
     const ui::Range& range,
@@ skipping 280 matching lines @@
 
 #if defined(USE_AURA)
 // static
 NativeTextfieldWrapper* NativeTextfieldWrapper::CreateWrapper(
     Textfield* field) {
   return new NativeTextfieldViews(field);
 }
 #endif
 
 }  // namespace views