Makes vertical alignment of location bar bubbles same

ui/views/bubble/bubble_border.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 <algorithm>
 
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkPaint.h"
@@ skipping 146 matching lines @@
 BubbleBorder::~BubbleBorder() {}
 
 gfx::Rect BubbleBorder::GetBounds(const gfx::Rect& anchor_rect,
                                   const gfx::Size& contents_size) const {
   int x = anchor_rect.x();
   int y = anchor_rect.y();
   int w = anchor_rect.width();
   int h = anchor_rect.height();
   const gfx::Size size(GetSizeForContentsSize(contents_size));
   const int arrow_offset = GetArrowOffset(size);
-  const int arrow_size =
+  // |arrow_shift| is necessary to visually align the tip of the bubble arrow
+  // with the anchor point. This shift is an inverse of the shadow thickness.
+  int arrow_shift =
       images_->arrow_interior_thickness + kStroke - images_->arrow_thickness;
+  // When arrow is painted transparently the visible border of the bubble needs
+  // to be positioned at the same bounds as when the arrow is shown.
+  if (arrow_paint_type_ == PAINT_TRANSPARENT)
+    arrow_shift += images_->arrow_interior_thickness;
   const bool mid_anchor = alignment_ == ALIGN_ARROW_TO_MID_ANCHOR;
 
   // Calculate the bubble coordinates based on the border and arrow settings.
   if (is_arrow_on_horizontal(arrow_)) {
     if (is_arrow_on_left(arrow_)) {
       x += mid_anchor ? w / 2 - arrow_offset : kStroke - GetBorderThickness();
     } else if (is_arrow_at_center(arrow_)) {
       x += w / 2 - arrow_offset;
     } else {
       x += mid_anchor ? w / 2 + arrow_offset - size.width() :
                         w - size.width() + GetBorderThickness() - kStroke;
     }
-    y += is_arrow_on_top(arrow_) ? h + arrow_size : -arrow_size - size.height();
+    y += is_arrow_on_top(arrow_) ? h + arrow_shift
+                                 : -arrow_shift - size.height();
   } else if (has_arrow(arrow_)) {
-    x += is_arrow_on_left(arrow_) ? w + arrow_size : -arrow_size - size.width();
+    x += is_arrow_on_left(arrow_) ? w + arrow_shift
+                                  : -arrow_shift - size.width();
     if (is_arrow_on_top(arrow_)) {
       y += mid_anchor ? h / 2 - arrow_offset : kStroke - GetBorderThickness();
     } else if (is_arrow_at_center(arrow_)) {
       y += h / 2 - arrow_offset;
     } else {
       y += mid_anchor ? h / 2 + arrow_offset - size.height() :
                         h - size.height() + GetBorderThickness() - kStroke;
     }
   } else {
     x += (w - size.width()) / 2;
@@ skipping 52 matching lines @@
   canvas->sk_canvas()->clipRect(arrow_rect, SkRegion::kDifference_Op);
   Painter::PaintPainterAt(canvas, images_->border_painter.get(), bounds);
   canvas->Restore();
 
   DrawArrow(canvas, arrow_bounds);
 }
 
 gfx::Insets BubbleBorder::GetInsets() const {
   // The insets contain the stroke and shadow pixels outside the bubble fill.
   const int inset = GetBorderThickness();
-  if ((arrow_paint_type_ == PAINT_NONE) || !has_arrow(arrow_))
+  if (arrow_paint_type_ != PAINT_NORMAL || !has_arrow(arrow_))
     return gfx::Insets(inset);
 
   int first_inset = inset;
   int second_inset = std::max(inset, images_->arrow_thickness);
   if (is_arrow_on_horizontal(arrow_) ?
       is_arrow_on_top(arrow_) : is_arrow_on_left(arrow_))
     std::swap(first_inset, second_inset);
   return is_arrow_on_horizontal(arrow_) ?
       gfx::Insets(first_inset, inset, second_inset, inset) :
       gfx::Insets(inset, first_inset, inset, second_inset);
 }
 
 gfx::Size BubbleBorder::GetMinimumSize() const {
   return GetSizeForContentsSize(gfx::Size());
 }
 
 gfx::Size BubbleBorder::GetSizeForContentsSize(
     const gfx::Size& contents_size) const {
   // Enlarge the contents size by the thickness of the border images.
   gfx::Size size(contents_size);
   const gfx::Insets insets = GetInsets();
   size.Enlarge(insets.width(), insets.height());
 
   // Ensure the bubble is large enough to not overlap border and arrow images.
   const int min = 2 * images_->border_thickness;
+  // Only take arrow image sizes into account when the bubble tip is shown.
+  if (arrow_paint_type_ != PAINT_NORMAL || !has_arrow(arrow_)) {
+    size.SetToMax(gfx::Size(min, min));
+    return size;
+  }
   const int min_with_arrow_width = min + images_->arrow_width;
   const int min_with_arrow_thickness = images_->border_thickness +
       std::max(images_->arrow_thickness + images_->border_interior_thickness,
                images_->border_thickness);
-  // Only take arrow image sizes into account when the bubble tip is shown.
-  if (arrow_paint_type_ == PAINT_NONE || !has_arrow(arrow_))
-    size.SetToMax(gfx::Size(min, min));
-  else if (is_arrow_on_horizontal(arrow_))
+  if (is_arrow_on_horizontal(arrow_))
     size.SetToMax(gfx::Size(min_with_arrow_width, min_with_arrow_thickness));
   else
     size.SetToMax(gfx::Size(min_with_arrow_thickness, min_with_arrow_width));
   return size;
 }
 
 gfx::ImageSkia* BubbleBorder::GetArrowImage() const {
   if (!has_arrow(arrow_))
     return NULL;
   if (is_arrow_on_horizontal(arrow_)) {
@@ skipping 94 matching lines @@
   paint.setStyle(SkPaint::kFill_Style);
   paint.setColor(border_->background_color());
   SkPath path;
   gfx::Rect bounds(view->GetLocalBounds());
   bounds.Inset(border_->GetInsets());
 
   canvas->DrawRoundRect(bounds, border_->GetBorderCornerRadius(), paint);
 }
 
 }  // namespace views