Move Range code to gfx.

chrome/browser/ui/views/omnibox/omnibox_view_views.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 "chrome/browser/ui/views/omnibox/omnibox_view_views.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 323 matching lines @@
   }
 #endif
   model()->OnWillKillFocus(native_view);
   // Close the popup.
   CloseOmniboxPopup();
   // Tell the model to reset itself.
   model()->OnKillFocus();
   controller()->OnKillFocus();
 
   // Make sure the beginning of the text is visible.
-  SelectRange(ui::Range(0));
+  SelectRange(gfx::Range(0));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxViewViews, OmniboxView implementation:
 
 void OmniboxViewViews::SaveStateToTab(content::WebContents* tab) {
   DCHECK(tab);
 
   // We don't want to keep the IME status, so force quit the current
   // session here.  It may affect the selection status, so order is
@@ skipping 24 matching lines @@
 
 void OmniboxViewViews::Update() {
   const ToolbarModel::SecurityLevel old_security_level = security_level_;
   security_level_ = controller()->GetToolbarModel()->GetSecurityLevel(false);
   if (model()->UpdatePermanentText()) {
     // Tweak: if the user had all the text selected, select all the new text.
     // This makes one particular case better: the user clicks in the box to
     // change it right before the permanent URL is changed.  Since the new URL
     // is still fully selected, the user's typing will replace the edit contents
     // as they'd intended.
-    const ui::Range range(GetSelectedRange());
+    const gfx::Range range(GetSelectedRange());
     const bool was_select_all = (range.length() == text().length());
 
     RevertAll();
 
     // Only select all when we have focus.  If we don't have focus, selecting
     // all is unnecessary since the selection will change on regaining focus,
     // and can in fact cause artifacts, e.g. if the user is on the NTP and
     // clicks a link to navigate, causing |was_select_all| to be vacuously true
     // for the empty omnibox, and we then select all here, leading to the
     // trailing portion of a long URL being scrolled into view.  We could try
     // and address cases like this, but it seems better to just not muck with
     // things when the omnibox isn't focused to begin with.
     if (was_select_all && model()->has_focus())
       SelectAll(range.is_reversed());
   } else if (old_security_level != security_level_) {
     EmphasizeURLComponents();
   }
 }
 
 string16 OmniboxViewViews::GetText() const {
   // TODO(oshima): IME support
   return text();
 }
 
 void OmniboxViewViews::SetWindowTextAndCaretPos(const string16& text,
                                                 size_t caret_pos,
                                                 bool update_popup,
                                                 bool notify_text_changed) {
-  const ui::Range range(caret_pos, caret_pos);
+  const gfx::Range range(caret_pos, caret_pos);
   SetTextAndSelectedRange(text, range);
 
   if (update_popup)
     UpdatePopup();
 
   if (notify_text_changed)
     TextChanged();
 }
 
 void OmniboxViewViews::SetForcedQuery() {
   const string16 current_text(text());
   const size_t start = current_text.find_first_not_of(kWhitespaceUTF16);
   if (start == string16::npos || (current_text[start] != '?'))
     SetUserText(ASCIIToUTF16("?"));
   else
-    SelectRange(ui::Range(current_text.size(), start + 1));
+    SelectRange(gfx::Range(current_text.size(), start + 1));
 }
 
 bool OmniboxViewViews::IsSelectAll() const {
   // TODO(oshima): IME support.
   return text() == GetSelectedText();
 }
 
 bool OmniboxViewViews::DeleteAtEndPressed() {
   return delete_at_end_pressed_;
 }
 
 void OmniboxViewViews::GetSelectionBounds(string16::size_type* start,
                                           string16::size_type* end) const {
-  const ui::Range range = GetSelectedRange();
+  const gfx::Range range = GetSelectedRange();
   *start = static_cast<size_t>(range.start());
   *end = static_cast<size_t>(range.end());
 }
 
 void OmniboxViewViews::SelectAll(bool reversed) {
   views::Textfield::SelectAll(reversed);
 }
 
 void OmniboxViewViews::UpdatePopup() {
   model()->SetInputInProgress(true);
   if (!model()->has_focus())
     return;
 
   // Hide the inline autocompletion for IME users.
   location_bar_view_->SetImeInlineAutocompletion(string16());
 
   // Prevent inline autocomplete when the caret isn't at the end of the text,
   // and during IME composition editing unless
   // |kEnableOmniboxAutoCompletionForIme| is enabled.
-  const ui::Range sel = GetSelectedRange();
+  const gfx::Range sel = GetSelectedRange();
   model()->StartAutocomplete(
       !sel.is_empty(),
       sel.GetMax() < text().length() ||
       (IsIMEComposing() && !IsOmniboxAutoCompletionForImeEnabled()));
 }
 
 void OmniboxViewViews::SetFocus() {
   RequestFocus();
   // Restore caret visibility if focus is explicitly requested. This is
   // necessary because if we already have invisible focus, the RequestFocus()
@@ skipping 21 matching lines @@
 bool OmniboxViewViews::OnInlineAutocompleteTextMaybeChanged(
     const string16& display_text,
     size_t user_text_length) {
   if (display_text == text())
     return false;
 
   if (IsIMEComposing()) {
     location_bar_view_->SetImeInlineAutocompletion(
         display_text.substr(user_text_length));
   } else {
-    ui::Range range(display_text.size(), user_text_length);
+    gfx::Range range(display_text.size(), user_text_length);
     SetTextAndSelectedRange(display_text, range);
   }
   TextChanged();
   return true;
 }
 
 void OmniboxViewViews::OnRevertTemporaryText() {
   SelectRange(saved_temporary_selection_);
   // We got here because the user hit the Escape key. We explicitly don't call
   // TextChanged(), since OmniboxPopupModel::ResetToDefaultMatch() has already
   // been called by now, and it would've called TextChanged() if it was
   // warranted.
 }
 
 void OmniboxViewViews::OnBeforePossibleChange() {
   // Record our state.
   text_before_change_ = text();
   sel_before_change_ = GetSelectedRange();
   ime_composing_before_change_ = IsIMEComposing();
 }
 
 bool OmniboxViewViews::OnAfterPossibleChange() {
   // See if the text or selection have changed since OnBeforePossibleChange().
   const string16 new_text = text();
-  const ui::Range new_sel = GetSelectedRange();
+  const gfx::Range new_sel = GetSelectedRange();
   const bool text_changed = (new_text != text_before_change_) ||
       (ime_composing_before_change_ != 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
   // sure to not flag cases like selecting part of the text and then pasting
   // (or typing) the prefix of that selection.  (We detect these by making
   // sure the caret, which should be after any insertion, hasn't moved
@@ skipping 305 matching lines @@
   bool grey_out_url = text().substr(scheme.begin, scheme.len) ==
       UTF8ToUTF16(extensions::kExtensionScheme);
   bool grey_base = model()->CurrentTextIsURL() &&
       (host.is_nonempty() || grey_out_url);
   SetColor(location_bar_view_->GetColor(
       security_level_,
       grey_base ? LocationBarView::DEEMPHASIZED_TEXT : LocationBarView::TEXT));
   if (grey_base && !grey_out_url) {
     ApplyColor(
         location_bar_view_->GetColor(security_level_, LocationBarView::TEXT),
-        ui::Range(host.begin, host.end()));
+        gfx::Range(host.begin, host.end()));
   }
 
   // Emphasize the scheme for security UI display purposes (if necessary).
   // Note that we check CurrentTextIsURL() because if we're replacing search
   // URLs with search terms, we may have a non-URL even when the user is not
   // editing; and in some cases, e.g. for "site:foo.com" searches, the parser
   // may have incorrectly identified a qualifier as a scheme.
   SetStyle(gfx::DIAGONAL_STRIKE, false);
   if (!model()->user_input_in_progress() && model()->CurrentTextIsURL() &&
       scheme.is_nonempty() && (security_level_ != ToolbarModel::NONE)) {
     SkColor security_color = location_bar_view_->GetColor(
         security_level_, LocationBarView::SECURITY_TEXT);
     const bool strike = (security_level_ == ToolbarModel::SECURITY_ERROR);
-    const ui::Range scheme_range(scheme.begin, scheme.end());
+    const gfx::Range scheme_range(scheme.begin, scheme.end());
     ApplyColor(security_color, scheme_range);
     ApplyStyle(gfx::DIAGONAL_STRIKE, strike, scheme_range);
   }
 }
 
 void OmniboxViewViews::SetTextAndSelectedRange(const string16& text,
-                                               const ui::Range& range) {
+                                               const gfx::Range& range) {
   SetText(text);
   SelectRange(range);
 }
 
 string16 OmniboxViewViews::GetSelectedText() const {
   // TODO(oshima): Support IME.
   return views::Textfield::GetSelectedText();
 }
 
 void OmniboxViewViews::OnPaste() {
   const string16 text(GetClipboardText());
   if (!text.empty()) {
     // Record this paste, so we can do different behavior.
     model()->on_paste();
     // Force a Paste operation to trigger the text_changed code in
     // OnAfterPossibleChange(), even if identical contents are pasted.
     text_before_change_.clear();
     InsertOrReplaceText(text);
   }
 }