Move Range code to gfx.

ui/gfx/render_text.h

 // 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.
 
 #ifndef UI_GFX_RENDER_TEXT_H_
 #define UI_GFX_RENDER_TEXT_H_
 
 #include <algorithm>
 #include <cstring>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/i18n/rtl.h"
 #include "base/strings/string16.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkRect.h"
-#include "ui/base/range/range.h"
 #include "ui/gfx/break_list.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/point.h"
+#include "ui/gfx/range/range.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/selection_model.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/gfx/vector2d.h"
 
 class SkCanvas;
 class SkDrawLooper;
 struct SkPoint;
 class SkShader;
@@ skipping 54 matching lines @@
  public:
   StyleIterator(const BreakList<SkColor>& colors,
                 const std::vector<BreakList<bool> >& styles);
   ~StyleIterator();
 
   // Get the colors and styles at the current iterator position.
   SkColor color() const { return color_->second; }
   bool style(TextStyle s) const { return style_[s]->second; }
 
   // Get the intersecting range of the current iterator set.
-  ui::Range GetRange() const;
+  gfx::Range GetRange() const;
 
   // Update the iterator to point to colors and styles applicable at |position|.
   void UpdatePosition(size_t position);
 
  private:
   BreakList<SkColor> colors_;
   std::vector<BreakList<bool> > styles_;
 
   BreakList<SkColor>::const_iterator color_;
   std::vector<BreakList<bool>::const_iterator> style_;
@@ skipping 90 matching lines @@
   void set_fade_tail(bool fade_tail) { fade_tail_ = fade_tail; }
   bool fade_tail() const { return fade_tail_; }
 
   bool background_is_transparent() const { return background_is_transparent_; }
   void set_background_is_transparent(bool transparent) {
     background_is_transparent_ = transparent;
   }
 
   const SelectionModel& selection_model() const { return selection_model_; }
 
-  const ui::Range& selection() const { return selection_model_.selection(); }
+  const gfx::Range& selection() const { return selection_model_.selection(); }
 
   size_t cursor_position() const { return selection_model_.caret_pos(); }
   void SetCursorPosition(size_t position);
 
   // Moves the cursor left or right. Cursor movement is visual, meaning that
   // left and right are relative to screen, not the directionality of the text.
   // If |select| is false, the selection start is moved to the same position.
   void MoveCursor(BreakType break_type,
                   VisualCursorDirection direction,
                   bool select);
 
   // Set the selection_model_ to the value of |selection|.
   // The selection range is clamped to text().length() if out of range.
   // Returns true if the cursor position or selection range changed.
   // If any index in |selection_model| is not a cursorable position (not on a
   // grapheme boundary), it is a no-op and returns false.
   bool MoveCursorTo(const SelectionModel& selection_model);
 
   // Move the cursor to the position associated with the clicked point.
   // If |select| is false, the selection start is moved to the same position.
   // Returns true if the cursor position or selection range changed.
   bool MoveCursorTo(const Point& point, bool select);
 
   // Set the selection_model_ based on |range|.
   // If the |range| start or end is greater than text length, it is modified
   // to be the text length.
   // If the |range| start or end is not a cursorable position (not on grapheme
   // boundary), it is a NO-OP and returns false. Otherwise, returns true.
-  bool SelectRange(const ui::Range& range);
+  bool SelectRange(const gfx::Range& range);
 
   // Returns true if the local point is over selected text.
   bool IsPointInSelection(const Point& point);
 
   // Selects no text, keeping the current cursor position and caret affinity.
   void ClearSelection();
 
   // Select the entire text range. If |reversed| is true, the range will end at
   // the logical beginning of the text; this generally shows the leading portion
   // of text that overflows its display area.
   void SelectAll(bool reversed);
 
   // Selects the word at the current cursor position. If there is a non-empty
   // selection, the selection bounds are extended to their nearest word
   // boundaries.
   void SelectWord();
 
-  const ui::Range& GetCompositionRange() const;
-  void SetCompositionRange(const ui::Range& composition_range);
+  const gfx::Range& GetCompositionRange() const;
+  void SetCompositionRange(const gfx::Range& composition_range);
 
   // Set the text color over the entire text or a logical character range.
   // The |range| should be valid, non-reversed, and within [0, text().length()].
   void SetColor(SkColor value);
-  void ApplyColor(SkColor value, const ui::Range& range);
+  void ApplyColor(SkColor value, const gfx::Range& range);
 
   // Set various text styles over the entire text or a logical character range.
   // The respective |style| is applied if |value| is true, or removed if false.
   // The |range| should be valid, non-reversed, and within [0, text().length()].
   void SetStyle(TextStyle style, bool value);
-  void ApplyStyle(TextStyle style, bool value, const ui::Range& range);
+  void ApplyStyle(TextStyle style, bool value, const gfx::Range& range);
 
   // Returns whether this style is enabled consistently across the entire
   // RenderText.
   bool GetStyle(TextStyle style) const;
 
   // Set the text directionality mode and get the text direction yielded.
   void SetDirectionalityMode(DirectionalityMode mode);
   base::i18n::TextDirection GetTextDirection();
 
   // Returns the visual movement direction corresponding to the logical end
@@ skipping 48 matching lines @@
   size_t IndexOfAdjacentGrapheme(size_t index,
                                  LogicalCursorDirection direction);
 
   // Return a SelectionModel with the cursor at the current selection's start.
   // The returned value represents a cursor/caret position without a selection.
   SelectionModel GetSelectionModelForSelectionStart();
 
   // Sets shadows to drawn with text.
   void SetTextShadows(const ShadowValues& shadows);
 
-  typedef std::pair<Font, ui::Range> FontSpan;
+  typedef std::pair<Font, gfx::Range> FontSpan;
   // For testing purposes, returns which fonts were chosen for which parts of
   // the text by returning a vector of Font and Range pairs, where each range
   // specifies the character range for which the corresponding font has been
   // chosen.
   virtual std::vector<FontSpan> GetFontSpansForTesting() = 0;
 
  protected:
   RenderText();
 
   const BreakList<SkColor>& colors() const { return colors_; }
@@ skipping 27 matching lines @@
   // The returned value represents a cursor/caret position without a selection.
   SelectionModel EdgeSelectionModel(VisualCursorDirection direction);
 
   // Sets the selection model, the argument is assumed to be valid.
   virtual void SetSelectionModel(const SelectionModel& model);
 
   // Get the horizontal bounds (relative to the left of the text, not the view)
   // of the glyph starting at |index|. If the glyph is RTL then the returned
   // Range will have is_reversed() true.  (This does not return a Rect because a
   // Rect can't have a negative width.)
-  virtual ui::Range GetGlyphBounds(size_t index) = 0;
+  virtual gfx::Range GetGlyphBounds(size_t index) = 0;
 
   // Get the visual bounds containing the logical substring within the |range|.
   // If |range| is empty, the result is empty. These bounds could be visually
   // discontinuous if the substring is split by a LTR/RTL level change.
   // These bounds are in local coordinates, but may be outside the visible
   // region if the text is longer than the textfield. Subsequent text, cursor,
   // or bounds changes may invalidate returned values.
-  virtual std::vector<Rect> GetSubstringBounds(const ui::Range& range) = 0;
+  virtual std::vector<Rect> GetSubstringBounds(const gfx::Range& range) = 0;
 
   // Convert between indices into |text_| and indices into |obscured_text_|,
   // which differ when the text is obscured. Regardless of whether or not the
   // text is obscured, the character (code point) offsets always match.
   virtual size_t TextIndexToLayoutIndex(size_t index) const = 0;
   virtual size_t LayoutIndexToTextIndex(size_t index) const = 0;
 
   // Return true if cursor can appear in front of the character at |position|,
   // which means it is a grapheme boundary or the first character in the text.
   virtual bool IsCursorablePosition(size_t position) = 0;
@@ skipping 28 matching lines @@
   Vector2d GetAlignmentOffset();
 
   // Applies fade effects to |renderer|.
   void ApplyFadeEffects(internal::SkiaTextRenderer* renderer);
 
   // Applies text shadows to |renderer|.
   void ApplyTextShadows(internal::SkiaTextRenderer* renderer);
 
   // A convenience function to check whether the glyph attached to the caret
   // is within the given range.
-  static bool RangeContainsCaret(const ui::Range& range,
+  static bool RangeContainsCaret(const gfx::Range& range,
                                  size_t caret_pos,
                                  LogicalCursorDirection caret_affinity);
 
  private:
   friend class RenderTextTest;
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, DefaultStyle);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, SetColorAndStyle);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, ApplyColorAndStyle);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, ObscuredText);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, RevealObscuredText);
@@ skipping 62 matching lines @@
   // The color used for drawing selected text.
   SkColor selection_color_;
 
   // The background color used for drawing the selection when focused.
   SkColor selection_background_focused_color_;
 
   // The focus state of the text.
   bool focused_;
 
   // Composition text range.
-  ui::Range composition_range_;
+  gfx::Range composition_range_;
 
   // Color and style breaks, used to color and stylize ranges of text.
   // BreakList positions are stored with text indices, not layout indices.
   // TODO(msw): Expand to support cursor, selection, background, etc. colors.
   BreakList<SkColor> colors_;
   std::vector<BreakList<bool> > styles_;
 
   // Breaks saved without temporary composition and selection styling.
   BreakList<SkColor> saved_colors_;
   BreakList<bool> saved_underlines_;
@@ skipping 36 matching lines @@
 
   // Text shadows to be drawn.
   ShadowValues text_shadows_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderText);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_RENDER_TEXT_H_