Clean up of SelectionModel

chrome/browser/ui/views/omnibox/omnibox_view_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 "chrome/browser/ui/views/omnibox/omnibox_view_views.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
@@ skipping 219 matching lines @@
              !event.IsControlDown()) {
     if (model_->is_keyword_hint()) {
       handled = model_->AcceptKeyword();
     } else {
       string16::size_type start = 0;
       string16::size_type end = 0;
       size_t length = GetTextLength();
       GetSelectionBounds(&start, &end);
       if (start != end || start < length) {
         OnBeforePossibleChange();
-        textfield_->SelectSelectionModel(gfx::SelectionModel(length, length));
+        SelectRange(length, length);
         OnAfterPossibleChange();
         handled = true;
       }
 
       // TODO(Oshima): handle instant
     }
   }
   // TODO(oshima): page up & down
 
   return handled;
@@ skipping 146 matching lines @@
 
 void OmniboxViewViews::SetWindowTextAndCaretPos(const string16& text,
                                                 size_t caret_pos) {
   const ui::Range range(caret_pos, caret_pos);
   SetTextAndSelectedRange(text, range);
 }
 
 void OmniboxViewViews::SetForcedQuery() {
   const string16 current_text(GetText());
   const size_t start = current_text.find_first_not_of(kWhitespaceUTF16);
   if (start == string16::npos || (current_text[start] != '?')) {

[msw, 2011/10/04 07:25:41]

you can remove the braces for these conditional blocks.

[xji, 2011/10/05 01:23:42]

Done.

     SetUserText(ASCIIToUTF16("?"));
   } else {
-    textfield_->SelectSelectionModel(gfx::SelectionModel(current_text.size(),
-                                                         start + 1));
+    SelectRange(current_text.size(), start + 1);
   }
 }
 
 bool OmniboxViewViews::IsSelectAll() {
   // TODO(oshima): IME support.
   return textfield_->text() == textfield_->GetSelectedText();
 }
 
 bool OmniboxViewViews::DeleteAtEndPressed() {
   return delete_at_end_pressed_;
 }
 
 void OmniboxViewViews::GetSelectionBounds(string16::size_type* start,
                                           string16::size_type* end) {
-  gfx::SelectionModel sel;
-  textfield_->GetSelectionModel(&sel);
-  *start = static_cast<size_t>(sel.selection_end());
-  *end = static_cast<size_t>(sel.selection_start());
+  ui::Range range;
+  textfield_->GetSelectedRange(&range);
+  *start = static_cast<size_t>(range.end());
+  *end = static_cast<size_t>(range.start());
 }
 
 void OmniboxViewViews::SelectAll(bool reversed) {
   if (reversed)
-    textfield_->SelectSelectionModel(gfx::SelectionModel(GetTextLength(), 0));
+    SelectRange(GetTextLength(), 0);
   else
-    textfield_->SelectSelectionModel(gfx::SelectionModel(0, GetTextLength()));
+    SelectRange(0, GetTextLength());
 }
 
 void OmniboxViewViews::RevertAll() {
   ClosePopup();
   model_->Revert();
   TextChanged();
 }
 
 void OmniboxViewViews::UpdatePopup() {
   model_->SetInputInProgress(true);
   if (!model_->has_focus())
     return;
 
   // Don't inline autocomplete when the caret/selection isn't at the end of
   // the text, or in the middle of composition.
-  gfx::SelectionModel sel;
-  textfield_->GetSelectionModel(&sel);
-  size_t max_of_selection = std::max(sel.selection_start(),
-                                     sel.selection_end());
+  ui::Range sel;
+  textfield_->GetSelectedRange(&sel);
   bool no_inline_autocomplete =
-      max_of_selection < GetTextLength() || textfield_->IsIMEComposing();
+      sel.GetMax() < GetTextLength() || textfield_->IsIMEComposing();
 
-  bool is_sel_empty = (sel.selection_start() == sel.selection_end());
-  model_->StartAutocomplete(!is_sel_empty, no_inline_autocomplete);
+  model_->StartAutocomplete(!sel.is_empty(), no_inline_autocomplete);
 }
 
 void OmniboxViewViews::ClosePopup() {
   model_->StopAutocomplete();
 }
 
 void OmniboxViewViews::SetFocus() {
   // In views-implementation, the focus is on textfield rather than OmniboxView.
   textfield_->RequestFocus();
 }
 
 void OmniboxViewViews::OnTemporaryTextMaybeChanged(
     const string16& display_text,
     bool save_original_selection) {
-  if (save_original_selection) {
-    gfx::SelectionModel sel;
-    textfield_->GetSelectionModel(&sel);
-    saved_temporary_selection_.set_start(sel.selection_start());
-    saved_temporary_selection_.set_end(sel.selection_end());
-  }
+  if (save_original_selection)
+    textfield_->GetSelectedRange(&saved_temporary_selection_);
 
   SetWindowTextAndCaretPos(display_text, display_text.length());
   TextChanged();
 }
 
 bool OmniboxViewViews::OnInlineAutocompleteTextMaybeChanged(
     const string16& display_text,
     size_t user_text_length) {
   if (display_text == GetText())
     return false;
   ui::Range range(display_text.size(), user_text_length);
   SetTextAndSelectedRange(display_text, range);
   TextChanged();
   return true;
 }
 
 void OmniboxViewViews::OnRevertTemporaryText() {
-  gfx::SelectionModel sel(saved_temporary_selection_.start(),
-                          saved_temporary_selection_.end());
-  textfield_->SelectSelectionModel(sel);
+  textfield_->SelectRange(saved_temporary_selection_);
   TextChanged();
 }
 
 void OmniboxViewViews::OnBeforePossibleChange() {
   // Record our state.
   text_before_change_ = GetText();
-  gfx::SelectionModel sel;
-  textfield_->GetSelectionModel(&sel);
-  sel_before_change_.set_start(sel.selection_start());
-  sel_before_change_.set_end(sel.selection_end());
+  textfield_->GetSelectedRange(&sel_before_change_);
   ime_composing_before_change_ = textfield_->IsIMEComposing();
 }
 
 bool OmniboxViewViews::OnAfterPossibleChange() {
-  gfx::SelectionModel sel;
-  textfield_->GetSelectionModel(&sel);
   ui::Range new_sel;
-  new_sel.set_start(sel.selection_start());
-  new_sel.set_end(sel.selection_end());
+  textfield_->GetSelectedRange(&new_sel);
 
   // See if the text or selection have changed since OnBeforePossibleChange().
   const string16 new_text = GetText();
   const bool text_changed = (new_text != text_before_change_) ||
       (ime_composing_before_change_ != textfield_->IsIMEComposing());
   const bool selection_differs =
       !((sel_before_change_.is_empty() && new_sel.is_empty()) ||
         sel_before_change_.EqualsIgnoringDirection(new_sel));
 
   // When the user has deleted text, we don't allow inline autocomplete.  Make
@@ skipping 160 matching lines @@
 
 void OmniboxViewViews::TextChanged() {
   EmphasizeURLComponents();
   model_->OnChanged();
 }
 
 void OmniboxViewViews::SetTextAndSelectedRange(const string16& text,
                                                const ui::Range& range) {
   if (text != GetText())
     textfield_->SetText(text);
-  textfield_->SelectSelectionModel(gfx::SelectionModel(
-      range.start(), range.end()));
+  textfield_->SelectRange(range);
 }
 
 string16 OmniboxViewViews::GetSelectedText() const {
   // TODO(oshima): Support instant, IME.
   return textfield_->GetSelectedText();
 }
 
+void OmniboxViewViews::SelectRange(size_t caret, size_t end) {
+  const ui::Range range(caret, end);
+  textfield_->SelectRange(range);

[msw, 2011/10/04 07:25:41]

You could optionally inline this without additional lines at each callsite via:
textfield_->SelectRange(ui::Range([start], [end]));
I usually wouldn't add a convenience function for something that convenient.

[xji, 2011/10/05 01:23:42]

Removed this convient function.
It was there originally, but I agree with you that it is not needed.

+}
 
 AutocompletePopupView* OmniboxViewViews::CreatePopupView(
     View* location_bar) {
 #if defined(TOUCH_UI)
   typedef TouchAutocompletePopupContentsView AutocompleteContentsView;
 #else
   typedef AutocompletePopupContentsView AutocompleteContentsView;
 #endif
   return new AutocompleteContentsView(gfx::Font(), this, model_.get(),
                                       location_bar);
 }