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;
     }
 
+#if defined(OS_ANDROID)

[bokan, 2017/03/22 20:07:25]

This file is only compiled for Aura platforms so Chrome OS, Linux, Windows. You
shouldn't need an ifdef here.

     // In overlay mode, draw a stroke (border).
     constexpr int kStrokeWidth = kOverlayScrollbarStrokeWidth;
     cc::PaintFlags flags;
     flags.setColor(
         SkColorSetA(kOverlayScrollbarStrokeColor[theme], stroke_alpha));
     flags.setStyle(cc::PaintFlags::kStroke_Style);
     flags.setStrokeWidth(kStrokeWidth);
 
     gfx::RectF stroke_rect(thumb_rect);
     constexpr float kHalfStrokeWidth = kStrokeWidth / 2.f;
     stroke_rect.Inset(kHalfStrokeWidth, kHalfStrokeWidth);
     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);
+#else  // OS_ANDROID
+    // In overlay mode, draw a stroke (border).
+    constexpr int kStrokeWidth = kOverlayScrollbarStrokeWidth;
+    cc::PaintFlags flags;
+    flags.setColor(SkColorSetA(
+        kOverlayScrollbarStrokeColor[params.scrollbar_theme], stroke_alpha));
+    flags.setStyle(cc::PaintFlags::kStroke_Style);
+    flags.setStrokeWidth(kStrokeWidth);
+
+    gfx::RectF stroke_rect(thumb_rect);
+    constexpr float kHalfStrokeWidth = kStrokeWidth / 2.f;
+
+    float left_stroke_width, top_stroke_width, right_stroke_width,
+        bottom_stroke_width;
+
+    left_stroke_width = top_stroke_width = right_stroke_width =
+        bottom_stroke_width = kHalfStrokeWidth;
+
+    if (params.isLeftVerticalScrollbar) {
+      left_stroke_width = 0;
+    } else if (params.isVerticalScrollbar) {
+      right_stroke_width = 0;
+    } else {
+      bottom_stroke_width = 0;
+    }
+
+    if (params.hitStart) {
+      if (params.isVerticalScrollbar) {
+        top_stroke_width = 0;
+      } else {
+        left_stroke_width = 0;
+      }
+    }
+
+    if (params.hitEnd) {
+      if (params.isVerticalScrollbar) {
+        bottom_stroke_width = 0;
+      } else {
+        right_stroke_width = 0;
+      }
+    }
+
+    stroke_rect.Inset(left_stroke_width, top_stroke_width, right_stroke_width,
+                      bottom_stroke_width);
+    canvas->drawRect(gfx::RectFToSkRect(stroke_rect), flags);
+
+    // Inset the all the edges edges so we fill-in the stroke below.
+    thumb_rect.Inset(left_stroke_width * 2, top_stroke_width * 2,
+                     right_stroke_width * 2, bottom_stroke_width * 2);
+#endif
   } 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