Update ash shelf/tray focus rects.

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"
 #include "base/memory/ptr_util.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/insets_f.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/size_f.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/nine_image_painter.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/views/view.h"
@@ skipping 85 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, const gfx::Insets& insets);
+  SolidFocusPainter(SkColor color,
+                    SkScalar 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 gfx::Insets insets_;
+  const SkScalar thickness_;
+  const gfx::InsetsF insets_;
 
   DISALLOW_COPY_AND_ASSIGN(SolidFocusPainter);
 };
 
 SolidFocusPainter::SolidFocusPainter(SkColor color,
-                                     const gfx::Insets& insets)
-    : color_(color),
-      insets_(insets) {
-}
+                                     SkScalar thickness,
+                                     const gfx::InsetsF& insets)
+    : color_(color), thickness_(thickness), insets_(insets) {}
 
 SolidFocusPainter::~SolidFocusPainter() {
 }
 
 gfx::Size SolidFocusPainter::GetMinimumSize() const {
   return gfx::Size();
 }
 
 void SolidFocusPainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) {
-  gfx::Rect rect(size);
+  gfx::RectF rect((gfx::Rect(size)));
   rect.Inset(insets_);
-  canvas->DrawSolidFocusRect(rect, color_);
+  canvas->DrawSolidFocusRect(rect, color_, thickness_);
 }
 
 // GradientPainter ------------------------------------------------------------
 
 class GradientPainter : public Painter {
  public:
   GradientPainter(bool horizontal,
                   SkColor* colors,
                   SkScalar* pos,
                   size_t count);
@@ skipping 186 matching lines @@
 // static
 std::unique_ptr<Painter> Painter::CreateDashedFocusPainterWithInsets(
     const gfx::Insets& insets) {
   return base::MakeUnique<DashedFocusPainter>(insets);
 }
 
 // static
 std::unique_ptr<Painter> Painter::CreateSolidFocusPainter(
     SkColor color,
     const gfx::Insets& insets) {
-  return base::MakeUnique<SolidFocusPainter>(color, 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);
+}
+
+// static
+std::unique_ptr<Painter> Painter::CreateSolidFocusPainter(
+    SkColor color,
+    float thickness,
+    const gfx::InsetsF& insets) {
+  return base::MakeUnique<SolidFocusPainter>(color, SkFloatToScalar(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