Harmony - Draw bubble/dialog borders just outside the content area

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"
@@ skipping 42 matching lines @@
     arrow_thickness = top_arrow.height();
   }
 }
 
 BorderImages::~BorderImages() {}
 
 }  // namespace internal
 
 namespace {
 
+// The border is stroked at 1px, but for the purposes of reserving space we have
+// to deal in dip coordinates, so round up to 1dip.
+const int kBorderThicknessDip = 1;
+const int kBorderStrokeThicknessPx = 1;
+
 // 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);
 
@@ skipping 131 matching lines @@
 }
 
 gfx::Rect BubbleBorder::GetBounds(const gfx::Rect& anchor_rect,
                                   const gfx::Size& contents_size) const {
   // In MD, there are no arrows, so positioning logic is significantly simpler.
   // TODO(estade): handle more anchor positions.
   if (UseMd() &&
       (arrow_ == TOP_RIGHT || arrow_ == TOP_LEFT || arrow_ == BOTTOM_CENTER ||
        arrow_ == LEFT_CENTER || arrow_ == RIGHT_CENTER)) {
     gfx::Rect contents_bounds(contents_size);
+    // Apply the border part of the inset before calculating coordinates because
+    // the border should align with the anchor's border. For the purposes of
+    // positioning, the border is rounded up to a dip, which may mean we have
+    // misalignment in scale factors greater than 1.
+    // TODO(estade): when it becomes possible to provide px bounds instead of
+    // dip bounds, fix this.
+    const gfx::Insets border_insets = gfx::Insets(kBorderThicknessDip);
+    const gfx::Insets shadow_insets = GetInsets() - border_insets;
+    contents_bounds.Inset(-border_insets);
     if (arrow_ == TOP_RIGHT) {
       contents_bounds +=
           anchor_rect.bottom_right() - contents_bounds.top_right();
     } else if (arrow_ == TOP_LEFT) {
       contents_bounds +=
           anchor_rect.bottom_left() - contents_bounds.origin();
     } else if (arrow_ == BOTTOM_CENTER) {
       contents_bounds += CenterTop(anchor_rect) - CenterBottom(contents_bounds);
     } else if (arrow_ == LEFT_CENTER) {
       contents_bounds += RightCenter(anchor_rect) - LeftCenter(contents_bounds);
     } else if (arrow_ == RIGHT_CENTER) {
       contents_bounds += LeftCenter(anchor_rect) - RightCenter(contents_bounds);
     }
-    contents_bounds.Inset(-GetInsets());
+    contents_bounds.Inset(-shadow_insets);
     // |arrow_offset_| is used to adjust bubbles that would normally be
     // partially offscreen.
     contents_bounds += gfx::Vector2d(-arrow_offset_, 0);
     return contents_bounds;
   }
 
   int x = anchor_rect.x();
   int y = anchor_rect.y();
   int w = anchor_rect.width();
   int h = anchor_rect.height();
@@ skipping 107 matching lines @@
   canvas->Restore();
 
   DrawArrow(canvas, arrow_bounds);
 }
 
 gfx::Insets BubbleBorder::GetInsets() const {
   if (UseMd()) {
      gfx::Insets blur(kLargeShadowBlur);
      gfx::Insets offset(-kLargeShadowVerticalOffset, 0,
                         kLargeShadowVerticalOffset, 0);
+     gfx::Insets border(kBorderThicknessDip);
      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);
@@ skipping 134 matching lines @@
   // 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, 0x26));
   paint.setAntiAlias(true);
 
-  gfx::Rect bounds(view.GetLocalBounds());
+  gfx::RectF 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);
+  SkRRect clip_r_rect =
+      SkRRect::MakeRectXY(gfx::RectFToSkRect(bounds), GetBorderCornerRadius(),
+                          GetBorderCornerRadius());
   canvas->sk_canvas()->clipRRect(clip_r_rect, SkRegion::kDifference_Op,
                                  true /*doAntiAlias*/);
+
+  // The border is drawn outside the content area.
+  SkRRect r_rect = clip_r_rect;
+  const SkScalar one_pixel =
+      SkFloatToScalar(kBorderStrokeThicknessPx / canvas->image_scale());
+  r_rect.inset(-one_pixel, -one_pixel);
   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::RectF bounds(view->GetLocalBounds());
   bounds.Inset(gfx::InsetsF(border_->GetInsets()));
-  if (UseMd()) {
-    // The border is 1px at all scale factors. Leave room for it. It's partially
-    // transparent, so we don't want to draw any background underneath it.
-    const SkScalar one_pixel = SkFloatToScalar(1 / canvas->image_scale());
-    bounds.Inset(gfx::InsetsF(one_pixel));
-  }
 
   canvas->DrawRoundRect(bounds, border_->GetBorderCornerRadius(), paint);
 }
 
 }  // namespace views