Add GetMinimumSize() for Labels and ensure it's zero for empty Links.

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"
+#include "ui/views/test/views_test_base.h"
+#include "ui/views/widget/native_widget.h"
+#include "ui/views/widget/root_view.h"
 
 namespace views {
 
-class StyledLabelTest : public testing::Test, public StyledLabelListener {
+class StyledLabelTest : public ViewsTestBase, public StyledLabelListener {
  public:
   StyledLabelTest() {}
   virtual ~StyledLabelTest() {}
 
   // StyledLabelListener implementation.
   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));
+    styled_->set_owned_by_client();
   }
 
   int StyledLabelContentHeightForWidth(int w) {
     return styled_->GetHeightForWidth(w) - styled_->GetInsets().height();
   }
 
  private:
   scoped_ptr<StyledLabel> styled_;
 
   DISALLOW_COPY_AND_ASSIGN(StyledLabelTest);
@@ skipping 63 matching lines @@
 
   // Also respect the border.
   styled()->set_border(Border::CreateEmptyBorder(3, 3, 3, 3));
   styled()->SetBounds(
       0,
       0,
       styled()->GetInsets().width() + label_preferred_size.width(),
       styled()->GetInsets().height() + 2 * label_preferred_size.height());
   styled()->Layout();
   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());
+  EXPECT_EQ(3, styled()->child_at(0)->x());
+  EXPECT_EQ(3, styled()->child_at(0)->y());
+  EXPECT_EQ(styled()->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);
+
+  // By default styled() should not have a focus border because it's not drawn.
+  EXPECT_TRUE(styled()->GetInsets().empty());
+
+  // Without links, there should be no focus border even when drawn.
+  scoped_ptr<Widget> widget(new Widget);
+  Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  widget->Init(params);
+  internal::RootView* root =
+      static_cast<internal::RootView*>(widget->GetRootView());
+  root->AddChildView(styled());
+  EXPECT_TRUE(styled()->GetInsets().empty());
+
+  // Now let's add some links.
   styled()->AddStyleRange(gfx::Range(0, 1),
                           StyledLabel::RangeStyleInfo::CreateForLink());
   styled()->AddStyleRange(gfx::Range(1, 2),
                           StyledLabel::RangeStyleInfo::CreateForLink());
   styled()->AddStyleRange(gfx::Range(10, 11),
                           StyledLabel::RangeStyleInfo::CreateForLink());
   styled()->AddStyleRange(gfx::Range(12, 13),
                           StyledLabel::RangeStyleInfo::CreateForLink());
 
+  // Now there should be a focus border because there are non-empty Links.
+  EXPECT_FALSE(styled()->GetInsets().empty());
+
+  // Verify layout creates the right number of children.
   styled()->SetBounds(0, 0, 1000, 1000);
   styled()->Layout();
-  ASSERT_EQ(7, styled()->child_count());
+  EXPECT_EQ(7, styled()->child_count());
+
+  // Removing styled() from the root should remove the focus border.
+  root->RemoveChildView(styled());
+  EXPECT_TRUE(styled()->GetInsets().empty());
 }
 
 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()),
       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());
+  EXPECT_EQ(0, 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 breaked");
+  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()),
       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());
+  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()),
@@ skipping 31 matching lines @@
   // Set the width so |bold_text| doesn't fit on a single line with bold style,
   // but does with normal font style.
   int styled_width = (normal_label_size.width() + bold_label_size.width()) / 2;
   int pref_height = styled()->GetHeightForWidth(styled_width);
 
   // Sanity check that |bold_text| with normal font style would fit on a single
   // line in a styled label with width |styled_width|.
   StyledLabel unstyled(ASCIIToUTF16(bold_text), this);
   unstyled.SetBounds(0, 0, styled_width, pref_height);
   unstyled.Layout();
-  ASSERT_EQ(1, unstyled.child_count());
+  EXPECT_EQ(1, unstyled.child_count());
 
   styled()->SetBounds(0, 0, styled_width, pref_height);
   styled()->Layout();
 
   ASSERT_EQ(3, styled()->child_count());
 
   // The bold text should be broken up into two parts.
   ASSERT_EQ(std::string(Label::kViewClassName),
             styled()->child_at(0)->GetClassName());
   EXPECT_EQ(gfx::Font::BOLD,
             static_cast<Label*>(styled()->child_at(0))->font().GetStyle());
   ASSERT_EQ(std::string(Label::kViewClassName),
             styled()->child_at(1)->GetClassName());
   EXPECT_EQ(gfx::Font::BOLD,
             static_cast<Label*>(styled()->child_at(1))->font().GetStyle());
   ASSERT_EQ(std::string(Label::kViewClassName),
             styled()->child_at(2)->GetClassName());
   EXPECT_EQ(gfx::Font::NORMAL,
             static_cast<Label*>(styled()->child_at(2))->font().GetStyle());
 
   // The second bold part should start on a new line.
-  EXPECT_EQ(0, styled()->child_at(0)->bounds().x());
-  EXPECT_EQ(0, styled()->child_at(1)->bounds().x());
-  EXPECT_EQ(styled()->child_at(1)->bounds().right() - 2,
-            styled()->child_at(2)->bounds().x());
+  EXPECT_EQ(0, styled()->child_at(0)->x());
+  EXPECT_EQ(0, styled()->child_at(1)->x());
+  EXPECT_EQ(styled()->child_at(1)->bounds().right(),
+            styled()->child_at(2)->x());
 }
 
 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;
@@ skipping 67 matching lines @@
   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);
   styled()->Layout();
 
   EXPECT_EQ(label_preferred_size.width(), styled()->width());
 
   ASSERT_EQ(5, styled()->child_count());
-  EXPECT_EQ(0, styled()->child_at(0)->bounds().x());
-  EXPECT_EQ(styled()->child_at(0)->bounds().right() - 2,
-            styled()->child_at(1)->bounds().x());
-  EXPECT_EQ(0, styled()->child_at(2)->bounds().x());
-  EXPECT_EQ(styled()->child_at(2)->bounds().right() - 2,
-            styled()->child_at(3)->bounds().x());
-  EXPECT_EQ(0, styled()->child_at(4)->bounds().x());
+  EXPECT_EQ(0, styled()->child_at(0)->x());
+  EXPECT_EQ(styled()->child_at(0)->bounds().right(),
+            styled()->child_at(1)->x());
+  EXPECT_EQ(0, styled()->child_at(2)->x());
+  EXPECT_EQ(styled()->child_at(2)->bounds().right(),
+            styled()->child_at(3)->x());
+  EXPECT_EQ(0, styled()->child_at(4)->x());
 
   string16 tooltip;
   EXPECT_TRUE(
       styled()->child_at(1)->GetTooltipText(gfx::Point(1, 1), &tooltip));
   EXPECT_EQ(ASCIIToUTF16("tooltip"), tooltip);
   EXPECT_TRUE(
       styled()->child_at(2)->GetTooltipText(gfx::Point(1, 1), &tooltip));
   EXPECT_EQ(ASCIIToUTF16("tooltip"), tooltip);
 }
 
 TEST_F(StyledLabelTest, HandleEmptyLayout) {
-  const std::string text("This is a test block of text, ");
+  const std::string text("This is a test block of text.");
   InitStyledLabel(text);
   styled()->Layout();
-  ASSERT_EQ(0, styled()->child_count());
+  EXPECT_EQ(0, styled()->child_count());
 }
 
 }  // namespace