MacViews: Add native drop shadow to dialogs on OSX < 10.10.

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"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/path.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/views/painter.h"
 #include "ui/views/resources/grit/views_resources.h"
 #include "ui/views/view.h"
 
 namespace views {
 
 namespace internal {
 
@@ skipping 109 matching lines @@
 
 }  // 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);
+// On Mac, use the NO_ASSETS bubble border. WindowServer on Mac is able to

[tapted, 2016/01/28 05:59:22]

nit: I think we should have the initializer still, but do

#if defined(OS_MACOSX)
  // On Mac...
  shadow_ = NO_ASSETS;
#endif

Another option could be, in the initializer,

shadow_(AdjustShadowForPlatform(shadow))

but that's probably clunkier

[karandeepb, 2016/02/04 03:39:27]

Done.

+// generate drop shadows for dialogs, hence we don't use raster shadows.
+#if defined(OS_MACOSX)
+  shadow_ = NO_ASSETS;
+#else
+  shadow_ = shadow;
+#endif  // OS_MACOSX
+  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();
@@ skipping 45 matching lines @@
       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_->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));
 }
 
+void BubbleBorder::GetArrowMask(const gfx::Rect& view_bounds,
+                                gfx::Path* mask) const {
+  if (!has_arrow(arrow_) || arrow_paint_type_ != PAINT_NORMAL)
+    return;
+
+  return GetArrowMaskFromArrowBounds(GetArrowRect(view_bounds), mask);
+}
+
 void BubbleBorder::Paint(const views::View& view, gfx::Canvas* canvas) {
   gfx::Rect bounds(view.GetContentsBounds());
   bounds.Inset(-GetBorderThickness(), -GetBorderThickness());
   const gfx::Rect arrow_bounds = GetArrowRect(view.GetLocalBounds());
   if (arrow_bounds.IsEmpty()) {
     if (images_->border_painter)
       Painter::PaintPainterAt(canvas, images_->border_painter.get(), bounds);
     return;
   }
   if (!images_->border_painter) {
@@ skipping 97 matching lines @@
 
   // With no assets, return the size enclosing the path filled in DrawArrow().
   DCHECK_EQ(2 * images_->arrow_interior_thickness, images_->arrow_width);
   int width = images_->arrow_width;
   int height = images_->arrow_interior_thickness;
   if (!is_arrow_on_horizontal(arrow_))
     std::swap(width, height);
   return gfx::Rect(origin, gfx::Size(width, height));
 }
 
-void BubbleBorder::DrawArrow(gfx::Canvas* canvas,
-                             const gfx::Rect& arrow_bounds) const {
-  canvas->DrawImageInt(*GetArrowImage(), arrow_bounds.x(), arrow_bounds.y());
+void BubbleBorder::GetArrowMaskFromArrowBounds(const gfx::Rect& arrow_bounds,
+                                               SkPath* mask) const {
   const bool horizontal = is_arrow_on_horizontal(arrow_);
   const int thickness = images_->arrow_interior_thickness;
   float tip_x = horizontal ? arrow_bounds.CenterPoint().x() :
       is_arrow_on_left(arrow_) ? arrow_bounds.right() - thickness :
                                  arrow_bounds.x() + thickness;
   float tip_y = !horizontal ? arrow_bounds.CenterPoint().y() + 0.5f :
       is_arrow_on_top(arrow_) ? arrow_bounds.bottom() - thickness :
                                 arrow_bounds.y() + thickness;
   const bool positive_offset = horizontal ?
       is_arrow_on_top(arrow_) : is_arrow_on_left(arrow_);
   const int offset_to_next_vertex = positive_offset ?
       images_->arrow_interior_thickness : -images_->arrow_interior_thickness;
 
+  mask->incReserve(4);
+  mask->moveTo(SkDoubleToScalar(tip_x), SkDoubleToScalar(tip_y));
+  mask->lineTo(SkDoubleToScalar(tip_x + offset_to_next_vertex),
+               SkDoubleToScalar(tip_y + offset_to_next_vertex));
+  const int multiplier = horizontal ? 1 : -1;
+  mask->lineTo(SkDoubleToScalar(tip_x - multiplier * offset_to_next_vertex),
+               SkDoubleToScalar(tip_y + multiplier * offset_to_next_vertex));
+  mask->close();
+}
+
+void BubbleBorder::DrawArrow(gfx::Canvas* canvas,
+                             const gfx::Rect& arrow_bounds) const {
+  canvas->DrawImageInt(*GetArrowImage(), arrow_bounds.x(), arrow_bounds.y());
   SkPath path;
-  path.incReserve(4);
-  path.moveTo(SkDoubleToScalar(tip_x), SkDoubleToScalar(tip_y));
-  path.lineTo(SkDoubleToScalar(tip_x + offset_to_next_vertex),
-              SkDoubleToScalar(tip_y + offset_to_next_vertex));
-  const int multiplier = horizontal ? 1 : -1;
-  path.lineTo(SkDoubleToScalar(tip_x - multiplier * offset_to_next_vertex),
-              SkDoubleToScalar(tip_y + multiplier * offset_to_next_vertex));
-  path.close();
-
+  GetArrowMaskFromArrowBounds(arrow_bounds, &path);
   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());
 
   canvas->DrawRoundRect(bounds, border_->GetBorderCornerRadius(), paint);
 }
 
 }  // namespace views