Move Range code to gfx.

ui/gfx/render_text_unittest.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.h"
 
 #include <algorithm>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 22 matching lines @@
 // Various weak, LTR, RTL, and Bidi string cases with three characters each.
 const wchar_t kWeak[] =      L" . ";
 const wchar_t kLtr[] =       L"abc";
 const wchar_t kLtrRtl[] =    L"a" L"\x5d0\x5d1";
 const wchar_t kLtrRtlLtr[] = L"a" L"\x5d1" L"b";
 const wchar_t kRtl[] =       L"\x5d0\x5d1\x5d2";
 const wchar_t kRtlLtr[] =    L"\x5d0\x5d1" L"a";
 const wchar_t kRtlLtrRtl[] = L"\x5d0" L"a" L"\x5d1";
 
 // 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();
 }
 
 base::string16 GetSelectedText(RenderText* render_text) {
   return render_text->text().substr(render_text->selection().GetMin(),
                                     render_text->selection().length());
 }
 
 // A test utility function to set the application default text direction.
 void SetRTL(bool rtl) {
@@ skipping 61 matching lines @@
     if (i >= 1)
       EXPECT_TRUE(render_text->styles()[STRIKE].EqualsValueForTesting(true));
   }
 }
 
 TEST_F(RenderTextTest, ApplyColorAndStyle) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(ASCIIToUTF16("012345678"));
 
   // Apply a ranged color and style and check the resulting breaks.
-  render_text->ApplyColor(SK_ColorRED, ui::Range(1, 4));
-  render_text->ApplyStyle(BOLD, true, ui::Range(2, 5));
+  render_text->ApplyColor(SK_ColorRED, gfx::Range(1, 4));
+  render_text->ApplyStyle(BOLD, true, gfx::Range(2, 5));
   std::vector<std::pair<size_t, SkColor> > expected_color;
   expected_color.push_back(std::pair<size_t, SkColor>(0, SK_ColorBLACK));
   expected_color.push_back(std::pair<size_t, SkColor>(1, SK_ColorRED));
   expected_color.push_back(std::pair<size_t, SkColor>(4, SK_ColorBLACK));
   EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
   std::vector<std::pair<size_t, bool> > expected_style;
   expected_style.push_back(std::pair<size_t, bool>(0, false));
   expected_style.push_back(std::pair<size_t, bool>(2, true));
   expected_style.push_back(std::pair<size_t, bool>(5, false));
   EXPECT_TRUE(render_text->styles()[BOLD].EqualsForTesting(expected_style));
 
   // Ensure setting a color and style overrides the ranged colors and styles.
   render_text->SetColor(SK_ColorBLUE);
   EXPECT_TRUE(render_text->colors().EqualsValueForTesting(SK_ColorBLUE));
   render_text->SetStyle(BOLD, false);
   EXPECT_TRUE(render_text->styles()[BOLD].EqualsValueForTesting(false));
 
   // Apply a color and style over the text end and check the resulting breaks.
   // (INT_MAX should be used instead of the text length for the range end)
   const size_t text_length = render_text->text().length();
-  render_text->ApplyColor(SK_ColorRED, ui::Range(0, text_length));
-  render_text->ApplyStyle(BOLD, true, ui::Range(2, text_length));
+  render_text->ApplyColor(SK_ColorRED, gfx::Range(0, text_length));
+  render_text->ApplyStyle(BOLD, true, gfx::Range(2, text_length));
   std::vector<std::pair<size_t, SkColor> > expected_color_end;
   expected_color_end.push_back(std::pair<size_t, SkColor>(0, SK_ColorRED));
   EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color_end));
   std::vector<std::pair<size_t, bool> > expected_style_end;
   expected_style_end.push_back(std::pair<size_t, bool>(0, false));
   expected_style_end.push_back(std::pair<size_t, bool>(2, true));
   EXPECT_TRUE(render_text->styles()[BOLD].EqualsForTesting(expected_style_end));
 
   // Ensure ranged values adjust to accommodate text length changes.
-  render_text->ApplyStyle(ITALIC, true, ui::Range(0, 2));
-  render_text->ApplyStyle(ITALIC, true, ui::Range(3, 6));
-  render_text->ApplyStyle(ITALIC, true, ui::Range(7, text_length));
+  render_text->ApplyStyle(ITALIC, true, gfx::Range(0, 2));
+  render_text->ApplyStyle(ITALIC, true, gfx::Range(3, 6));
+  render_text->ApplyStyle(ITALIC, true, gfx::Range(7, text_length));
   std::vector<std::pair<size_t, bool> > expected_italic;
   expected_italic.push_back(std::pair<size_t, bool>(0, true));
   expected_italic.push_back(std::pair<size_t, bool>(2, false));
   expected_italic.push_back(std::pair<size_t, bool>(3, true));
   expected_italic.push_back(std::pair<size_t, bool>(6, false));
   expected_italic.push_back(std::pair<size_t, bool>(7, true));
   EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
 
   // Truncating the text should trim any corresponding breaks.
   render_text->SetText(ASCIIToUTF16("0123456"));
   expected_italic.resize(4);
   EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
   render_text->SetText(ASCIIToUTF16("01234"));
   expected_italic.resize(3);
   EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
 
   // Appending text should extend the terminal styles without changing breaks.
   render_text->SetText(ASCIIToUTF16("012345678"));
   EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
 }
 
 #if defined(OS_LINUX)
 TEST_F(RenderTextTest, PangoAttributes) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(ASCIIToUTF16("012345678"));
 
   // Apply ranged BOLD/ITALIC styles and check the resulting Pango attributes.
-  render_text->ApplyStyle(BOLD, true, ui::Range(2, 4));
-  render_text->ApplyStyle(ITALIC, true, ui::Range(1, 3));
+  render_text->ApplyStyle(BOLD, true, gfx::Range(2, 4));
+  render_text->ApplyStyle(ITALIC, true, gfx::Range(1, 3));
 
   struct {
     int start;
     int end;
     bool bold;
     bool italic;
   } cases[] = {
     { 0, 1,       false, false },
     { 1, 2,       false, true  },
     { 2, 3,       true,  true  },
@@ skipping 30 matching lines @@
 // TODO(asvitkine): Cursor movements tests disabled on Mac because RenderTextMac
 //                  does not implement this yet. http://crbug.com/131618
 #if !defined(OS_MACOSX)
 void TestVisualCursorMotionInObscuredField(RenderText* render_text,
                                            const base::string16& text,
                                            bool select) {
   ASSERT_TRUE(render_text->obscured());
   render_text->SetText(text);
   int len = text.length();
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, select);
-  EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : len, len), CURSOR_FORWARD),
+  EXPECT_EQ(SelectionModel(gfx::Range(select ? 0 : len, len), CURSOR_FORWARD),
             render_text->selection_model());
   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, select);
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
   for (int j = 1; j <= len; ++j) {
     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, select);
-    EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : j, j), CURSOR_BACKWARD),
+    EXPECT_EQ(SelectionModel(gfx::Range(select ? 0 : j, j), CURSOR_BACKWARD),
               render_text->selection_model());
   }
   for (int j = len - 1; j >= 0; --j) {
     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, select);
-    EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : j, j), CURSOR_FORWARD),
+    EXPECT_EQ(SelectionModel(gfx::Range(select ? 0 : j, j), CURSOR_FORWARD),
               render_text->selection_model());
   }
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, select);
-  EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : len, len), CURSOR_FORWARD),
+  EXPECT_EQ(SelectionModel(gfx::Range(select ? 0 : len, len), CURSOR_FORWARD),
             render_text->selection_model());
   render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, select);
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 }
 
 TEST_F(RenderTextTest, ObscuredText) {
   const base::string16 seuss = ASCIIToUTF16("hop on pop");
   const base::string16 no_seuss = ASCIIToUTF16("**********");
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 
@@ skipping 603 matching lines @@
   }
 }
 
 TEST_F(RenderTextTest, SelectAll) {
   const wchar_t* const cases[] =
       { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl };
 
   // Ensure that SelectAll respects the |reversed| argument regardless of
   // application locale and text content directionality.
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
-  const SelectionModel expected_reversed(ui::Range(3, 0), CURSOR_FORWARD);
-  const SelectionModel expected_forwards(ui::Range(0, 3), CURSOR_BACKWARD);
+  const SelectionModel expected_reversed(gfx::Range(3, 0), CURSOR_FORWARD);
+  const SelectionModel expected_forwards(gfx::Range(0, 3), CURSOR_BACKWARD);
   const bool was_rtl = base::i18n::IsRTL();
 
   for (size_t i = 0; i < 2; ++i) {
     SetRTL(!base::i18n::IsRTL());
     // Test that an empty string produces an empty selection model.
     render_text->SetText(base::string16());
     EXPECT_EQ(render_text->selection_model(), SelectionModel());
 
     // Test the weak, LTR, RTL, and Bidi string cases.
     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(cases); j++) {
       render_text->SetText(WideToUTF16(cases[j]));
       render_text->SelectAll(false);
       EXPECT_EQ(render_text->selection_model(), expected_forwards);
       render_text->SelectAll(true);
       EXPECT_EQ(render_text->selection_model(), expected_reversed);
     }
   }
 
   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
 }
 
   TEST_F(RenderTextTest, MoveCursorLeftRightWithSelection) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
   // Left arrow on select ranging (6, 4).
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(ui::Range(6), render_text->selection());
+  EXPECT_EQ(gfx::Range(6), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(ui::Range(4), render_text->selection());
+  EXPECT_EQ(gfx::Range(4), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(ui::Range(5), render_text->selection());
+  EXPECT_EQ(gfx::Range(5), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(ui::Range(6), render_text->selection());
+  EXPECT_EQ(gfx::Range(6), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, true);
-  EXPECT_EQ(ui::Range(6, 5), render_text->selection());
+  EXPECT_EQ(gfx::Range(6, 5), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, true);
-  EXPECT_EQ(ui::Range(6, 4), render_text->selection());
+  EXPECT_EQ(gfx::Range(6, 4), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(ui::Range(6), render_text->selection());
+  EXPECT_EQ(gfx::Range(6), render_text->selection());
 
   // Right arrow on select ranging (4, 6).
   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(ui::Range(0), render_text->selection());
+  EXPECT_EQ(gfx::Range(0), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(ui::Range(1), render_text->selection());
+  EXPECT_EQ(gfx::Range(1), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(ui::Range(2), render_text->selection());
+  EXPECT_EQ(gfx::Range(2), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(ui::Range(3), render_text->selection());
+  EXPECT_EQ(gfx::Range(3), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(ui::Range(5), render_text->selection());
+  EXPECT_EQ(gfx::Range(5), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(ui::Range(4), render_text->selection());
+  EXPECT_EQ(gfx::Range(4), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, true);
-  EXPECT_EQ(ui::Range(4, 5), render_text->selection());
+  EXPECT_EQ(gfx::Range(4, 5), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, true);
-  EXPECT_EQ(ui::Range(4, 6), render_text->selection());
+  EXPECT_EQ(gfx::Range(4, 6), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(ui::Range(4), render_text->selection());
+  EXPECT_EQ(gfx::Range(4), render_text->selection());
 }
 #endif  // !defined(OS_MACOSX)
 
 // TODO(xji): Make these work on Windows.
 #if defined(OS_LINUX)
 void MoveLeftRightByWordVerifier(RenderText* render_text,
                                  const wchar_t* str) {
   render_text->SetText(WideToUTF16(str));
 
   // Test moving by word from left ro right.
@@ skipping 266 matching lines @@
 
   const int plain_width = render_text->GetStringSize().width();
   EXPECT_GT(plain_width, 0);
 
   // Apply a bold style and check that the new width is greater.
   render_text->SetStyle(BOLD, true);
   const int bold_width = render_text->GetStringSize().width();
   EXPECT_GT(bold_width, plain_width);
 
   // Now, apply a plain style over the first word only.
-  render_text->ApplyStyle(BOLD, false, ui::Range(0, 5));
+  render_text->ApplyStyle(BOLD, false, gfx::Range(0, 5));
   const int plain_bold_width = render_text->GetStringSize().width();
   EXPECT_GT(plain_bold_width, plain_width);
   EXPECT_LT(plain_bold_width, bold_width);
 }
 
 TEST_F(RenderTextTest, StringSizeHeight) {
   base::string16 cases[] = {
     WideToUTF16(L"Hello World!"),  // English
     WideToUTF16(L"\x6328\x62f6"),  // Japanese
     WideToUTF16(L"\x0915\x093f"),  // Hindi
@@ skipping 218 matching lines @@
     { 12, 12, 13 },
     { 13, 13, 16 },
     { 14, 13, 16 },
     { 15, 13, 16 },
     { 16, 13, 16 },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     render_text->SetCursorPosition(cases[i].cursor);
     render_text->SelectWord();
-    EXPECT_EQ(ui::Range(cases[i].selection_start, cases[i].selection_end),
+    EXPECT_EQ(gfx::Range(cases[i].selection_start, cases[i].selection_end),
               render_text->selection());
   }
 }
 
 // Make sure the last word is selected when the cursor is at text.length().
 TEST_F(RenderTextTest, LastWordSelected) {
   const std::string kTestURL1 = "http://www.google.com";
   const std::string kTestURL2 = "http://www.google.com/something/";
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
@@ skipping 12 matching lines @@
 }
 
 // When given a non-empty selection, SelectWord should expand the selection to
 // nearest word boundaries.
 TEST_F(RenderTextTest, SelectMultipleWords) {
   const std::string kTestURL = "http://www.google.com";
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   render_text->SetText(ASCIIToUTF16(kTestURL));
-  render_text->SelectRange(ui::Range(16, 20));
+  render_text->SelectRange(gfx::Range(16, 20));
   render_text->SelectWord();
   EXPECT_EQ(ASCIIToUTF16("google.com"), GetSelectedText(render_text.get()));
   EXPECT_FALSE(render_text->selection().is_reversed());
 
   // SelectWord should preserve the selection direction.
-  render_text->SelectRange(ui::Range(20, 16));
+  render_text->SelectRange(gfx::Range(20, 16));
   render_text->SelectWord();
   EXPECT_EQ(ASCIIToUTF16("google.com"), GetSelectedText(render_text.get()));
   EXPECT_TRUE(render_text->selection().is_reversed());
 }
 
 // TODO(asvitkine): Cursor movements tests disabled on Mac because RenderTextMac
 //                  does not implement this yet. http://crbug.com/131618
 #if !defined(OS_MACOSX)
 TEST_F(RenderTextTest, DisplayRectShowsCursorLTR) {
   ASSERT_FALSE(base::i18n::IsRTL());
@@ skipping 118 matching lines @@
     L"\x633\x627"
   };
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->set_selection_color(SK_ColorRED);
   Canvas canvas;
 
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     render_text->SetText(WideToUTF16(kTestStrings[i]));
     const int expected_width = render_text->GetStringSize().width();
-    render_text->MoveCursorTo(SelectionModel(ui::Range(0, 1), CURSOR_FORWARD));
+    render_text->MoveCursorTo(SelectionModel(gfx::Range(0, 1), CURSOR_FORWARD));
     EXPECT_EQ(expected_width, render_text->GetStringSize().width());
     // Draw the text. It shouldn't hit any DCHECKs or crash.
     // See http://crbug.com/214150
     render_text->Draw(&canvas);
     render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
   }
 }
 
 }  // namespace gfx