Improve appearance of focus rings at fractional scales.

ui/views/painter.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/painter.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 103 matching lines @@
 void DashedFocusPainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) {
   gfx::Rect rect(size);
   rect.Inset(insets_);
   canvas->DrawFocusRect(rect);
 }
 
 // SolidFocusPainter -----------------------------------------------------------
 
 class SolidFocusPainter : public Painter {
  public:
-  SolidFocusPainter(SkColor color,
-                    SkScalar thickness,
-                    const gfx::InsetsF& insets);
+  SolidFocusPainter(SkColor color, int thickness, const gfx::InsetsF& insets);
   ~SolidFocusPainter() override;
 
   // Painter:
   gfx::Size GetMinimumSize() const override;
   void Paint(gfx::Canvas* canvas, const gfx::Size& size) override;
 
  private:
   const SkColor color_;
-  const SkScalar thickness_;
+  const int thickness_;
   const gfx::InsetsF insets_;
 
   DISALLOW_COPY_AND_ASSIGN(SolidFocusPainter);
 };
 
 SolidFocusPainter::SolidFocusPainter(SkColor color,
-                                     SkScalar thickness,
+                                     int thickness,
                                      const gfx::InsetsF& insets)
     : color_(color), thickness_(thickness), insets_(insets) {}
 
 SolidFocusPainter::~SolidFocusPainter() {
 }
 
 gfx::Size SolidFocusPainter::GetMinimumSize() const {
   return gfx::Size();
 }
 
@@ skipping 195 matching lines @@
 
 // static
 std::unique_ptr<Painter> Painter::CreateSolidFocusPainter(
     SkColor color,
     const gfx::Insets& insets) {
   // Before Canvas::DrawSolidFocusRect correctly inset the rect's bounds based
   // on the thickness, callers had to add 1 to the bottom and right insets.
   // Subtract that here so it works the same way with the new
   // Canvas::DrawSolidFocusRect.
   const gfx::Insets corrected_insets = insets - gfx::Insets(0, 0, 1, 1);
-  return base::MakeUnique<SolidFocusPainter>(color, SkIntToScalar(1),
-                                             corrected_insets);
+  return base::MakeUnique<SolidFocusPainter>(color, 1, corrected_insets);
 }
 
 // static
 std::unique_ptr<Painter> Painter::CreateSolidFocusPainter(
     SkColor color,
-    float thickness,
+    int thickness,
     const gfx::InsetsF& insets) {
-  return base::MakeUnique<SolidFocusPainter>(color, SkFloatToScalar(thickness),
-                                             insets);
+  return base::MakeUnique<SolidFocusPainter>(color, thickness, insets);
 }
 
 // HorizontalPainter ----------------------------------------------------------
 
 HorizontalPainter::HorizontalPainter(const int image_resource_names[]) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   for (int i = 0; i < 3; ++i)
     images_[i] = rb.GetImageNamed(image_resource_names[i]).ToImageSkia();
   DCHECK_EQ(images_[LEFT]->height(), images_[CENTER]->height());
   DCHECK_EQ(images_[LEFT]->height(), images_[RIGHT]->height());
@@ skipping 15 matching lines @@
   canvas->DrawImageInt(*images_[LEFT], 0, 0);
   canvas->DrawImageInt(*images_[RIGHT], size.width() - images_[RIGHT]->width(),
                        0);
   canvas->TileImageInt(
       *images_[CENTER], images_[LEFT]->width(), 0,
       size.width() - images_[LEFT]->width() - images_[RIGHT]->width(),
       images_[LEFT]->height());
 }
 
 }  // namespace views