Implement Harmony spec for dialog/bubble borders.

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/SkDrawLooper.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
+#include "ui/base/material_design/material_design_controller.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/scoped_canvas.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 24 matching lines @@
     arrow_thickness = top_arrow.height();
   }
 }
 
 BorderImages::~BorderImages() {}
 
 }  // namespace internal
 
 namespace {
 
+// Blur and offset values for the two shadows drawn around each dialog. The
+// values are all in dip.
+const int kSmallShadowVerticalOffset = 2;
+const int kSmallShadowBlur = 4;
+const SkColor kSmallShadowColor = SkColorSetA(SK_ColorBLACK, 0x33);
+
+const int kLargeShadowVerticalOffset = 2;
+const int kLargeShadowBlur = 6;
+const SkColor kLargeShadowColor = SkColorSetA(SK_ColorBLACK, 0x1A);
+
+bool UseMd() {
+  return ui::MaterialDesignController::IsSecondaryUiMaterial();
+}
+
 // 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 66 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),
+      images_(nullptr),
       background_color_(color),
       use_theme_background_color_(false) {
 #if defined(OS_MACOSX)
   // On Mac, use the NO_ASSETS bubble border. WindowServer on Mac is able to
   // generate drop shadows for dialogs, hence we don't use raster shadows.
   shadow_ = NO_ASSETS;
 #endif  // OS_MACOSX
   DCHECK(shadow_ < SHADOW_COUNT);
-  images_ = GetBorderImages(shadow_);
+  if (UseMd()) {
+    // Harmony bubbles don't use arrows.
+    alignment_ = ALIGN_EDGE_TO_ANCHOR_EDGE;
+    arrow_paint_type_ = PAINT_NONE;
+  } else {
+    images_ = GetBorderImages(shadow_);
+  }
 }
 
 BubbleBorder::~BubbleBorder() {}
 
+void BubbleBorder::set_paint_arrow(ArrowPaintType value) {
+  if (UseMd())
+    return;
+  arrow_paint_type_ = value;
+}
+
 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);
   // |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 =
+  int arrow_shift = UseMd() ? 0 :
       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_)) {
@@ skipping 19 matching lines @@
     }
   } 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::GetBorderThickness() const {
-  return images_->border_thickness - images_->border_interior_thickness;
+  // TODO(estade): this shouldn't be called in MD.
+  return UseMd()
+             ? 0
+             : images_->border_thickness - images_->border_interior_thickness;
 }
 
 int BubbleBorder::GetBorderCornerRadius() const {
-  return images_->corner_radius;
+  return UseMd() ? 3 : images_->corner_radius;
 }
 
 int BubbleBorder::GetArrowOffset(const gfx::Size& border_size) const {
+  if (UseMd())
+    return 0;
+
   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_->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));
 }
 
 bool BubbleBorder::GetArrowPath(const gfx::Rect& view_bounds,
                                 gfx::Path* path) const {
   if (!has_arrow(arrow_) || arrow_paint_type_ != PAINT_NORMAL)
     return false;
 
   GetArrowPathFromArrowBounds(GetArrowRect(view_bounds), path);
   return true;
 }
 
 void BubbleBorder::SetBorderInteriorThickness(int border_interior_thickness) {
   images_->border_interior_thickness = border_interior_thickness;
   if (!has_arrow(arrow_) || arrow_paint_type_ != PAINT_NORMAL)
     images_->border_thickness = border_interior_thickness;
 }
 
 void BubbleBorder::Paint(const views::View& view, gfx::Canvas* canvas) {
+  if (UseMd())
+    return PaintMd(view, 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) {
     DrawArrow(canvas, arrow_bounds);
     return;
   }
 
   // Clip the arrow bounds out to avoid painting the overlapping edge area.
   canvas->Save();
   canvas->ClipRect(arrow_bounds, SkRegion::kDifference_Op);
   Painter::PaintPainterAt(canvas, images_->border_painter.get(), bounds);
   canvas->Restore();
 
   DrawArrow(canvas, arrow_bounds);
 }
 
 gfx::Insets BubbleBorder::GetInsets() const {
+  if (UseMd()) {
+     gfx::Insets blur(kLargeShadowBlur);
+     gfx::Insets offset(-kLargeShadowVerticalOffset, 0,
+                        kLargeShadowVerticalOffset, 0);
+     return blur + offset;
+  }
+
   // The insets contain the stroke and shadow pixels outside the bubble fill.
   const int inset = GetBorderThickness();
   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());
+  if (UseMd())
+    return size;
 
   // 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 +
@@ skipping 51 matching lines @@
   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::GetArrowPathFromArrowBounds(const gfx::Rect& arrow_bounds,
                                                SkPath* path) const {
+  DCHECK(!UseMd());
   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;
 
   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();
 }
 
 void BubbleBorder::DrawArrow(gfx::Canvas* canvas,
                              const gfx::Rect& arrow_bounds) const {
+  DCHECK(!UseMd());
   canvas->DrawImageInt(*GetArrowImage(), arrow_bounds.x(), arrow_bounds.y());
   SkPath path;
   GetArrowPathFromArrowBounds(arrow_bounds, &path);
   SkPaint paint;
   paint.setStyle(SkPaint::kFill_Style);
   paint.setColor(background_color_);
 
   canvas->DrawPath(path, paint);
 }
 
+void BubbleBorder::PaintMd(const View& view, gfx::Canvas* canvas) {
+  gfx::ScopedCanvas scoped(canvas);
+
+  SkPaint paint;
+  std::vector<gfx::ShadowValue> shadows;
+  // gfx::ShadowValue counts blur pixels both inside and outside the shape,
+  // whereas these blur values only describe the outside portion, hence they
+  // must be doubled.
+  shadows.emplace_back(gfx::Vector2d(0, kSmallShadowVerticalOffset),
+                       2 * kSmallShadowBlur, kSmallShadowColor);
+  shadows.emplace_back(gfx::Vector2d(0, kLargeShadowVerticalOffset),
+                       2 * kLargeShadowBlur, kLargeShadowColor);
+  paint.setLooper(gfx::CreateShadowDrawLooperCorrectBlur(shadows));
+  paint.setColor(SkColorSetA(SK_ColorBLACK, 0x0D));
+  paint.setAntiAlias(true);
+
+  gfx::Rect bounds(view.GetLocalBounds());
+  bounds.Inset(GetInsets());
+  SkRRect r_rect =
+      SkRRect::MakeRectXY(gfx::RectToSkRect(bounds), GetBorderCornerRadius(),
+                          GetBorderCornerRadius());
+  // Clip out a round rect so the fill and shadow don't draw over the contents
+  // of the bubble.
+  SkRRect clip_r_rect = r_rect;
+  // Stroke width is a single pixel at any scale factor.
+  const SkScalar one_pixel = SkFloatToScalar(1 / canvas->image_scale());
+  clip_r_rect.inset(one_pixel, one_pixel);
+  canvas->sk_canvas()->clipRRect(clip_r_rect, SkRegion::kDifference_Op,
+                                 true /*doAntiAlias*/);
+  canvas->sk_canvas()->drawRRect(r_rect, 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