Move Range code to gfx.

ui/gfx/canvas_skia.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/canvas.h"
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "ui/base/range/range.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/insets.h"
+#include "ui/gfx/range/range.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/render_text.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/gfx/text_utils.h"
 
 namespace gfx {
 
 namespace {
 
 // If necessary, wraps |text| with RTL/LTR directionality characters based on
@@ skipping 51 matching lines @@
       *bitmap.getAddr32(x, y - 1) != 0)
     return true;  // Touched pixel above.
   if (y < bitmap.height() - 1 &&
       *bitmap.getAddr32(x, y + 1) != halo_color &&
       *bitmap.getAddr32(x, y + 1) != 0)
     return true;  // Touched pixel below.
   return false;
 }
 
 // Strips accelerator character prefixes in |text| if needed, based on |flags|.
-// Returns a range in |text| to underline or ui::Range::InvalidRange() if
+// Returns a range in |text| to underline or gfx::Range::InvalidRange() if
 // underlining is not needed.
-ui::Range StripAcceleratorChars(int flags, base::string16* text) {
+gfx::Range StripAcceleratorChars(int flags, base::string16* text) {
   if (flags & (Canvas::SHOW_PREFIX | Canvas::HIDE_PREFIX)) {
     int char_pos = -1;
     int char_span = 0;
     *text = RemoveAcceleratorChar(*text, '&', &char_pos, &char_span);
     if ((flags & Canvas::SHOW_PREFIX) && char_pos != -1)
-      return ui::Range(char_pos, char_pos + char_span);
+      return gfx::Range(char_pos, char_pos + char_span);
   }
-  return ui::Range::InvalidRange();
+  return gfx::Range::InvalidRange();
 }
 
 // Elides |text| and adjusts |range| appropriately. If eliding causes |range|
 // to no longer point to the same character in |text|, |range| is made invalid.
 void ElideTextAndAdjustRange(const FontList& font_list,
                              int width,
                              base::string16* text,
-                             ui::Range* range) {
+                             gfx::Range* range) {
   const base::char16 start_char =
       (range->IsValid() ? text->at(range->start()) : 0);
   *text = ui::ElideText(*text, font_list, width, ui::ELIDE_AT_END);
   if (!range->IsValid())
     return;
   if (range->start() >= text->length() ||
       text->at(range->start()) != start_char) {
-    *range = ui::Range::InvalidRange();
+    *range = gfx::Range::InvalidRange();
   }
 }
 
 // Updates |render_text| from the specified parameters.
 void UpdateRenderText(const Rect& rect,
                       const base::string16& text,
                       const FontList& font_list,
                       int flags,
                       SkColor color,
                       RenderText* render_text) {
@@ skipping 143 matching lines @@
       wrap_behavior = ui::ELIDE_LONG_WORDS;
 
     std::vector<base::string16> strings;
     ui::ElideRectangleText(adjusted_text,
                            font_list,
                            text_bounds.width(), text_bounds.height(),
                            wrap_behavior,
                            &strings);
 
     for (size_t i = 0; i < strings.size(); i++) {
-      ui::Range range = StripAcceleratorChars(flags, &strings[i]);
+      gfx::Range range = StripAcceleratorChars(flags, &strings[i]);
       UpdateRenderText(rect, strings[i], font_list, flags, color,
                        render_text.get());
       int line_padding = 0;
       if (line_height > 0)
         line_padding = line_height - render_text->GetStringSize().height();
       else
         line_height = render_text->GetStringSize().height();
 
       // TODO(msw|asvitkine): Center Windows multi-line text: crbug.com/107357
 #if !defined(OS_WIN)
       if (i == 0) {
         // TODO(msw|asvitkine): Support multi-line text with varied heights.
         const int text_height = strings.size() * line_height - line_padding;
         rect += Vector2d(0, (text_bounds.height() - text_height) / 2);
       }
 #endif
 
       rect.set_height(line_height - line_padding);
 
       if (range.IsValid())
         render_text->ApplyStyle(UNDERLINE, true, range);
       render_text->SetDisplayRect(rect);
       render_text->Draw(this);
       rect += Vector2d(0, line_height);
     }
   } else {
-    ui::Range range = StripAcceleratorChars(flags, &adjusted_text);
+    gfx::Range range = StripAcceleratorChars(flags, &adjusted_text);
     bool elide_text = ((flags & NO_ELLIPSIS) == 0);
 
 #if defined(OS_LINUX)
     // On Linux, eliding really means fading the end of the string. But only
     // for LTR text. RTL text is still elided (on the left) with "...".
     if (elide_text) {
       render_text->SetText(adjusted_text);
       if (render_text->GetTextDirection() == base::i18n::LEFT_TO_RIGHT) {
         render_text->set_fade_tail(true);
         elide_text = false;
@@ skipping 150 matching lines @@
     size_t desired_characters_to_truncate_from_head,
     const Font& font,
     SkColor color,
     const Rect& display_rect) {
   DrawFadeTruncatingStringRect(text, truncate_mode,
                                desired_characters_to_truncate_from_head,
                                FontList(font), color, display_rect);
 }
 
 }  // namespace gfx