Fix appearance of task manager border at fractional scale factors.

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/gfx/canvas.h"
 #include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/scoped_canvas.h"
 #include "ui/views/painter.h"
 #include "ui/views/view.h"
 
 namespace views {
 
 namespace {
 
 // A simple border with different thicknesses on each side and single color.
 class SolidSidedBorder : public Border {
  public:
@@ skipping 10 matching lines @@
 
   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) {
-  // Top border.
-  canvas->FillRect(gfx::Rect(0, 0, view.width(), insets_.top()), color_);
-  // Left border.
-  canvas->FillRect(gfx::Rect(0, insets_.top(), insets_.left(),
-                             view.height() - insets_.height()), color_);
-  // Bottom border.
-  canvas->FillRect(gfx::Rect(0, view.height() - insets_.bottom(), view.width(),
-                             insets_.bottom()), color_);
-  // Right border.
-  canvas->FillRect(gfx::Rect(view.width() - insets_.right(), insets_.top(),
-                             insets_.right(), view.height() - insets_.height()),
-                   color_);
+  // 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 bounds(view.GetLocalBounds());
+  bounds.Scale(dsf);
+  // This scaling operation floors the inset values.
+  bounds.Inset(insets_.Scale(dsf));
+  // If the view has a layer, it will be snapped to pixel bounds, giving the
+  // canvas integral dimensions. Therefore we have to round up. Otherwise, no
+  // rounding is necessary as the view's canvas won't be integral.
+  if (view.layer())
+    bounds = gfx::RectF(gfx::ToEnclosingRect(bounds));

[Peter Kasting, 2017/02/18 00:08:28]

Why ToEnclosingRect() and not ToEnclosedRect()?  The latter seems more correct
to me in the example Eric gave.

[ericrk, 2017/02/18 00:37:25]

Agreed.

Interestingly, it appears that the view.layer() check doesn't fully cover the
case I'm dealing with (the autofill popup). In the autofill popup case, the view
does not seem to have a layer.

Need to understand things a bit better, but in the autofill case, the
AutofillPopupBaseView creates a new Widget and acts as a WidgetDelegateView. The
widget itself is pixel sized, and the view appears to draw to the widget without
requiring a layer.

+  canvas->ClipRect(bounds, SkClipOp::kDifference);
+  canvas->DrawColor(color_);
 }
 
 gfx::Insets SolidSidedBorder::GetInsets() const {
   return insets_;
 }
 
 gfx::Size SolidSidedBorder::GetMinimumSize() const {
   return gfx::Size(insets_.width(), insets_.height());
 }
 
@@ skipping 182 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