Switch gfx::Range to use uint32_t instead of size_t.

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 <stddef.h>
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 166 matching lines @@
   styled()->SetBounds(0, 0, 1000, 1000);
   styled()->Layout();
   EXPECT_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(
-      gfx::Range(text.size(), text.size() + link_text.size()),
+      gfx::Range(static_cast<uint32_t>(text.size()),
+                 static_cast<uint32_t>(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());
   // The label has no focus border while the link (and thus overall styled
   // label) does, so the label should be inset by the width of the focus border.
   EXPECT_EQ(Label::kFocusBorderPadding, styled()->child_at(0)->x());
   EXPECT_EQ(0, styled()->child_at(1)->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 broken");
   InitStyledLabel(text + unbreakable_text);
   StyledLabel::RangeStyleInfo style_info;
   style_info.disable_line_wrapping = true;
   styled()->AddStyleRange(
-      gfx::Range(text.size(), text.size() + unbreakable_text.size()),
+      gfx::Range(static_cast<uint32_t>(text.size()),
+                 static_cast<uint32_t>(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)->x());
   EXPECT_EQ(0, styled()->child_at(1)->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(
-      gfx::Range(text.size(), text.size() + underlined_text.size()),
+      gfx::Range(static_cast<uint32_t>(text.size()),
+                 static_cast<uint32_t>(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_list().GetFontStyle());
 }
 
 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(gfx::Range(0, bold_text.size()), style_info);
+  styled()->AddStyleRange(
+      gfx::Range(0u, static_cast<uint32_t>(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.SetFontList(label.font_list().DeriveWithStyle(gfx::Font::BOLD));
   const gfx::Size bold_label_size = label.GetPreferredSize();
 
   ASSERT_GE(bold_label_size.width(), normal_label_size.width());
 
@@ skipping 39 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(gfx::Range(0, text_red.size()), style_info_red);
+  styled()->AddStyleRange(
+      gfx::Range(0u, static_cast<uint32_t>(text_red.size())), style_info_red);
 
   StyledLabel::RangeStyleInfo style_info_link =
       StyledLabel::RangeStyleInfo::CreateForLink();
-  styled()->AddStyleRange(gfx::Range(text_red.size(),
-                                    text_red.size() + text_link.size()),
-                          style_info_link);
+  styled()->AddStyleRange(
+      gfx::Range(static_cast<uint32_t>(text_red.size()),
+                 static_cast<uint32_t>(text_red.size() + text_link.size())),
+      style_info_link);
 
   styled()->SetBounds(0, 0, 1000, 1000);
   styled()->Layout();
 
   Widget* widget = new Widget();
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
   View* container = new View();
   widget->SetContentsView(container);
   container->AddChildView(styled());
@@ skipping 35 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(
-      gfx::Range(tooltip_start, tooltip_start + tooltip_text.size()),
+      gfx::Range(static_cast<uint32_t>(tooltip_start),
+                 static_cast<uint32_t>(tooltip_start + tooltip_text.size())),
       tooltip_style);
-  styled()->AddStyleRange(gfx::Range(link_start, link_start + link_text.size()),
-                          StyledLabel::RangeStyleInfo::CreateForLink());
+  styled()->AddStyleRange(
+      gfx::Range(static_cast<uint32_t>(link_start),
+                 static_cast<uint32_t>(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());
 
   styled()->SetBounds(0, 0, label_preferred_size.width(), pref_height);
@@ skipping 95 matching lines @@
   // all controls should be recreated
   styled()->SetText(another_text);
   int updated_height = styled()->GetHeightForWidth(styled()->width());
   EXPECT_NE(updated_height, real_height);
   View* first_child_after_text_update = styled()->has_children() ?
       styled()->child_at(0) : nullptr;
   EXPECT_NE(first_child_after_text_update, first_child_after_layout);
 }
 
 }  // namespace views