Fixed BubbleBorder sizing problems & added unit tests.

ui/views/bubble/bubble_border_unittest.cc

Index: ui/views/bubble/bubble_border_unittest.cc
diff --git a/ui/views/bubble/bubble_border_unittest.cc b/ui/views/bubble/bubble_border_unittest.cc
index b8838f656ba177e70a6cac271754729b726c250b..189622bcb118505f95f4480001928a08baad5efc 100644
--- a/ui/views/bubble/bubble_border_unittest.cc
+++ b/ui/views/bubble/bubble_border_unittest.cc
@@ -4,11 +4,109 @@
 
 #include "ui/views/bubble/bubble_border.h"
 
+#include "base/memory/scoped_ptr.h"
 #include "ui/views/test/views_test_base.h"
 
 namespace views {
 
-typedef ViewsTestBase BubbleBorderTest;
+class BubbleBorderTest : public views::ViewsTestBase {
+ public:
+  const int kStroke = views::BubbleBorder::kStroke;
+
+  const gfx::Size kSmallSize = gfx::Size(1, 1);
+  const gfx::Size kMediumSize = gfx::Size(50, 50);
+
+  const gfx::Rect kGetOriginAnchor = gfx::Rect(100, 100, 20, 20);

[msw, 2014/08/19 21:35:40]

nit: rename this kAnchor.

[bruthig, 2014/08/22 19:45:04]

Done.

+  const gfx::Size kGetOriginContentsSize = gfx::Size(50, 50);

[msw, 2014/08/19 21:35:40]

nit: remove this and just use kMediumSize.

[bruthig, 2014/08/22 19:45:04]

Done.

+
+  BubbleBorderTest() {}
+  virtual ~BubbleBorderTest() {}
+
+ protected:
+  // Sets the bubble alignment.
+  void SetAlignment(BubbleBorder::BubbleAlignment alignment) {
+    bubble_border_->set_alignment(alignment);
+  }
+
+  // Sets the arrow paint type.
+  void SetPaintArrow(BubbleBorder::ArrowPaintType value) {
+    bubble_border_->set_paint_arrow(value);
+  }
+
+  // Gets the arrow thickness.
+  int GetArrowThickness() const {
+    return bubble_border_->GetArrowThickness();
+  }
+
+  // Gets the top arrow width.
+  int GetTopArrowWidth() const {
+    return bubble_border_->GetTopArrowWidth();
+  }
+
+  // Gets the image border thickness.
+  int GetBorderThickness() const {
+    return bubble_border_->GetBorderThickness();
+  }
+
+  // Gets the border thickness.
+  int GetBorderExteriorThickness() const {
+    return bubble_border_->GetBorderExteriorThickness();
+  }
+
+  // Gets the border interior thickness.
+  int GetBorderInteriorThickness() const {
+    return bubble_border_->GetBorderInteriorThickness();
+  }
+
+  // Get the arrow size.
+  int GetArrowSize() const {
+    return bubble_border_->GetArrowSize();
+  }
+
+  // Returns true iff the bubble_border_ has an arrow.
+  bool HasArrow() {
+    return BubbleBorder::has_arrow(bubble_border_->arrow());
+  }
+
+  // Get the size for the given |contents_size|.
+  gfx::Size GetSizeForContentsSize(
+      const gfx::Size& contents_size) const {
+    return bubble_border_->GetSizeForContentsSize(contents_size);
+  }
+
+  // Gets an origin point for the fixed kGetOriginAnchor and

[msw, 2014/08/19 21:35:40]

This helper can be re-written as a static for individual test |border|s:
  static gfx::Point GetOrigin(const BubbleBorder& border) {
     border.GetBounds(kAnchor, kMediumSize);
  }
(it could also be a file-local static in an anon namespace if you prefer)

+  // kGetOriginContentsSize.
+  gfx::Point GetOrigin() {
+    return bubble_border_->GetBounds(kGetOriginAnchor,
+                                     kGetOriginContentsSize).origin();
+  }
+
+  // Creates a new BubbleBorder instance with the given |arrow|.
+  void CreateBubbleBorder(BubbleBorder::Arrow arrow) {
+    bubble_border_.reset(new BubbleBorder(arrow,
+                                          BubbleBorder::NO_SHADOW,
+                                          SK_ColorWHITE));
+  }
+
+  // Creates a new BubbleBorder instance with the given |arrow|.
+  void CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::Arrow arrow,
+      int& arrow_offset,
+      gfx::Size& size_for_contents_size) {
+    bubble_border_.reset(new BubbleBorder(arrow,

[msw, 2014/08/19 21:35:40]

Have individual tests just do this as needed:
  const gfx::Size size(border->GetSizeForContentsSize(kMediumSize));
  const int arrow_offset = border->GetArrowOffset(size);

+                                          BubbleBorder::NO_SHADOW,
+                                          SK_ColorWHITE));
+    size_for_contents_size = GetSizeForContentsSize(kGetOriginContentsSize);
+    arrow_offset = bubble_border_->GetArrowOffset(size_for_contents_size);
+  }
+
+ private:
+  scoped_ptr<BubbleBorder> bubble_border_;

[msw, 2014/08/19 21:35:39]

Remove this and wrappers; let each test construct and use a BubbleBorder: 
  BubbleBorder border(arrow, BubbleBorder::NO_SHADOW, SK_ColorWHITE);
  <... use |border| directly ...>
Add const kShadow and kColor (like kStroke) for |border|s, if you wish.

+
+  DISALLOW_COPY_AND_ASSIGN(BubbleBorderTest);
+};
+
+typedef BubbleBorderTest BubbleBorderGetSizeForContentsSizeTest;
+typedef BubbleBorderTest BubbleBorderGetBoundsOriginTest;
 
 TEST_F(BubbleBorderTest, GetMirroredArrow) {
   // Horizontal mirroring.
@@ -202,39 +300,556 @@ TEST_F(BubbleBorderTest, IsArrowAtCenter) {
   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::FLOAT));
 }
 
-TEST_F(BubbleBorderTest, TestMinimalSize) {
-  gfx::Rect anchor = gfx::Rect(100, 100, 20, 20);
-  gfx::Size contents = gfx::Size(10, 10);
-  BubbleBorder b1(BubbleBorder::RIGHT_TOP, BubbleBorder::NO_SHADOW, 0);
+TEST_F(BubbleBorderGetSizeForContentsSizeTest, WithHorizontalTopArrow) {
+  CreateBubbleBorder(BubbleBorder::TOP_CENTER);
+
+  gfx::Size size;
+
+  ASSERT_TRUE(HasArrow());

[msw, 2014/08/19 21:35:39]

Nit move asserts like this directly after the Border construction.

+
+  SetPaintArrow(BubbleBorder::PAINT_NORMAL);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness() + GetTopArrowWidth(), size.width());
+  EXPECT_EQ(GetBorderThickness()
+              + GetArrowThickness()
+              + GetBorderInteriorThickness(),
+            size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.height()
+              + GetBorderExteriorThickness()
+              + GetArrowThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_TRANSPARENT);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness() + GetTopArrowWidth(), size.width());
+  EXPECT_EQ(GetBorderThickness()
+              + GetArrowThickness()
+              + GetBorderInteriorThickness(),
+            size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.height()
+              + GetBorderExteriorThickness()
+              + GetArrowThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_NONE);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness(), size.width());
+  EXPECT_EQ(2 * GetBorderThickness(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+}
+
+TEST_F(BubbleBorderGetSizeForContentsSizeTest, WithHorizontalBottomArrow) {

[msw, 2014/08/19 21:35:40]

All the expected values should be the same for a top/bottom, left/right arrow,
and none/float pairs, and there are other strong similarities between various
cases. Can you remove some cases or consolidate the tests to avoid some
duplication? Maybe something like this pattern, which I've used with success
elsewhere:

  struct TestCase {
    BubbleBorder::Arrow arrow;
    BubbleBorder::ArrowPaintType paint_arrow;
    gfx::Size content;
    gfx::Size expected;
  };

  const gfx::Size kSmallHorizArrow = ...;
  const gfx::Size kSmallVertArrow = ...;
  const gfx::Size kSmallNoArrow = ...;

  TestCase cases[] = {
     { BubbleBorder::TOP_CENTER, BubbleBorder::PAINT_NORMAL, kSmall,
kSmallHorizArrow },
     { BubbleBorder::TOP_CENTER, BubbleBorder::PAINT_TRANSPARENT, kSmall,
kSmallHorizArrow },
     { BubbleBorder::TOP_CENTER, BubbleBorder::PAINT_NONE, kSmall, kSmallNoArrow
},
     { BubbleBorder::BOTTOM_CENTER, BubbleBorder::PAINT_NORMAL, kSmall,
kSmallHorizArrow },
     { BubbleBorder::BOTTOM_CENTER, BubbleBorder::PAINT_TRANSPARENT, kSmall,
kSmallHorizArrow },
     { BubbleBorder::BOTTOM_CENTER, BubbleBorder::PAINT_NONE, kSmall,
kSmallNoArrow },
     ...
     <Similar cases for vertical arrows, then ditto for all kMedium vert/horiz
cases>
  };

  for(size_t i = 0; i < arraysize(cases); ++i) {
    SCOPED_TRACE(...)
    border.set_arrow(cases[i].arrow);
    border.set_paint_arrow(cases[i].paint_arrow);
    EXPECT_EQ(expected, border.GetSizeForContentsSize(cases[i].content));
  }

[bruthig, 2014/08/20 15:01:28]

Interesting, I stayed away from this approach because I was not familiar with
the SCOPED_TRACE(...) macro and hated how you couldn't tell from the EXPECT_*
output which test actually failed.  This is very useful to know about, thanks!!
:D

[msw, 2014/08/20 20:41:02]

Yeah, SCOPED_TRACE and looping over similar test cases is a great approach, you
can find some examples in RenderTextTest and SearchProviderTest.

[bruthig, 2014/08/22 19:45:04]

Done.

+  CreateBubbleBorder(BubbleBorder::BOTTOM_CENTER);
+
+  gfx::Size size;
+
+  ASSERT_TRUE(HasArrow());
+
+  SetPaintArrow(BubbleBorder::PAINT_NORMAL);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness() + GetTopArrowWidth(), size.width());
+  EXPECT_EQ(GetBorderThickness()
+              + GetArrowThickness()
+              + GetBorderInteriorThickness(),
+            size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.height()
+              + GetBorderExteriorThickness()
+              + GetArrowThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_TRANSPARENT);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness() + GetTopArrowWidth(), size.width());
+  EXPECT_EQ(GetBorderThickness()
+              + GetArrowThickness()
+              + GetBorderInteriorThickness(),
+            size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.height()
+              + GetBorderExteriorThickness()
+              + GetArrowThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_NONE);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness(), size.width());
+  EXPECT_EQ(2 * GetBorderThickness(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+}
+
+TEST_F(BubbleBorderGetSizeForContentsSizeTest, WithVerticalLeftArrow) {
+  CreateBubbleBorder(BubbleBorder::LEFT_CENTER);
+
+  gfx::Size size;
+
+  ASSERT_TRUE(HasArrow());
+
+  SetPaintArrow(BubbleBorder::PAINT_NORMAL);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(GetBorderThickness()
+              + GetArrowThickness()
+              + GetBorderInteriorThickness(),
+            size.width());
+  EXPECT_EQ(2 * GetBorderThickness() + GetTopArrowWidth(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.height()
+              + GetBorderExteriorThickness()
+              + GetArrowThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_TRANSPARENT);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(GetBorderThickness()
+              + GetArrowThickness()
+              + GetBorderInteriorThickness(),
+            size.width());
+  EXPECT_EQ(2 * GetBorderThickness() + GetTopArrowWidth(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.height()
+              + GetBorderExteriorThickness()
+              + GetArrowThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_NONE);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness(), size.width());
+  EXPECT_EQ(2 * GetBorderThickness(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+}
+
+TEST_F(BubbleBorderGetSizeForContentsSizeTest, WithVerticalRightArrow) {
+  CreateBubbleBorder(BubbleBorder::RIGHT_CENTER);
+
+  gfx::Size size;
+
+  ASSERT_TRUE(HasArrow());
+
+  SetPaintArrow(BubbleBorder::PAINT_NORMAL);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(GetBorderThickness()
+              + GetArrowThickness()
+              + GetBorderInteriorThickness(),
+              size.width());
+  EXPECT_EQ(2 * GetBorderThickness() + GetTopArrowWidth(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.height()
+              + GetBorderExteriorThickness()
+              + GetArrowThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_TRANSPARENT);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(GetBorderThickness()
+              + GetArrowThickness()
+              + GetBorderInteriorThickness(),
+            size.width());
+  EXPECT_EQ(2 * GetBorderThickness() + GetTopArrowWidth(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.height()
+              + GetBorderExteriorThickness()
+              + GetArrowThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_NONE);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness(), size.width());
+  EXPECT_EQ(2 * GetBorderThickness(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+}
+
+TEST_F(BubbleBorderGetSizeForContentsSizeTest, WithoutArrow) {
+  CreateBubbleBorder(BubbleBorder::NONE);
+
+  gfx::Size size;
+
+  ASSERT_FALSE(HasArrow());
+
+  SetPaintArrow(BubbleBorder::PAINT_NORMAL);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness(), size.width());
+  EXPECT_EQ(2 * GetBorderThickness(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_TRANSPARENT);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness(), size.width());
+  EXPECT_EQ(2 * GetBorderThickness(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_NONE);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness(), size.width());
+  EXPECT_EQ(2 * GetBorderThickness(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+}
 
-  // The height should be much bigger then the requested size + border and
-  // padding since it needs to be able to include the tip bitmap.
-  gfx::Rect visible_tip_1 = b1.GetBounds(anchor, contents);
-  EXPECT_GE(visible_tip_1.height(), 30);
-  EXPECT_LE(visible_tip_1.width(), 30);
 
-  // With the tip being invisible the height should now be much smaller.
-  b1.set_paint_arrow(BubbleBorder::PAINT_TRANSPARENT);
-  gfx::Rect invisible_tip_1 = b1.GetBounds(anchor, contents);
-  EXPECT_LE(invisible_tip_1.height(), 30);
-  EXPECT_LE(invisible_tip_1.width(), 30);
+TEST_F(BubbleBorderGetSizeForContentsSizeTest, WithFloatArrow) {
+  CreateBubbleBorder(BubbleBorder::FLOAT);
 
-  // When the orientation of the tip changes, the above mentioned tests need to
-  // be reverse for width and height.
-  BubbleBorder b2(BubbleBorder::TOP_RIGHT, BubbleBorder::NO_SHADOW, 0);
+  gfx::Size size;
 
-  // The width should be much bigger then the requested size + border and
-  // padding since it needs to be able to include the tip bitmap.
-  gfx::Rect visible_tip_2 = b2.GetBounds(anchor, contents);
-  EXPECT_GE(visible_tip_2.width(), 30);
-  EXPECT_LE(visible_tip_2.height(), 30);
+  ASSERT_FALSE(HasArrow());
 
-  // With the tip being invisible the width should now be much smaller.
-  b2.set_paint_arrow(BubbleBorder::PAINT_TRANSPARENT);
-  gfx::Rect invisible_tip_2 = b2.GetBounds(anchor, contents);
-  EXPECT_LE(invisible_tip_2.width(), 30);
-  EXPECT_LE(invisible_tip_2.height(), 30);
+  SetPaintArrow(BubbleBorder::PAINT_NORMAL);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness(), size.width());
+  EXPECT_EQ(2 * GetBorderThickness(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_TRANSPARENT);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness(), size.width());
+  EXPECT_EQ(2 * GetBorderThickness(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+
+  SetPaintArrow(BubbleBorder::PAINT_NONE);
+  size = GetSizeForContentsSize(kSmallSize);
+  EXPECT_EQ(2 * GetBorderThickness(), size.width());
+  EXPECT_EQ(2 * GetBorderThickness(), size.height());
+
+  size = GetSizeForContentsSize(kMediumSize);
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.width());
+  EXPECT_EQ(kMediumSize.width() + 2 * GetBorderExteriorThickness(),
+            size.height());
+}
+
+TEST_F(BubbleBorderGetBoundsOriginTest, ArrowIsHorizontalLeft) {

[msw, 2014/08/19 21:35:40]

Ditto request to remove similar test cases or consolidate a pattern.

[bruthig, 2014/08/22 19:45:04]

Done.

+  int arrow_offset;
+  gfx::Size size_for_contents_size;
+  CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::TOP_LEFT,
+                                          arrow_offset,
+                                          size_for_contents_size);
+
+  gfx::Point origin;
+
+  SetAlignment(BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x() + kGetOriginAnchor.width() / 2 - arrow_offset,
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height() + GetArrowSize(),
+            origin.y());
+
+  SetAlignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x() + kStroke - GetBorderExteriorThickness(),
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height() + GetArrowSize(),
+            origin.y());
 }
 
+TEST_F(BubbleBorderGetBoundsOriginTest, ArrowIsHorizontalCenter) {
+  int arrow_offset;
+  gfx::Size size_for_contents_size;
+  CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::TOP_CENTER,
+                                          arrow_offset,
+                                          size_for_contents_size);
+
+  gfx::Point origin;
+
+  SetAlignment(BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x() + kGetOriginAnchor.width() / 2 - arrow_offset,
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height() + GetArrowSize(),
+            origin.y());
+
+  SetAlignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x() + kGetOriginAnchor.width() / 2 - arrow_offset,
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height() + GetArrowSize(),
+            origin.y());
+}
+
+TEST_F(BubbleBorderGetBoundsOriginTest, ArrowIsHorizontalRight) {
+  int arrow_offset;
+  gfx::Size size_for_contents_size;
+  CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::TOP_RIGHT,
+                                          arrow_offset,
+                                          size_for_contents_size);
+
+  gfx::Point origin;
+
+  SetAlignment(BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x()
+              + kGetOriginAnchor.width() / 2
+              + arrow_offset
+              - size_for_contents_size.width(),
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height() + GetArrowSize(),
+            origin.y());
+
+  SetAlignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x()
+              + kGetOriginAnchor.width()
+              - size_for_contents_size.width()
+              + GetBorderExteriorThickness()
+              - kStroke,
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height() + GetArrowSize(),
+            origin.y());
+}
+
+TEST_F(BubbleBorderGetBoundsOriginTest, ArrowIsHorizontalBottom) {
+  int arrow_offset;
+  gfx::Size size_for_contents_size;
+  CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::BOTTOM_LEFT,
+                                          arrow_offset,
+                                          size_for_contents_size);
+
+  gfx::Point origin;
+
+  SetAlignment(BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.y()
+              - GetArrowSize()
+              - size_for_contents_size.height(),
+            origin.y());
+
+  SetAlignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.y()
+              - GetArrowSize()
+              - size_for_contents_size.height(),
+            origin.y());
+}
+
+TEST_F(BubbleBorderGetBoundsOriginTest, ArrowIsVerticalTop) {
+  int arrow_offset;
+  gfx::Size size_for_contents_size;
+  CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::LEFT_TOP,
+                                          arrow_offset,
+                                          size_for_contents_size);
+
+  gfx::Point origin;
+
+  SetAlignment(BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x()
+              + kGetOriginAnchor.width()
+              + GetArrowSize(),
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height() / 2 - arrow_offset,
+            origin.y());
+
+  SetAlignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x() + kGetOriginAnchor.width() + GetArrowSize(),
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kStroke - GetBorderExteriorThickness(),
+            origin.y());
+}
+
+TEST_F(BubbleBorderGetBoundsOriginTest, ArrowIsVerticalCenter) {
+  int arrow_offset;
+  gfx::Size size_for_contents_size;
+  CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::LEFT_CENTER,
+                                          arrow_offset,
+                                          size_for_contents_size);
+
+  gfx::Point origin;
+
+  SetAlignment(BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x() + kGetOriginAnchor.width() + GetArrowSize(),
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height() / 2 - arrow_offset,
+            origin.y());
+
+  SetAlignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x() + kGetOriginAnchor.width() + GetArrowSize(),
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height() / 2 - arrow_offset,
+            origin.y());
+}
+
+TEST_F(BubbleBorderGetBoundsOriginTest, ArrowIsVerticalBottom) {
+  int arrow_offset;
+  gfx::Size size_for_contents_size;
+  CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::LEFT_BOTTOM,
+                                          arrow_offset,
+                                          size_for_contents_size);
+
+  gfx::Point origin;
+
+  SetAlignment(BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x()
+              + kGetOriginAnchor.width()
+              + GetArrowSize(),
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y()
+              + kGetOriginAnchor.height() / 2
+              + arrow_offset
+              - size_for_contents_size.height(),
+            origin.y());
+
+  SetAlignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x() + kGetOriginAnchor.width() + GetArrowSize(),
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y()
+              + kGetOriginAnchor.height()
+              - size_for_contents_size.height()
+              + GetBorderExteriorThickness()
+              - kStroke,
+            origin.y());
+}
+
+TEST_F(BubbleBorderGetBoundsOriginTest, ArrowIsVerticalRight) {
+  int arrow_offset;
+  gfx::Size size_for_contents_size;
+  CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::RIGHT_CENTER,
+                                          arrow_offset,
+                                          size_for_contents_size);
+
+  gfx::Point origin;
+
+  SetAlignment(BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x()
+              - GetArrowSize()
+              - size_for_contents_size.width(),
+            origin.x());
+
+  SetAlignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x()
+            - GetArrowSize()
+            - size_for_contents_size.width(),
+          origin.x());
+}
+
+TEST_F(BubbleBorderGetBoundsOriginTest, ArrowIsNone) {
+  int arrow_offset;
+  gfx::Size size_for_contents_size;
+  CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::NONE,
+                                          arrow_offset,
+                                          size_for_contents_size);
+
+  gfx::Point origin;
+
+  SetAlignment(BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x()
+              + (kGetOriginAnchor.width() - size_for_contents_size.width()) / 2,
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height(), origin.y());
+
+  SetAlignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x()
+              + (kGetOriginAnchor.width() - size_for_contents_size.width()) / 2,
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y() + kGetOriginAnchor.height(), origin.y());
+}
+
+TEST_F(BubbleBorderGetBoundsOriginTest, ArrowIsFloat) {
+  int arrow_offset;
+  gfx::Size size_for_contents_size;
+  CreateBubbleBorderForGetBoundsOrginTest(BubbleBorder::FLOAT,
+                                          arrow_offset,
+                                          size_for_contents_size);
+
+  gfx::Point origin;
+
+  SetAlignment(BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
+  origin = GetOrigin();
+    EXPECT_EQ(kGetOriginAnchor.x()
+                + (kGetOriginAnchor.width()
+                    - size_for_contents_size.width()) / 2,
+              origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y()
+              + (kGetOriginAnchor.height()
+                  - size_for_contents_size.height()) / 2,
+            origin.y());
+
+  SetAlignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  origin = GetOrigin();
+  EXPECT_EQ(kGetOriginAnchor.x()
+              + (kGetOriginAnchor.width() - size_for_contents_size.width()) / 2,
+            origin.x());
+  EXPECT_EQ(kGetOriginAnchor.y()
+              + (kGetOriginAnchor.height()
+                  - size_for_contents_size.height()) / 2,
+            origin.y());
+}
 
 }  // namespace views