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"
 #include "grit/ui_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/views/painter.h"
 #include "ui/views/view.h"
 
 namespace views {
 
 namespace internal {
 
-// A helper that combines each border image-set painter with arrows and metrics.
-struct BorderImages {
-  BorderImages(const int border_image_ids[],
-               const int arrow_image_ids[],
-               int border_interior_thickness,
-               int arrow_interior_thickness,
-               int corner_radius);
-
-  scoped_ptr<Painter> border_painter;
-  gfx::ImageSkia left_arrow;
-  gfx::ImageSkia top_arrow;
-  gfx::ImageSkia right_arrow;
-  gfx::ImageSkia bottom_arrow;
-
-  // The thickness of border and arrow images and their interior areas.
-  // Thickness is the width of left/right and the height of top/bottom images.
-  // The interior is measured without including stroke or shadow pixels.
-  int border_thickness;
-  int border_interior_thickness;
-  int arrow_thickness;
-  int arrow_interior_thickness;
-  // The corner radius of the bubble's rounded-rect interior area.
-  int corner_radius;
-};
-
 BorderImages::BorderImages(const int border_image_ids[],
                            const int arrow_image_ids[],
                            int border_interior_thickness,
                            int arrow_interior_thickness,
                            int corner_radius)
     : border_painter(Painter::CreateImageGridPainter(border_image_ids)),
       border_thickness(0),
       border_interior_thickness(border_interior_thickness),
       arrow_thickness(0),
       arrow_interior_thickness(arrow_interior_thickness),
       corner_radius(corner_radius) {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   border_thickness = rb.GetImageSkiaNamed(border_image_ids[0])->width();
   if (arrow_image_ids[0] != 0) {
     left_arrow = *rb.GetImageSkiaNamed(arrow_image_ids[0]);
     top_arrow = *rb.GetImageSkiaNamed(arrow_image_ids[1]);
     right_arrow = *rb.GetImageSkiaNamed(arrow_image_ids[2]);
     bottom_arrow = *rb.GetImageSkiaNamed(arrow_image_ids[3]);
     arrow_thickness = top_arrow.height();
   }
 }
 
+BorderImages::~BorderImages() {}
+
 }  // 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);
@@ skipping 108 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 61 matching lines @@
               SkDoubleToScalar(tip_y + multiplier * offset_to_next_vertex));
   path.close();
 
   SkPaint paint;
   paint.setStyle(SkPaint::kFill_Style);
   paint.setColor(background_color_);
 
   canvas->DrawPath(path, paint);
 }
 
+internal::BorderImages* BubbleBorder::GetImagesForTest() const {
+  return images_;
+}
+
 void BubbleBackground::Paint(gfx::Canvas* canvas, views::View* view) const {
   if (border_->shadow() == BubbleBorder::NO_SHADOW_OPAQUE_BORDER)
     canvas->DrawColor(border_->background_color());
 
   // Fill the contents with a round-rect region to match the border images.
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setStyle(SkPaint::kFill_Style);
   paint.setColor(border_->background_color());
   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