Move Range code to gfx.

ui/views/controls/styled_label_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/views/controls/link.h"
 #include "ui/views/controls/styled_label.h"
 #include "ui/views/controls/styled_label_listener.h"
 
 namespace views {
 
 class StyledLabelTest : public testing::Test, public StyledLabelListener {
  public:
   StyledLabelTest() {}
   virtual ~StyledLabelTest() {}
 
   // StyledLabelListener implementation.
-  virtual void StyledLabelLinkClicked(const ui::Range& range,
+  virtual void StyledLabelLinkClicked(const gfx::Range& range,
                                       int event_flags) OVERRIDE {}
 
  protected:
   StyledLabel* styled() { return styled_.get(); }
 
   void InitStyledLabel(const std::string& ascii_text) {
     styled_.reset(new StyledLabel(ASCIIToUTF16(ascii_text), this));
   }
 
   int StyledLabelContentHeightForWidth(int w) {
@@ skipping 79 matching lines @@
   ASSERT_EQ(2, styled()->child_count());
   EXPECT_EQ(3, styled()->child_at(0)->bounds().x());
   EXPECT_EQ(3, styled()->child_at(0)->bounds().y());
   EXPECT_EQ(styled()->bounds().height() - 3,
             styled()->child_at(1)->bounds().bottom());
 }
 
 TEST_F(StyledLabelTest, CreateLinks) {
   const std::string text("This is a test block of text.");
   InitStyledLabel(text);
-  styled()->AddStyleRange(ui::Range(0, 1),
+  styled()->AddStyleRange(gfx::Range(0, 1),
                           StyledLabel::RangeStyleInfo::CreateForLink());
-  styled()->AddStyleRange(ui::Range(1, 2),
+  styled()->AddStyleRange(gfx::Range(1, 2),
                           StyledLabel::RangeStyleInfo::CreateForLink());
-  styled()->AddStyleRange(ui::Range(10, 11),
+  styled()->AddStyleRange(gfx::Range(10, 11),
                           StyledLabel::RangeStyleInfo::CreateForLink());
-  styled()->AddStyleRange(ui::Range(12, 13),
+  styled()->AddStyleRange(gfx::Range(12, 13),
                           StyledLabel::RangeStyleInfo::CreateForLink());
 
   styled()->SetBounds(0, 0, 1000, 1000);
   styled()->Layout();
   ASSERT_EQ(7, styled()->child_count());
 }
 
 TEST_F(StyledLabelTest, DontBreakLinks) {
   const std::string text("This is a test block of text, ");
   const std::string link_text("and this should be a link");
   InitStyledLabel(text + link_text);
   styled()->AddStyleRange(
-      ui::Range(text.size(), text.size() + link_text.size()),
+      gfx::Range(text.size(), text.size() + link_text.size()),
       StyledLabel::RangeStyleInfo::CreateForLink());
 
   Label label(ASCIIToUTF16(text + link_text.substr(0, link_text.size() / 2)));
   gfx::Size label_preferred_size = label.GetPreferredSize();
   int pref_height = styled()->GetHeightForWidth(label_preferred_size.width());
   EXPECT_EQ(label_preferred_size.height() * 2,
             pref_height - styled()->GetInsets().height());
 
   styled()->SetBounds(0, 0, label_preferred_size.width(), pref_height);
   styled()->Layout();
   ASSERT_EQ(2, styled()->child_count());
   EXPECT_EQ(0, styled()->child_at(0)->bounds().x());
   EXPECT_EQ(0, styled()->child_at(1)->bounds().x());
 }
 
 TEST_F(StyledLabelTest, StyledRangeWithDisabledLineWrapping) {
   const std::string text("This is a test block of text, ");
   const std::string unbreakable_text("and this should not be breaked");
   InitStyledLabel(text + unbreakable_text);
   StyledLabel::RangeStyleInfo style_info;
   style_info.disable_line_wrapping = true;
   styled()->AddStyleRange(
-      ui::Range(text.size(), text.size() + unbreakable_text.size()),
+      gfx::Range(text.size(), text.size() + unbreakable_text.size()),
       style_info);
 
   Label label(ASCIIToUTF16(
       text + unbreakable_text.substr(0, unbreakable_text.size() / 2)));
   gfx::Size label_preferred_size = label.GetPreferredSize();
   int pref_height = styled()->GetHeightForWidth(label_preferred_size.width());
   EXPECT_EQ(label_preferred_size.height() * 2,
             pref_height - styled()->GetInsets().height());
 
   styled()->SetBounds(0, 0, label_preferred_size.width(), pref_height);
   styled()->Layout();
   ASSERT_EQ(2, styled()->child_count());
   EXPECT_EQ(0, styled()->child_at(0)->bounds().x());
   EXPECT_EQ(0, styled()->child_at(1)->bounds().x());
 }
 
 TEST_F(StyledLabelTest, StyledRangeUnderlined) {
   const std::string text("This is a test block of text, ");
   const std::string underlined_text("and this should be undelined");
   InitStyledLabel(text + underlined_text);
   StyledLabel::RangeStyleInfo style_info;
   style_info.font_style = gfx::Font::UNDERLINE;
   styled()->AddStyleRange(
-      ui::Range(text.size(), text.size() + underlined_text.size()),
+      gfx::Range(text.size(), text.size() + underlined_text.size()),
       style_info);
 
   styled()->SetBounds(0, 0, 1000, 1000);
   styled()->Layout();
 
   ASSERT_EQ(2, styled()->child_count());
   ASSERT_EQ(std::string(Label::kViewClassName),
             styled()->child_at(1)->GetClassName());
   EXPECT_EQ(gfx::Font::UNDERLINE,
             static_cast<Label*>(styled()->child_at(1))->font().GetStyle());
 }
 
 TEST_F(StyledLabelTest, StyledRangeBold) {
   const std::string bold_text(
       "This is a block of text whose style will be set to BOLD in the test");
   const std::string text(" normal text");
   InitStyledLabel(bold_text + text);
 
   StyledLabel::RangeStyleInfo style_info;
   style_info.font_style = gfx::Font::BOLD;
-  styled()->AddStyleRange(ui::Range(0, bold_text.size()), style_info);
+  styled()->AddStyleRange(gfx::Range(0, bold_text.size()), style_info);
 
   // Calculate the bold text width if it were a pure label view, both with bold
   // and normal style.
   Label label(ASCIIToUTF16(bold_text));
   const gfx::Size normal_label_size = label.GetPreferredSize();
   label.SetFont(label.font().DeriveFont(0, gfx::Font::BOLD));
   const gfx::Size bold_label_size = label.GetPreferredSize();
 
   ASSERT_GE(bold_label_size.width(), normal_label_size.width());
 
@@ skipping 36 matching lines @@
 }
 
 TEST_F(StyledLabelTest, Color) {
   const std::string text_red("RED");
   const std::string text_link("link");
   const std::string text("word");
   InitStyledLabel(text_red + text_link + text);
 
   StyledLabel::RangeStyleInfo style_info_red;
   style_info_red.color = SK_ColorRED;
-  styled()->AddStyleRange(ui::Range(0, text_red.size()), style_info_red);
+  styled()->AddStyleRange(gfx::Range(0, text_red.size()), style_info_red);
 
   StyledLabel::RangeStyleInfo style_info_link =
       StyledLabel::RangeStyleInfo::CreateForLink();
-  styled()->AddStyleRange(ui::Range(text_red.size(),
+  styled()->AddStyleRange(gfx::Range(text_red.size(),
                                     text_red.size() + text_link.size()),
                           style_info_link);
 
   // Obtain the default text color for a label.
   Label label(ASCIIToUTF16(text));
   const SkColor kDefaultTextColor = label.enabled_color();
 
   // Obtain the default text color for a link;
   Link link(ASCIIToUTF16(text_link));
   const SkColor kDefaultLinkColor = link.enabled_color();
@@ skipping 33 matching lines @@
   const std::string link_text("and this should be a link");
 
   const size_t tooltip_start = text.size();
   const size_t link_start =
       text.size() + tooltip_text.size() + normal_text.size();
 
   InitStyledLabel(text + tooltip_text + normal_text + link_text);
   StyledLabel::RangeStyleInfo tooltip_style;
   tooltip_style.tooltip = ASCIIToUTF16("tooltip");
   styled()->AddStyleRange(
-      ui::Range(tooltip_start, tooltip_start + tooltip_text.size()),
+      gfx::Range(tooltip_start, tooltip_start + tooltip_text.size()),
       tooltip_style);
-  styled()->AddStyleRange(ui::Range(link_start, link_start + link_text.size()),
+  styled()->AddStyleRange(gfx::Range(link_start, link_start + link_text.size()),
                           StyledLabel::RangeStyleInfo::CreateForLink());
 
   // Break line inside the range with the tooltip.
   Label label(ASCIIToUTF16(
        text + tooltip_text.substr(0, tooltip_text.size() - 3)));
   gfx::Size label_preferred_size = label.GetPreferredSize();
   int pref_height = styled()->GetHeightForWidth(label_preferred_size.width());
   EXPECT_EQ(label_preferred_size.height() * 3,
             pref_height - styled()->GetInsets().height());
 
@@ skipping 21 matching lines @@
 }
 
 TEST_F(StyledLabelTest, HandleEmptyLayout) {
   const std::string text("This is a test block of text, ");
   InitStyledLabel(text);
   styled()->Layout();
   ASSERT_EQ(0, styled()->child_count());
 }
 
 }  // namespace