Adjust overlay scrollbar appearance.

ui/views/controls/scrollbar/overlay_scroll_bar.cc

 // Copyright 2013 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/controls/scrollbar/overlay_scroll_bar.h"
 
 #include "base/macros.h"
 #include "cc/paint/paint_flags.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
+#include "ui/native_theme/overlay_scrollbar_constants_aura.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 
 namespace views {
 namespace {
 
 // Total thickness of the thumb (matches visuals when hovered).
-const int kThumbThickness = 11;
+constexpr int kThumbThickness =
+    ui::kOverlayScrollbarThumbWidthPressed + ui::kOverlayScrollbarStrokeWidth;
 // When hovered, the thumb takes up the full width. Otherwise, it's a bit
 // slimmer.
-const int kThumbHoverOffset = 4;
-const int kThumbStroke = 1;
-const float kThumbHoverAlpha = 0.5f;
-const float kThumbDefaultAlpha = 0.3f;
+constexpr int kThumbHoverOffset = 4;
+// The layout size of the thumb stroke, in DIP.
+constexpr int kThumbStroke = ui::kOverlayScrollbarStrokeWidth;
+// The visual size of the thumb stroke, in px.
+constexpr int kThumbStrokeVisualSize = ui::kOverlayScrollbarStrokeWidth;
 
 }  // namespace
 
 OverlayScrollBar::Thumb::Thumb(OverlayScrollBar* scroll_bar)
     : BaseScrollBarThumb(scroll_bar), scroll_bar_(scroll_bar) {
   // |scroll_bar| isn't done being constructed; it's not safe to do anything
   // that might reference it yet.
 }
 
 OverlayScrollBar::Thumb::~Thumb() {}
@@ skipping 22 matching lines @@
   gfx::RectF fill_bounds(GetLocalBounds());
   fill_bounds.Inset(gfx::InsetsF(IsHorizontal() ? kThumbHoverOffset : 0,
                                  IsHorizontal() ? 0 : kThumbHoverOffset, 0, 0));
   fill_bounds.Inset(gfx::InsetsF(kThumbStroke, kThumbStroke,
                                  IsHorizontal() ? 0 : kThumbStroke,
                                  IsHorizontal() ? kThumbStroke : 0));
   canvas->DrawRect(fill_bounds, fill_flags);
 
   cc::PaintFlags stroke_flags;
   stroke_flags.setStyle(cc::PaintFlags::kStroke_Style);
-  stroke_flags.setColor(SK_ColorWHITE);
-  stroke_flags.setStrokeWidth(kThumbStroke);
+  stroke_flags.setColor(
+      SkColorSetA(SK_ColorWHITE, (ui::kOverlayScrollbarStrokeNormalAlpha /
+                                  ui::kOverlayScrollbarThumbNormalAlpha) *
+                                     SK_AlphaOPAQUE));
+  stroke_flags.setStrokeWidth(kThumbStrokeVisualSize);
   stroke_flags.setStrokeCap(cc::PaintFlags::kSquare_Cap);
+
+  // The stroke is a single pixel, so we must deal with the unscaled canvas.
+  const float dsf = canvas->UndoDeviceScaleFactor();
   gfx::RectF stroke_bounds(fill_bounds);
-  stroke_bounds.Inset(gfx::InsetsF(kThumbStroke / 2.f));
+  stroke_bounds.Scale(dsf);
+  // The stroke should be aligned to the pixel center that is nearest the fill,
+  // so outset by a half pixel.
+  stroke_bounds.Inset(gfx::InsetsF(-kThumbStrokeVisualSize / 2.0f));
   // The stroke doesn't apply to the far edge of the thumb.
   SkPath path;
   path.moveTo(gfx::PointFToSkPoint(stroke_bounds.top_right()));
   path.lineTo(gfx::PointFToSkPoint(stroke_bounds.origin()));
   path.lineTo(gfx::PointFToSkPoint(stroke_bounds.bottom_left()));
   if (IsHorizontal()) {
     path.moveTo(gfx::PointFToSkPoint(stroke_bounds.bottom_right()));
     path.close();
   } else {
     path.lineTo(gfx::PointFToSkPoint(stroke_bounds.bottom_right()));
   }
   canvas->DrawPath(path, stroke_flags);
 }
 
 void OverlayScrollBar::Thumb::OnBoundsChanged(
     const gfx::Rect& previous_bounds) {
   scroll_bar_->Show();
   // Don't start the hide countdown if the thumb is still hovered or pressed.
   if (GetState() == CustomButton::STATE_NORMAL)
     scroll_bar_->StartHideCountdown();
 }
 
 void OverlayScrollBar::Thumb::OnStateChanged() {
   if (GetState() == CustomButton::STATE_NORMAL) {
     gfx::Transform translation;
     translation.Translate(
         gfx::Vector2d(IsHorizontal() ? 0 : kThumbHoverOffset,
                       IsHorizontal() ? kThumbHoverOffset: 0));
     layer()->SetTransform(translation);
-    layer()->SetOpacity(kThumbDefaultAlpha);
+    layer()->SetOpacity(ui::kOverlayScrollbarThumbNormalAlpha);
 
     if (GetWidget())
       scroll_bar_->StartHideCountdown();
   } else {
     layer()->SetTransform(gfx::Transform());
-    layer()->SetOpacity(kThumbHoverAlpha);
+    layer()->SetOpacity(ui::kOverlayScrollbarThumbHoverAlpha);
   }
 }
 
 OverlayScrollBar::OverlayScrollBar(bool horizontal)
     : BaseScrollBar(horizontal), hide_timer_(false, false) {
   auto* thumb = new Thumb(this);
   SetThumb(thumb);
   thumb->Init();
   set_notify_enter_exit_on_child(true);
   SetPaintToLayer();
@@ skipping 40 matching lines @@
   StartHideCountdown();
 }
 
 void OverlayScrollBar::Show() {
   layer()->SetOpacity(1.0f);
   hide_timer_.Stop();
 }
 
 void OverlayScrollBar::Hide() {
   ui::ScopedLayerAnimationSettings settings(layer()->GetAnimator());
-  settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(200));
+  settings.SetTransitionDuration(ui::kOverlayScrollbarFadeOutDuration);
   layer()->SetOpacity(0.0f);
 }
 
 void OverlayScrollBar::StartHideCountdown() {
   if (IsMouseHovered())
     return;
   hide_timer_.Start(
-      FROM_HERE, base::TimeDelta::FromSeconds(1),
+      FROM_HERE, ui::kOverlayScrollbarFadeOutDelay,
       base::Bind(&OverlayScrollBar::Hide, base::Unretained(this)));
 }
 
 }  // namespace views