Move Range code to gfx.

ui/gfx/render_text_linux.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 "ui/gfx/render_text_linux.h"
 
 #include <pango/pangocairo.h>
 #include <algorithm>
 #include <string>
 #include <vector>
@@ skipping 22 matching lines @@
 }
 
 // Returns true if the given visual cursor |direction| is logically forward
 // motion in the given Pango |item|.
 bool IsForwardMotion(VisualCursorDirection direction, const PangoItem* item) {
   bool rtl = item->analysis.level & 1;
   return rtl == (direction == CURSOR_LEFT);
 }
 
 // Checks whether |range| contains |index|. This is not the same as calling
-// |range.Contains(ui::Range(index))| - as that would return true when
+// |range.Contains(gfx::Range(index))| - as that would return true when
 // |index| == |range.end()|.
-bool IndexInRange(const ui::Range& range, size_t index) {
+bool IndexInRange(const gfx::Range& range, size_t index) {
   return index >= range.start() && index < range.end();
 }
 
 // Sets underline metrics on |renderer| according to Pango font |desc|.
 void SetPangoUnderlineMetrics(PangoFontDescription *desc,
                               internal::SkiaTextRenderer* renderer) {
   PangoFontMetrics* metrics = GetPangoFontMetrics(desc);
   int thickness = pango_font_metrics_get_underline_thickness(metrics);
   // Pango returns the position "above the baseline". Change its sign to convert
   // it to a vertical offset from the baseline.
@@ skipping 74 matching lines @@
 }
 
 std::vector<RenderText::FontSpan> RenderTextLinux::GetFontSpansForTesting() {
   EnsureLayout();
 
   std::vector<RenderText::FontSpan> spans;
   for (GSList* it = current_line_->runs; it; it = it->next) {
     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(it->data)->item;
     const int start = LayoutIndexToTextIndex(item->offset);
     const int end = LayoutIndexToTextIndex(item->offset + item->length);
-    const ui::Range range(start, end);
+    const gfx::Range range(start, end);
 
     ScopedPangoFontDescription desc(pango_font_describe(item->analysis.font));
     spans.push_back(RenderText::FontSpan(Font(desc.get()), range));
   }
 
   return spans;
 }
 
 SelectionModel RenderTextLinux::AdjacentCharSelectionModel(
     const SelectionModel& selection,
@@ skipping 56 matching lines @@
     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
     size_t cursor = cur.caret_pos();
     if (IsForwardMotion(direction, item) ?
         iter.IsEndOfWord(cursor) : iter.IsStartOfWord(cursor))
       break;
   }
 
   return cur;
 }
 
-ui::Range RenderTextLinux::GetGlyphBounds(size_t index) {
+gfx::Range RenderTextLinux::GetGlyphBounds(size_t index) {
   PangoRectangle pos;
   pango_layout_index_to_pos(layout_, TextIndexToLayoutIndex(index), &pos);
   // TODO(derat): Support fractional ranges for subpixel positioning?
-  return ui::Range(PANGO_PIXELS(pos.x), PANGO_PIXELS(pos.x + pos.width));
+  return gfx::Range(PANGO_PIXELS(pos.x), PANGO_PIXELS(pos.x + pos.width));
 }
 
-std::vector<Rect> RenderTextLinux::GetSubstringBounds(const ui::Range& range) {
+std::vector<Rect> RenderTextLinux::GetSubstringBounds(const gfx::Range& range) {
   DCHECK_LE(range.GetMax(), text().length());
   if (range.is_empty())
     return std::vector<Rect>();
 
   EnsureLayout();
   int* ranges = NULL;
   int n_ranges = 0;
   pango_layout_line_get_x_ranges(current_line_,
                                  TextIndexToLayoutIndex(range.GetMin()),
                                  TextIndexToLayoutIndex(range.GetMax()),
@@ skipping 186 matching lines @@
 
     // Track the current glyph and the glyph at the start of its styled range.
     int glyph_index = 0;
     int style_start_glyph_index = glyph_index;
 
     // Track the x-coordinates for each styled range (|x| marks the current).
     SkScalar style_start_x = x;
 
     // Track the current style and its text (not layout) index range.
     style.UpdatePosition(GetGlyphTextIndex(run, style_start_glyph_index));
-    ui::Range style_range = style.GetRange();
+    gfx::Range style_range = style.GetRange();
 
     do {
       const PangoGlyphInfo& glyph = run->glyphs->glyphs[glyph_index];
       glyphs[glyph_index] = static_cast<uint16>(glyph.glyph);
       // Use pango_units_to_double() rather than PANGO_PIXELS() here, so units
       // are not rounded to the pixel grid if subpixel positioning is enabled.
       pos[glyph_index].set(x + pango_units_to_double(glyph.geometry.x_offset),
                            y + pango_units_to_double(glyph.geometry.y_offset));
       x += pango_units_to_double(glyph.geometry.width);
 
@@ skipping 29 matching lines @@
   UndoCompositionAndSelectionStyles();
 }
 
 GSList* RenderTextLinux::GetRunContainingCaret(
     const SelectionModel& caret) const {
   size_t position = TextIndexToLayoutIndex(caret.caret_pos());
   LogicalCursorDirection affinity = caret.caret_affinity();
   GSList* run = current_line_->runs;
   while (run) {
     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
-    ui::Range item_range(item->offset, item->offset + item->length);
+    gfx::Range item_range(item->offset, item->offset + item->length);
     if (RangeContainsCaret(item_range, position, affinity))
       return run;
     run = run->next;
   }
   return NULL;
 }
 
 SelectionModel RenderTextLinux::FirstSelectionModelInsideRun(
     const PangoItem* item) {
   size_t caret = IndexOfAdjacentGrapheme(
@@ skipping 12 matching lines @@
                                           int glyph_index) const {
   return LayoutIndexToTextIndex(run->item->offset +
                                 run->glyphs->log_clusters[glyph_index]);
 }
 
 RenderText* RenderText::CreateInstance() {
   return new RenderTextLinux;
 }
 
 }  // namespace gfx