Overlay scrollbars flush with window edge

ui/native_theme/native_theme_aura.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/native_theme/native_theme_aura.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 168 matching lines @@
   cc::PaintFlags flags;
   flags.setColor(kTrackColor);
   canvas->drawIRect(gfx::RectToSkIRect(rect), flags);
 }
 
 void NativeThemeAura::PaintScrollbarThumb(
     cc::PaintCanvas* canvas,
     Part part,
     State state,
     const gfx::Rect& rect,
-    ScrollbarOverlayColorTheme theme) const {
+    const NativeTheme::ScrollbarThumbExtraParams& params) const {
   // Do not paint if state is disabled.
   if (state == kDisabled)
     return;
 
   TRACE_EVENT0("blink", "NativeThemeAura::PaintScrollbarThumb");
 
   SkAlpha thumb_alpha = SK_AlphaTRANSPARENT;
   gfx::Rect thumb_rect(rect);
   SkColor thumb_color;
 
   if (use_overlay_scrollbars_) {
     // Constants used for painting overlay scrollbar thumb.
     constexpr SkAlpha kOverlayScrollbarFillAlphaNormal = 0x4D;
     constexpr SkAlpha kOverlayScrollbarFillAlphaHovered = 0x80;
     constexpr SkAlpha kOverlayScrollbarFillAlphaPressed = 0x80;
     constexpr SkAlpha kOverlayScrollbarStrokeAlphaNormal = 0x4D;
     constexpr SkAlpha kOverlayScrollbarStrokeAlphaHovered = 0x58;
     constexpr SkAlpha kOverlayScrollbarStrokeAlphaPressed = 0x80;
 
     // Indexed by ScrollbarOverlayColorTheme.
     constexpr SkColor kOverlayScrollbarThumbColor[] = {SK_ColorBLACK,
                                                        SK_ColorWHITE};
     constexpr SkColor kOverlayScrollbarStrokeColor[] = {SK_ColorWHITE,
                                                         SK_ColorBLACK};
 
-    thumb_color = kOverlayScrollbarThumbColor[theme];
+    thumb_color = kOverlayScrollbarThumbColor[params.scrollbar_theme];
 
     SkAlpha stroke_alpha = SK_AlphaTRANSPARENT;
     switch (state) {
       case NativeTheme::kDisabled:
         thumb_alpha = SK_AlphaTRANSPARENT;
         stroke_alpha = SK_AlphaTRANSPARENT;
         break;
       case NativeTheme::kHovered:
         thumb_alpha = kOverlayScrollbarFillAlphaHovered;
         stroke_alpha = kOverlayScrollbarStrokeAlphaHovered;
         break;
       case NativeTheme::kNormal:
         thumb_alpha = kOverlayScrollbarFillAlphaNormal;
         stroke_alpha = kOverlayScrollbarStrokeAlphaNormal;
         break;
       case NativeTheme::kPressed:
         thumb_alpha = kOverlayScrollbarFillAlphaPressed;
         stroke_alpha = kOverlayScrollbarStrokeAlphaPressed;
         break;
       case NativeTheme::kNumStates:
         NOTREACHED();
         break;
     }
 
     // In overlay mode, draw a stroke (border).
     constexpr int kStrokeWidth = kOverlayScrollbarStrokeWidth;
     cc::PaintFlags flags;
-    flags.setColor(
-        SkColorSetA(kOverlayScrollbarStrokeColor[theme], stroke_alpha));
+    flags.setColor(SkColorSetA(
+        kOverlayScrollbarStrokeColor[params.scrollbar_theme], stroke_alpha));
     flags.setStyle(cc::PaintFlags::kStroke_Style);
     flags.setStrokeWidth(kStrokeWidth);
 
+    int leftStrokeWidth, topStrokeWidth, rightStrokeWidth, bottomStrokeWidth;
+    leftStrokeWidth = topStrokeWidth = rightStrokeWidth = bottomStrokeWidth =
+        kStrokeWidth;
+
+    // Flush the stroke when it close to border.

[bokan, 2017/03/23 21:34:41]

A better comment would be "The edge to which the scrollbar is attached shouldn't
have a border"

+    if (part == NativeTheme::kScrollbarVerticalThumb) {
+      if (params.isLeftVerticalScrollbar)
+        leftStrokeWidth = 0;
+      else
+        rightStrokeWidth = 0;
+    } else {
+      bottomStrokeWidth = 0;
+    }
+
     gfx::RectF stroke_rect(thumb_rect);
-    constexpr float kHalfStrokeWidth = kStrokeWidth / 2.f;
-    stroke_rect.Inset(kHalfStrokeWidth, kHalfStrokeWidth);
+    stroke_rect.Inset(leftStrokeWidth / 2.f, topStrokeWidth / 2.f,

[bokan, 2017/03/23 21:34:41]

The drawRect call below is the one that draws the outline. Since we're going to
paint over it with the fill anyway, there's no need to change the inset above
(in fact I think this moves the stroke out a little). You should only change the
inset after the drawRect call below so that the fill paints over that one side.
(as I did in my patch).

I also think it'd be clearer to just put the thumb_rect.Inset call itself inside
the if statements and vary which parameter gets the 0 based on
vertical|horizontal|isLeftVertical, rather than define left, right, top, bottom
stroke widths.

+                      rightStrokeWidth / 2.f, bottomStrokeWidth / 2.f);
     canvas->drawRect(gfx::RectFToSkRect(stroke_rect), flags);
 
     // Inset the all the edges edges so we fill-in the stroke below.
-    thumb_rect.Inset(kStrokeWidth, kStrokeWidth);
+    thumb_rect.Inset(leftStrokeWidth, topStrokeWidth, rightStrokeWidth,
+                     bottomStrokeWidth);
   } else {
     switch (state) {
       case NativeTheme::kDisabled:
         thumb_alpha = SK_AlphaTRANSPARENT;
         break;
       case NativeTheme::kHovered:
         thumb_alpha = 0x4D;
         break;
       case NativeTheme::kNormal:
         thumb_alpha = 0x33;
@@ skipping 75 matching lines @@
 
 gfx::Rect NativeThemeAura::GetNinePatchAperture(Part part) const {
   DCHECK(SupportsNinePatch(part));
 
   return gfx::Rect(
       kOverlayScrollbarBorderPatchWidth, kOverlayScrollbarBorderPatchWidth,
       kOverlayScrollbarCenterPatchSize, kOverlayScrollbarCenterPatchSize);
 }
 
 }  // namespace ui