Makes vertical alignment of location bar bubbles same

ui/views/bubble/bubble_border_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/views/bubble/bubble_border.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 291 matching lines @@
     SCOPED_TRACE(base::StringPrintf("i=%d arrow=%d",
         static_cast<int>(i), cases[i].arrow));
 
     border.set_arrow(cases[i].arrow);
 
     border.set_paint_arrow(BubbleBorder::PAINT_NORMAL);
     EXPECT_EQ(cases[i].expected_with_arrow,
               border.GetSizeForContentsSize(cases[i].content));
 
     border.set_paint_arrow(BubbleBorder::PAINT_TRANSPARENT);
-    EXPECT_EQ(cases[i].expected_with_arrow,
+    EXPECT_EQ(cases[i].expected_without_arrow,
               border.GetSizeForContentsSize(cases[i].content));
 
     border.set_paint_arrow(BubbleBorder::PAINT_NONE);
     EXPECT_EQ(cases[i].expected_without_arrow,
               border.GetSizeForContentsSize(cases[i].content));
   }
 }
 
 TEST_F(BubbleBorderTest, GetBoundsOriginTest) {
   views::BubbleBorder border(BubbleBorder::TOP_LEFT,
@@ skipping 17 matching lines @@
   const gfx::Size kTotalSizeWithNoArrow =
       border.GetSizeForContentsSize(kContentSize);
 
   const int kBorderThickness = border.GetBorderThickness();
 
   const int kArrowOffsetForHorizCenter = kTotalSizeWithHorizArrow.width() / 2;
   const int kArrowOffsetForVertCenter = kTotalSizeWithVertArrow.height() / 2;
   const int kArrowOffsetForNotCenter =
       kImages->border_thickness + (kImages->arrow_width / 2);
 
-  const int kArrowSize =
-      kImages->arrow_interior_thickness + BubbleBorder::kStroke -
-          kImages->arrow_thickness;
+  const int kArrowThickness = kImages->arrow_interior_thickness;
+  const int kArrowShift =
+      kArrowThickness + BubbleBorder::kStroke - kImages->arrow_thickness;
+  const int kHeightDifference = kTotalSizeWithHorizArrow.height() -
+      kTotalSizeWithNoArrow.height();
+  const int kWidthDifference = kTotalSizeWithVertArrow.width() -
+      kTotalSizeWithNoArrow.width();
 
-  const int kTopHorizArrowY = kAnchor.y() + kAnchor.height() + kArrowSize;
+  const int kTopHorizArrowY = kAnchor.y() + kAnchor.height() + kArrowShift;
   const int kBottomHorizArrowY =
-      kAnchor.y() - kArrowSize - kTotalSizeWithHorizArrow.height();
-
-  const int kLeftVertArrowX = kAnchor.x() + kAnchor.width() + kArrowSize;
+      kAnchor.y() - kArrowShift - kTotalSizeWithHorizArrow.height();
+  const int kLeftVertArrowX = kAnchor.x() + kAnchor.width() + kArrowShift;
   const int kRightVertArrowX =
-      kAnchor.x() - kArrowSize - kTotalSizeWithVertArrow.width();
+      kAnchor.x() - kArrowShift - kTotalSizeWithVertArrow.width();
 
   struct TestCase {
     BubbleBorder::Arrow arrow;
     BubbleBorder::BubbleAlignment alignment;
     int expected_x;
     int expected_y;
   };
 
   TestCase cases[] = {
     // Horizontal arrow tests.
@@ skipping 30 matching lines @@
       kAnchor.x() + (kAnchor.width() - kTotalSizeWithNoArrow.width()) / 2,
       kAnchor.y() + kAnchor.height() },
     { BubbleBorder::FLOAT, BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR,
       kAnchor.x() + (kAnchor.width() - kTotalSizeWithNoArrow.width()) / 2,
       kAnchor.y() + (kAnchor.height() - kTotalSizeWithNoArrow.height()) / 2 },
   };
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(base::StringPrintf("i=%d arrow=%d alignment=%d",
         static_cast<int>(i), cases[i].arrow, cases[i].alignment));
-    border.set_arrow(cases[i].arrow);
+    const BubbleBorder::Arrow arrow = cases[i].arrow;
+    border.set_arrow(arrow);
     border.set_alignment(cases[i].alignment);
 
+    border.set_paint_arrow(BubbleBorder::PAINT_NORMAL);
     gfx::Point origin = border.GetBounds(kAnchor, kContentSize).origin();
-    EXPECT_EQ(cases[i].expected_x, origin.x());
-    EXPECT_EQ(cases[i].expected_y, origin.y());
+    int expected_x = cases[i].expected_x;
+    int expected_y = cases[i].expected_y;
+    EXPECT_EQ(expected_x, origin.x());
+    EXPECT_EQ(expected_y, origin.y());
+
+    border.set_paint_arrow(BubbleBorder::PAINT_TRANSPARENT);
+    origin = border.GetBounds(kAnchor, kContentSize).origin();
+    if (border.is_arrow_on_horizontal(arrow)) {
+      expected_y += BubbleBorder::is_arrow_on_top(arrow)
+          ? kArrowThickness : (-kArrowThickness + kHeightDifference);
+    } else if (BubbleBorder::has_arrow(arrow)) {
+      expected_x += BubbleBorder::is_arrow_on_left(arrow)
+          ? kArrowThickness : (-kArrowThickness + kWidthDifference);
+    }
+    EXPECT_EQ(expected_x, origin.x());
+    EXPECT_EQ(expected_y, origin.y());
+
+    border.set_paint_arrow(BubbleBorder::PAINT_NONE);
+    origin = border.GetBounds(kAnchor, kContentSize).origin();
+    expected_x = cases[i].expected_x;
+    expected_y = cases[i].expected_y;
+    if (border.is_arrow_on_horizontal(arrow) &&
+        !BubbleBorder::is_arrow_on_top(arrow)) {
+      expected_y += kHeightDifference;
+    } else if (BubbleBorder::has_arrow(arrow) &&
+        !border.is_arrow_on_horizontal(arrow) &&
+        !BubbleBorder::is_arrow_on_left(arrow)) {
+      expected_x += kWidthDifference;
+    }
+    EXPECT_EQ(expected_x, origin.x());
+    EXPECT_EQ(expected_y, origin.y());
   }
 }
 
 // Ensure all the shadow types pass some size validation and paint sanely.
 TEST_F(BubbleBorderTest, ShadowTypes) {
   const gfx::Rect rect(0, 0, 320, 200);
   View paint_view;
   paint_view.SetBoundsRect(rect);
 
   for (int i = 0; i < BubbleBorder::SHADOW_COUNT; ++i) {
@@ skipping 13 matching lines @@
     EXPECT_GE(border_images->border_thickness,
               border_images->border_interior_thickness);
 
     // For a TOP_LEFT arrow, the x-offset always matches the border thickness.
     EXPECT_EQ(border.GetArrowRect(rect).x(), border_images->border_thickness);
     border.Paint(paint_view, &canvas);
   }
 }
 
 }  // namespace views