Fixed BubbleBorder sizing problems & added unit tests.

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 "base/memory/scoped_ptr.h"
@@ skipping 54 matching lines @@
     right_arrow = *rb.GetImageSkiaNamed(arrow_image_ids[2]);
     bottom_arrow = *rb.GetImageSkiaNamed(arrow_image_ids[3]);
     arrow_thickness = top_arrow.height();
   }
 }
 
 }  // namespace internal
 
 namespace {
 
-// The border and arrow stroke size used in image assets, in pixels.
-const int kStroke = 1;
-
 // Bubble border and arrow image resource ids. They don't use the IMAGE_GRID
 // macro because there is no center image.
 const int kNoShadowImages[] = {
     IDR_BUBBLE_TL, IDR_BUBBLE_T, IDR_BUBBLE_TR,
     IDR_BUBBLE_L,  0,            IDR_BUBBLE_R,
     IDR_BUBBLE_BL, IDR_BUBBLE_B, IDR_BUBBLE_BR };
 const int kNoShadowArrows[] = {
     IDR_BUBBLE_L_ARROW, IDR_BUBBLE_T_ARROW,
     IDR_BUBBLE_R_ARROW, IDR_BUBBLE_B_ARROW, };
 
@@ skipping 55 matching lines @@
     case BubbleBorder::SHADOW_COUNT:
       NOTREACHED();
       break;
   }
 
   return set;
 }
 
 }  // namespace
 
+const int BubbleBorder::kStroke = 1;
+
 BubbleBorder::BubbleBorder(Arrow arrow, Shadow shadow, SkColor color)
     : arrow_(arrow),
       arrow_offset_(0),
       arrow_paint_type_(PAINT_NORMAL),
       alignment_(ALIGN_ARROW_TO_MID_ANCHOR),
       shadow_(shadow),
       background_color_(color),
       use_theme_background_color_(false) {
   DCHECK(shadow < SHADOW_COUNT);
   images_ = GetBorderImages(shadow);
 }
 
 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 =
-      images_->arrow_interior_thickness + kStroke - images_->arrow_thickness;
+  const int arrow_size = GetArrowSize();
   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();
+      x += mid_anchor ?
+          w / 2 - arrow_offset :
+          kStroke - GetBorderExteriorThickness();
     } 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;
+      x += mid_anchor ?
+          w / 2 + arrow_offset - size.width() :
+          w - size.width() + GetBorderExteriorThickness() - kStroke;
     }
     y += is_arrow_on_top(arrow_) ? h + arrow_size : -arrow_size - size.height();
   } else if (has_arrow(arrow_)) {
     x += is_arrow_on_left(arrow_) ? w + arrow_size : -arrow_size - size.width();
     if (is_arrow_on_top(arrow_)) {
-      y += mid_anchor ? h / 2 - arrow_offset : kStroke - GetBorderThickness();
+      y += mid_anchor ?
+          h / 2 - arrow_offset :
+          kStroke - GetBorderExteriorThickness();
     } 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;
+      y += mid_anchor ?
+          h / 2 + arrow_offset - size.height() :
+          h - size.height() + GetBorderExteriorThickness() - kStroke;
     }
   } else {
     x += (w - size.width()) / 2;
     y += (arrow_ == NONE) ? h : (h - size.height()) / 2;
   }
 
   return gfx::Rect(x, y, size.width(), size.height());
 }
 
+int BubbleBorder::GetArrowThickness() const {
+  return images_->arrow_thickness;
+}
+
+int BubbleBorder::GetTopArrowWidth() const {
+  return images_->top_arrow.width();
+}
+
 int BubbleBorder::GetBorderThickness() const {
+  return images_->border_thickness;
+}
+
+int BubbleBorder::GetBorderInteriorThickness() const {
+  return images_->border_interior_thickness;
+}
+
+int BubbleBorder::GetBorderExteriorThickness() const {
   return images_->border_thickness - images_->border_interior_thickness;
 }
 
 int BubbleBorder::GetBorderCornerRadius() const {
   return images_->corner_radius;
 }
 
 int BubbleBorder::GetArrowOffset(const gfx::Size& border_size) const {
   const int edge_length = is_arrow_on_horizontal(arrow_) ?
       border_size.width() : border_size.height();
   if (is_arrow_at_center(arrow_) && arrow_offset_ == 0)
     return edge_length / 2;
 
   // Calculate the minimum offset to not overlap arrow and corner images.
   const int min = images_->border_thickness + (images_->top_arrow.width() / 2);
   // Ensure the returned value will not cause image overlap, if possible.
   return std::max(min, std::min(arrow_offset_, edge_length - min));
 }
 
+int BubbleBorder::GetArrowSize() const {
+  return images_->arrow_interior_thickness + kStroke - images_->arrow_thickness;
+}
+
 void BubbleBorder::Paint(const views::View& view, gfx::Canvas* canvas) {
   gfx::Rect bounds(view.GetContentsBounds());
-  bounds.Inset(-GetBorderThickness(), -GetBorderThickness());
+  bounds.Inset(-GetBorderExteriorThickness(), -GetBorderExteriorThickness());
   const gfx::Rect arrow_bounds = GetArrowRect(view.GetLocalBounds());
   if (arrow_bounds.IsEmpty()) {
     Painter::PaintPainterAt(canvas, images_->border_painter.get(), bounds);
     return;
   }
 
   // Clip the arrow bounds out to avoid painting the overlapping edge area.
   canvas->Save();
   SkRect arrow_rect(gfx::RectToSkRect(arrow_bounds));
   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();
+  const int inset = GetBorderExteriorThickness();
   if ((arrow_paint_type_ == PAINT_NONE) || !has_arrow(arrow_))
     return gfx::Insets(inset, inset, inset, 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) :
@@ skipping 11 matching lines @@
   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;
   const int min_with_arrow_width = min + images_->top_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_TRANSPARENT || !has_arrow(arrow_))
+  if (arrow_paint_type_ == PAINT_NONE || !has_arrow(arrow_))
     size.SetToMax(gfx::Size(min, min));
   else 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_))
@@ skipping 80 matching lines @@
   SkPath path;
   gfx::Rect bounds(view->GetLocalBounds());
   bounds.Inset(border_->GetInsets());
 
   SkScalar radius = SkIntToScalar(border_->GetBorderCornerRadius());
   path.addRoundRect(gfx::RectToSkRect(bounds), radius, radius);
   canvas->DrawPath(path, paint);
 }
 
 }  // namespace views