Move Range code to gfx.

ui/views/controls/textfield/native_textfield_views.cc

 // Copyright (c) 2013 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/native_textfield_views.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ui_strings.h"
 #include "third_party/icu/source/common/unicode/uchar.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/events/event.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/range/range.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
+#include "ui/gfx/range/range.h"
 #include "ui/gfx/render_text.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/focusable_border.h"
 #include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/textfield/textfield.h"
@@ skipping 83 matching lines @@
   }
 
   OnBeforeUserAction();
   // TODO: Remove once NativeTextfield implementations are consolidated to
   // Textfield.
   if (!textfield_->OnMouseDragged(event)) {
     MoveCursorTo(event.location(), true);
     if (aggregated_clicks_ == 1) {
       model_->SelectWord();
       // Expand the selection so the initially selected word remains selected.
-      ui::Range selection = GetRenderText()->selection();
+      gfx::Range selection = GetRenderText()->selection();
       const size_t min = std::min(selection.GetMin(),
                                   double_click_word_.GetMin());
       const size_t max = std::max(selection.GetMax(),
                                   double_click_word_.GetMax());
       const bool reversed = selection.is_reversed();
       selection.set_start(reversed ? max : min);
       selection.set_end(reversed ? min : max);
       model_->SelectRange(selection);
     }
     SchedulePaint();
@@ skipping 122 matching lines @@
   int formats;
   std::set<OSExchangeData::CustomFormat> custom_formats;
   GetDropFormats(&formats, &custom_formats);
   return textfield_->enabled() && !textfield_->read_only() &&
       data.HasAnyFormat(formats, custom_formats);
 }
 
 int NativeTextfieldViews::OnDragUpdated(const ui::DropTargetEvent& event) {
   DCHECK(CanDrop(event.data()));
 
-  const ui::Range& selection = GetRenderText()->selection();
+  const gfx::Range& selection = GetRenderText()->selection();
   drop_cursor_position_ = GetRenderText()->FindCursorPosition(event.location());
   bool in_selection = !selection.is_empty() &&
-      selection.Contains(ui::Range(drop_cursor_position_.caret_pos()));
+      selection.Contains(gfx::Range(drop_cursor_position_.caret_pos()));
   is_drop_cursor_visible_ = !in_selection;
   // TODO(msw): Pan over text when the user drags to the visible text edge.
   OnCaretBoundsChanged();
   SchedulePaint();
 
   if (initiating_drag_) {
     if (in_selection)
       return ui::DragDropTypes::DRAG_NONE;
     return event.IsControlDown() ? ui::DragDropTypes::DRAG_COPY :
                                    ui::DragDropTypes::DRAG_MOVE;
@@ skipping 28 matching lines @@
   string16 text;
   event.data().GetString(&text);
   text = GetTextForDisplay(text);
 
   // Delete the current selection for a drag and drop within this view.
   const bool move = initiating_drag_ && !event.IsControlDown() &&
                     event.source_operations() & ui::DragDropTypes::DRAG_MOVE;
   if (move) {
     // Adjust the drop destination if it is on or after the current selection.
     size_t drop = drop_destination_model.caret_pos();
-    drop -= GetSelectedRange().Intersect(ui::Range(0, drop)).length();
+    drop -= GetSelectedRange().Intersect(gfx::Range(0, drop)).length();
     model_->DeleteSelectionAndInsertTextAt(text, drop);
   } else {
     model_->MoveCursorTo(drop_destination_model);
     // 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 25 matching lines @@
 }
 
 void NativeTextfieldViews::SelectRect(const gfx::Point& start,
                                       const gfx::Point& end) {
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   gfx::SelectionModel start_caret = GetRenderText()->FindCursorPosition(start);
   gfx::SelectionModel end_caret = GetRenderText()->FindCursorPosition(end);
   gfx::SelectionModel selection(
-      ui::Range(start_caret.caret_pos(), end_caret.caret_pos()),
+      gfx::Range(start_caret.caret_pos(), end_caret.caret_pos()),
       end_caret.caret_affinity());
 
   OnBeforeUserAction();
   model_->SelectSelectionModel(selection);
   OnCaretBoundsChanged();
   SchedulePaint();
   OnAfterUserAction();
 }
 
 void NativeTextfieldViews::MoveCaretTo(const gfx::Point& point) {
@@ skipping 237 matching lines @@
 
 gfx::NativeView NativeTextfieldViews::GetTestingHandle() const {
   NOTREACHED();
   return NULL;
 }
 
 bool NativeTextfieldViews::IsIMEComposing() const {
   return model_->HasCompositionText();
 }
 
-ui::Range NativeTextfieldViews::GetSelectedRange() const {
+gfx::Range NativeTextfieldViews::GetSelectedRange() const {
   return GetRenderText()->selection();
 }
 
-void NativeTextfieldViews::SelectRange(const ui::Range& range) {
+void NativeTextfieldViews::SelectRange(const gfx::Range& range) {
   model_->SelectRange(range);
   OnCaretBoundsChanged();
   SchedulePaint();
   textfield_->NotifyAccessibilityEvent(
       ui::AccessibilityTypes::EVENT_SELECTION_CHANGED, true);
 }
 
 gfx::SelectionModel NativeTextfieldViews::GetSelectionModel() const {
   return GetRenderText()->selection_model();
 }
@@ skipping 183 matching lines @@
         break;
     }
   }
 }
 
 void NativeTextfieldViews::SetColor(SkColor value) {
   GetRenderText()->SetColor(value);
   SchedulePaint();
 }
 
-void NativeTextfieldViews::ApplyColor(SkColor value, const ui::Range& range) {
+void NativeTextfieldViews::ApplyColor(SkColor value, const gfx::Range& range) {
   GetRenderText()->ApplyColor(value, range);
   SchedulePaint();
 }
 
 void NativeTextfieldViews::SetStyle(gfx::TextStyle style, bool value) {
   GetRenderText()->SetStyle(style, value);
   SchedulePaint();
 }
 
 void NativeTextfieldViews::ApplyStyle(gfx::TextStyle style,
                                       bool value,
-                                      const ui::Range& range) {
+                                      const gfx::Range& range) {
   GetRenderText()->ApplyStyle(style, value, range);
   SchedulePaint();
 }
 
 void NativeTextfieldViews::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   // Set the RenderText display area.
   gfx::Insets insets = GetInsets();
   gfx::Rect display_rect(insets.left(),
                          insets.top(),
                          width() - insets.width(),
@@ skipping 121 matching lines @@
   gfx::Rect rect = GetRenderText()->GetUpdatedCursorBounds();
   ConvertRectToScreen(this, &rect);
   return rect;
 }
 
 bool NativeTextfieldViews::GetCompositionCharacterBounds(uint32 index,
                                                          gfx::Rect* rect) {
   DCHECK(rect);
   if (!HasCompositionText())
     return false;
-  const ui::Range& composition_range = GetRenderText()->GetCompositionRange();
+  const gfx::Range& composition_range = GetRenderText()->GetCompositionRange();
   const uint32 left_cursor_pos = composition_range.start() + index;
   const uint32 right_cursor_pos = composition_range.start() + index + 1;
   DCHECK(!composition_range.is_empty());
   if (composition_range.end() < right_cursor_pos)
     return false;
   const gfx::SelectionModel start_position(left_cursor_pos,
                                            gfx::CURSOR_BACKWARD);
   const gfx::SelectionModel end_position(right_cursor_pos,
                                          gfx::CURSOR_BACKWARD);
   gfx::Rect start_cursor = GetRenderText()->GetCursorBounds(start_position,
                                                             false);
   gfx::Rect end_cursor = GetRenderText()->GetCursorBounds(end_position, false);
 
   // TextInputClient::GetCompositionCharacterBounds is expected to fill |rect|
   // in screen coordinates and GetCaretBounds returns screen coordinates.
   *rect = gfx::Rect(start_cursor.x(),
                     start_cursor.y(),
                     end_cursor.x() - start_cursor.x(),
                     start_cursor.height());
   ConvertRectToScreen(this, rect);
 
   return true;
 }
 
 bool NativeTextfieldViews::HasCompositionText() {
   return model_->HasCompositionText();
 }
 
-bool NativeTextfieldViews::GetTextRange(ui::Range* range) {
+bool NativeTextfieldViews::GetTextRange(gfx::Range* range) {
   if (!ImeEditingAllowed())
     return false;
 
   model_->GetTextRange(range);
   return true;
 }
 
-bool NativeTextfieldViews::GetCompositionTextRange(ui::Range* range) {
+bool NativeTextfieldViews::GetCompositionTextRange(gfx::Range* range) {
   if (!ImeEditingAllowed())
     return false;
 
   model_->GetCompositionTextRange(range);
   return true;
 }
 
-bool NativeTextfieldViews::GetSelectionRange(ui::Range* range) {
+bool NativeTextfieldViews::GetSelectionRange(gfx::Range* range) {
   if (!ImeEditingAllowed())
     return false;
   *range = GetSelectedRange();
   return true;
 }
 
-bool NativeTextfieldViews::SetSelectionRange(const ui::Range& range) {
+bool NativeTextfieldViews::SetSelectionRange(const gfx::Range& range) {
   if (!ImeEditingAllowed() || !range.IsValid())
     return false;
 
   OnBeforeUserAction();
   SelectRange(range);
   OnAfterUserAction();
   return true;
 }
 
-bool NativeTextfieldViews::DeleteRange(const ui::Range& range) {
+bool NativeTextfieldViews::DeleteRange(const gfx::Range& range) {
   if (!ImeEditingAllowed() || range.is_empty())
     return false;
 
   OnBeforeUserAction();
   model_->SelectRange(range);
   if (model_->HasSelection()) {
     model_->DeleteSelection();
     UpdateAfterChange(true, true);
   }
   OnAfterUserAction();
   return true;
 }
 
 bool NativeTextfieldViews::GetTextFromRange(
-    const ui::Range& range,
+    const gfx::Range& range,
     string16* text) {
   if (!ImeEditingAllowed() || !range.IsValid())
     return false;
 
-  ui::Range text_range;
+  gfx::Range text_range;
   if (!GetTextRange(&text_range) || !text_range.Contains(range))
     return false;
 
   *text = model_->GetTextFromRange(range);
   return true;
 }
 
 void NativeTextfieldViews::OnInputMethodChanged() {
   // TODO(msw): NOTIMPLEMENTED(); see http://crbug.com/140402
 }
 
 bool NativeTextfieldViews::ChangeTextDirectionAndLayoutAlignment(
     base::i18n::TextDirection direction) {
   NOTIMPLEMENTED();
   return false;
 }
 
 void NativeTextfieldViews::ExtendSelectionAndDelete(
     size_t before,
     size_t after) {
-  ui::Range range = GetSelectedRange();
+  gfx::Range range = GetSelectedRange();
   DCHECK_GE(range.start(), before);
 
   range.set_start(range.start() - before);
   range.set_end(range.end() + after);
-  ui::Range text_range;
+  gfx::Range text_range;
   if (GetTextRange(&text_range) && text_range.Contains(range))
     DeleteRange(range);
 }
 
 void NativeTextfieldViews::EnsureCaretInRect(const gfx::Rect& rect) {
 }
 
 void NativeTextfieldViews::OnCompositionTextConfirmedOrCleared() {
   if (skip_input_method_cancel_composition_)
     return;
@@ skipping 105 matching lines @@
         if (control && !alt && editable)
           cursor_changed = text_changed = Paste();
         break;
       case ui::VKEY_RIGHT:
       case ui::VKEY_LEFT: {
         // We should ignore the alt-left/right keys because alt key doesn't make
         // any special effects for them and they can be shortcut keys such like
         // forward/back of the browser history.
         if (alt)
           break;
-        const ui::Range selection_range = GetSelectedRange();
+        const gfx::Range selection_range = GetSelectedRange();
         model_->MoveCursor(
             control ? gfx::WORD_BREAK : gfx::CHARACTER_BREAK,
             (key_code == ui::VKEY_RIGHT) ? gfx::CURSOR_RIGHT : gfx::CURSOR_LEFT,
             shift);
         cursor_changed = GetSelectedRange() != selection_range;
         break;
       }
       case ui::VKEY_END:
       case ui::VKEY_HOME:
         if ((key_code == ui::VKEY_HOME) ==
@@ skipping 275 matching lines @@
   if (index != -1) {
     obscured_reveal_timer_.Start(
         FROM_HERE,
         duration,
         base::Bind(&NativeTextfieldViews::RevealObscuredChar,
                    base::Unretained(this), -1, base::TimeDelta()));
   }
 }
 
 }  // namespace views