Move Range code to gfx.

ui/gfx/render_text_win.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_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/rtl.h"
@@ skipping 114 matching lines @@
          c == base::i18n::kLeftToRightEmbeddingMark ||
          c == base::i18n::kRightToLeftEmbeddingMark ||
          c == base::i18n::kPopDirectionalFormatting ||
          c == base::i18n::kLeftToRightOverride ||
          c == base::i18n::kRightToLeftOverride;
 }
 
 // Returns the corresponding glyph range of the given character range.
 // |range| is in text-space (0 corresponds to |GetLayoutText()[0]|).
 // Returned value is in run-space (0 corresponds to the first glyph in the run).
-ui::Range CharRangeToGlyphRange(const internal::TextRun& run,
-                                const ui::Range& range) {
+gfx::Range CharRangeToGlyphRange(const internal::TextRun& run,
+                                const gfx::Range& range) {
   DCHECK(run.range.Contains(range));
   DCHECK(!range.is_reversed());
   DCHECK(!range.is_empty());
-  const ui::Range run_range = ui::Range(range.start() - run.range.start(),
+  const gfx::Range run_range = gfx::Range(range.start() - run.range.start(),
                                         range.end() - run.range.start());
-  ui::Range result;
+  gfx::Range result;
   if (run.script_analysis.fRTL) {
-    result = ui::Range(run.logical_clusters[run_range.end() - 1],
+    result = gfx::Range(run.logical_clusters[run_range.end() - 1],
         run_range.start() > 0 ? run.logical_clusters[run_range.start() - 1]
                               : run.glyph_count);
   } else {
-    result = ui::Range(run.logical_clusters[run_range.start()],
+    result = gfx::Range(run.logical_clusters[run_range.start()],
         run_range.end() < run.range.length() ?
             run.logical_clusters[run_range.end()] : run.glyph_count);
   }
   DCHECK(!result.is_reversed());
-  DCHECK(ui::Range(0, run.glyph_count).Contains(result));
+  DCHECK(gfx::Range(0, run.glyph_count).Contains(result));
   return result;
 }
 
 }  // namespace
 
 namespace internal {
 
 TextRun::TextRun()
   : font_style(0),
     strike(false),
@@ skipping 95 matching lines @@
   DCHECK_LE(cursor, text().length());
   return SelectionModel(cursor, trailing ? CURSOR_BACKWARD : CURSOR_FORWARD);
 }
 
 std::vector<RenderText::FontSpan> RenderTextWin::GetFontSpansForTesting() {
   EnsureLayout();
 
   std::vector<RenderText::FontSpan> spans;
   for (size_t i = 0; i < runs_.size(); ++i) {
     spans.push_back(RenderText::FontSpan(runs_[i]->font,
-        ui::Range(LayoutIndexToTextIndex(runs_[i]->range.start()),
+        gfx::Range(LayoutIndexToTextIndex(runs_[i]->range.start()),
                   LayoutIndexToTextIndex(runs_[i]->range.end()))));
   }
 
   return spans;
 }
 
 SelectionModel RenderTextWin::AdjacentCharSelectionModel(
     const SelectionModel& selection,
     VisualCursorDirection direction) {
   DCHECK(!needs_layout_);
@@ skipping 77 matching lines @@
           break;
         } else {
           pos = iter.pos() - iter.GetString().length();
         }
       }
     }
   }
   return SelectionModel(pos, CURSOR_FORWARD);
 }
 
-ui::Range RenderTextWin::GetGlyphBounds(size_t index) {
+gfx::Range RenderTextWin::GetGlyphBounds(size_t index) {
   const size_t run_index =
       GetRunContainingCaret(SelectionModel(index, CURSOR_FORWARD));
   // Return edge bounds if the index is invalid or beyond the layout text size.
   if (run_index >= runs_.size())
-    return ui::Range(string_size_.width());
+    return gfx::Range(string_size_.width());
   internal::TextRun* run = runs_[run_index];
   const size_t layout_index = TextIndexToLayoutIndex(index);
-  return ui::Range(GetGlyphXBoundary(run, layout_index, false),
+  return gfx::Range(GetGlyphXBoundary(run, layout_index, false),
                    GetGlyphXBoundary(run, layout_index, true));
 }
 
-std::vector<Rect> RenderTextWin::GetSubstringBounds(const ui::Range& range) {
+std::vector<Rect> RenderTextWin::GetSubstringBounds(const gfx::Range& range) {
   DCHECK(!needs_layout_);
-  DCHECK(ui::Range(0, text().length()).Contains(range));
-  ui::Range layout_range(TextIndexToLayoutIndex(range.start()),
+  DCHECK(gfx::Range(0, text().length()).Contains(range));
+  gfx::Range layout_range(TextIndexToLayoutIndex(range.start()),
                          TextIndexToLayoutIndex(range.end()));
-  DCHECK(ui::Range(0, GetLayoutText().length()).Contains(layout_range));
+  DCHECK(gfx::Range(0, GetLayoutText().length()).Contains(layout_range));
 
   std::vector<Rect> bounds;
   if (layout_range.is_empty())
     return bounds;
 
   // Add a Rect for each run/selection intersection.
   // TODO(msw): The bounds should probably not always be leading the range ends.
   for (size_t i = 0; i < runs_.size(); ++i) {
     const internal::TextRun* run = runs_[visual_to_logical_[i]];
-    ui::Range intersection = run->range.Intersect(layout_range);
+    gfx::Range intersection = run->range.Intersect(layout_range);
     if (intersection.IsValid()) {
       DCHECK(!intersection.is_reversed());
-      ui::Range range_x(GetGlyphXBoundary(run, intersection.start(), false),
+      gfx::Range range_x(GetGlyphXBoundary(run, intersection.start(), false),
                         GetGlyphXBoundary(run, intersection.end(), false));
       Rect rect(range_x.GetMin(), 0, range_x.length(), run->font.GetHeight());
       rect.set_origin(ToViewPoint(rect.origin()));
       // Union this with the last rect if they're adjacent.
       if (!bounds.empty() && rect.SharesEdgeWith(bounds.back())) {
         rect.Union(bounds.back());
         bounds.pop_back();
       }
       bounds.push_back(rect);
     }
@@ skipping 95 matching lines @@
     }
     pos.back().set(glyph_x, y);
 
     renderer.SetTextSize(run->font.GetFontSize());
     renderer.SetFontFamilyWithStyle(run->font.GetFontName(), run->font_style);
 
     for (BreakList<SkColor>::const_iterator it =
              colors().GetBreak(run->range.start());
          it != colors().breaks().end() && it->first < run->range.end();
          ++it) {
-      const ui::Range glyph_range = CharRangeToGlyphRange(*run,
+      const gfx::Range glyph_range = CharRangeToGlyphRange(*run,
           colors().GetRange(it).Intersect(run->range));
       if (glyph_range.is_empty())
         continue;
       renderer.SetForegroundColor(it->second);
       renderer.DrawPosText(&pos[glyph_range.start()],
                            &run->glyphs[glyph_range.start()],
                            glyph_range.length());
       const SkScalar width = pos[glyph_range.end()].x() -
           pos[glyph_range.start()].x();
       renderer.DrawDecorations(pos[glyph_range.start()].x(), y,
@@ skipping 372 matching lines @@
   size_t position = LayoutIndexToTextIndex(run->range.end());
   position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD);
   return SelectionModel(position, CURSOR_FORWARD);
 }
 
 RenderText* RenderText::CreateInstance() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx