Add SolidSidedWidgetBorder

ui/views/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/border.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "cc/paint/paint_flags.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/views/painter.h"
 #include "ui/views/view.h"
+#include "ui/views/widget/widget.h"
 
 namespace views {
 
 namespace {
 
 // A simple border with different thicknesses on each side and single color.
 class SolidSidedBorder : public Border {
  public:
   SolidSidedBorder(const gfx::Insets& insets, SkColor color);
 
   // Overridden from Border:
   void Paint(const View& view, gfx::Canvas* canvas) override;
   gfx::Insets GetInsets() const override;
   gfx::Size GetMinimumSize() const override;
 
+ protected:
+  // Returns the scaled bounds to inset from. Default implementation works
+  // well for views that are not drawn directly to a layer / widget.
+  virtual gfx::RectF ScaledBounds(const View& view, float dsf) const;
+
  private:
   const gfx::Insets insets_;
   const SkColor color_;
 
   DISALLOW_COPY_AND_ASSIGN(SolidSidedBorder);
 };
 
 SolidSidedBorder::SolidSidedBorder(const gfx::Insets& insets, SkColor color)
     : insets_(insets),
       color_(color) {
 }
 
 void SolidSidedBorder::Paint(const View& view, gfx::Canvas* canvas) {
   // Undo DSF so that we can be sure to draw an integral number of pixels for
   // the border. Integral scale factors should be unaffected by this, but for
   // fractional scale factors this ensures sharp lines.
   gfx::ScopedCanvas scoped(canvas);
   float dsf = canvas->UndoDeviceScaleFactor();
-
-  gfx::RectF scaled_bounds;
-  if (view.layer()) {
-    scaled_bounds =
-        gfx::RectF(ui::ConvertRectToPixel(view.layer(), view.GetLocalBounds()));
-  } else {
-    scaled_bounds = gfx::RectF(view.GetLocalBounds());
-    scaled_bounds.Scale(dsf);
-  }
+  gfx::RectF scaled_bounds = ScaledBounds(view, dsf);
 
   // This scaling operation floors the inset values.
   scaled_bounds.Inset(insets_.Scale(dsf));
   canvas->sk_canvas()->clipRect(gfx::RectFToSkRect(scaled_bounds),
                                 SkClipOp::kDifference, true);
   canvas->DrawColor(color_);
 }
 
 gfx::Insets SolidSidedBorder::GetInsets() const {
   return insets_;
 }
 
 gfx::Size SolidSidedBorder::GetMinimumSize() const {
   return gfx::Size(insets_.width(), insets_.height());
 }
 
+gfx::RectF SolidSidedBorder::ScaledBounds(const View& view, float dsf) const {
+  gfx::RectF scaled_bounds;
+  if (view.layer()) {
+    scaled_bounds =
+        gfx::RectF(ui::ConvertRectToPixel(view.layer(), view.GetLocalBounds()));
+  } else {
+    scaled_bounds = gfx::RectF(view.GetLocalBounds());
+    scaled_bounds.Scale(dsf);
+  }
+
+  return scaled_bounds;
+}
+
+// Subclass of SolidSidedBorder which handles rounding correctly for a view
+// drawn to a root widget.
+class SolidSidedWidgetBorder : public SolidSidedBorder {
+ public:
+  SolidSidedWidgetBorder(const gfx::Insets& insets, SkColor color);
+
+ private:
+  // Overridden from SolidSidedBorder:
+  gfx::RectF ScaledBounds(const View& view, float dsf) const override;
+};
+
+SolidSidedWidgetBorder::SolidSidedWidgetBorder(const gfx::Insets& insets,
+                                               SkColor color)
+    : SolidSidedBorder(insets, color) {}
+
+gfx::RectF SolidSidedWidgetBorder::ScaledBounds(const View& view,
+                                                float dsf) const {
+  return gfx::RectF(gfx::ScaleToEnclosedRect(view.GetLocalBounds(), dsf));
+}
+
 // A border with a rounded rectangle and single color.
 class RoundedRectBorder : public Border {
  public:
   RoundedRectBorder(int thickness, int corner_radius, SkColor color);
 
   // Overridden from Border:
   void Paint(const View& view, gfx::Canvas* canvas) override;
   gfx::Insets GetInsets() const override;
   gfx::Size GetMinimumSize() const override;
 
@@ skipping 135 matching lines @@
 Border::~Border() {}
 
 std::unique_ptr<Border> NullBorder() {
   return nullptr;
 }
 
 std::unique_ptr<Border> CreateSolidBorder(int thickness, SkColor color) {
   return base::MakeUnique<SolidSidedBorder>(gfx::Insets(thickness), color);
 }
 
+std::unique_ptr<Border> CreateSolidWidgetBorder(int thickness, SkColor color) {
+  return base::MakeUnique<SolidSidedWidgetBorder>(gfx::Insets(thickness),
+                                                  color);
+}
+
 std::unique_ptr<Border> CreateEmptyBorder(const gfx::Insets& insets) {
   return base::MakeUnique<EmptyBorder>(insets);
 }
 
 std::unique_ptr<Border> CreateRoundedRectBorder(int thickness,
                                                 int corner_radius,
                                                 SkColor color) {
   return base::MakeUnique<RoundedRectBorder>(thickness, corner_radius, color);
 }
 
@@ skipping 17 matching lines @@
                                            const gfx::Insets& insets) {
   return base::MakeUnique<ExtraInsetsBorder>(std::move(border), insets);
 }
 
 std::unique_ptr<Border> CreateBorderPainter(std::unique_ptr<Painter> painter,
                                             const gfx::Insets& insets) {
   return base::WrapUnique(new BorderPainter(std::move(painter), insets));
 }
 
 }  // namespace views