Aura overlay scrollbars adjust color for dark backgrounds

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"
 #include "build/build_config.h"
 #include "ui/base/layout.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/native_theme/common_theme.h"
+#include "ui/native_theme/material_design_constants.h"
 #include "ui/native_theme/native_theme_switches.h"
 
 namespace ui {
 
 namespace {
 
 SkAlpha ThumbAlphaForState(NativeTheme::State state) {
   bool overlay = IsOverlayScrollbarEnabled();
   switch (state) {
     case NativeTheme::kDisabled:
       return 0x00;
     case NativeTheme::kHovered:
-      return overlay ? 0xB2 : 0x4D;
+      return overlay ? kMDScrollbarAlphaHovered : 0x4D;
     case NativeTheme::kNormal:
-      return overlay ? 0x8C : 0x33;
+      return overlay ? kMDScrollbarAlphaNormal : 0x33;
     case NativeTheme::kPressed:
-      return overlay ? 0xB2 : 0x80;
+      return overlay ? kMDScrollbarAlphaPressed : 0x80;
     case NativeTheme::kNumStates:
       break;
   }
 
   NOTREACHED();
   return 0xFF;
 }
 
 SkAlpha ThumbStrokeAlphaForState(NativeTheme::State state) {
   DCHECK(IsOverlayScrollbarEnabled());
   switch (state) {
     case NativeTheme::kDisabled:
       return 0x00;
     case NativeTheme::kHovered:
+      return kMDScrollbarAlphaHovered;
     case NativeTheme::kPressed:
-      return 0x33;
+      return kMDScrollbarAlphaPressed;
     case NativeTheme::kNormal:
-      return 0x26;
+      return kMDScrollbarAlphaNormal;
     case NativeTheme::kNumStates:
       break;
   }
 
   NOTREACHED();
   return 0xFF;
 }
 
 const SkColor kTrackColor = SkColorSetRGB(0xF1, 0xF1, 0xF1);
 
 }  // namespace
 
 // static
 NativeTheme* NativeTheme::GetInstanceForWeb() {
   return NativeThemeAura::instance();
 }
 
 // static
 NativeThemeAura* NativeThemeAura::instance() {
   CR_DEFINE_STATIC_LOCAL(NativeThemeAura, s_native_theme, ());
   return &s_native_theme;
 }
 
 NativeThemeAura::NativeThemeAura() {
   // We don't draw scrollbar buttons.
 #if defined(OS_CHROMEOS)
   set_scrollbar_button_length(0);
 #endif
 
+  if (IsOverlayScrollbarEnabled()) {
+    scrollbar_width_ =
+        kMDScrollbarThumbWidthPressed + kMDScrollbarStrokeWidth * 2;
+  }
+
   // Images and alphas declarations assume the following order.
   static_assert(kDisabled == 0, "states unexpectedly changed");
   static_assert(kHovered == 1, "states unexpectedly changed");
   static_assert(kNormal == 2, "states unexpectedly changed");
   static_assert(kPressed == 3, "states unexpectedly changed");
 }
 
 NativeThemeAura::~NativeThemeAura() {
 }
 
@@ skipping 77 matching lines @@
   // Overlay Scrollbar should never paint a scrollbar track.
   DCHECK(!IsOverlayScrollbarEnabled());
   SkPaint paint;
   paint.setColor(kTrackColor);
   canvas->drawIRect(gfx::RectToSkIRect(rect), paint);
 }
 
 void NativeThemeAura::PaintScrollbarThumb(SkCanvas* canvas,
                                           Part part,
                                           State state,
-                                          const gfx::Rect& rect) const {
+                                          const gfx::Rect& rect,
+                                          ScrollbarOverlayStyle style) const {
   // Do not paint if state is disabled.
   if (state == kDisabled)
     return;
 
-  PaintScrollbarThumbStateTransition(canvas, part, state, state, 1.0, rect);
+  PaintScrollbarThumbStateTransition(canvas, part, state, state, 1.0, rect,
+                                     style);
 }
 
 void NativeThemeAura::PaintScrollbarThumbStateTransition(
     SkCanvas* canvas,
     Part part,
     State start_state,
     State end_state,
     double progress,
-    const gfx::Rect& rect) const {
+    const gfx::Rect& rect,
+    ScrollbarOverlayStyle style) const {
   gfx::Rect thumb_rect(rect);
+  SkColor thumb_color;
   if (IsOverlayScrollbarEnabled()) {
     // In overlay mode, draw a stroke (border).
-    const int kStrokeWidth = 1;
+    const int kStrokeWidth = kMDScrollbarStrokeWidth;
     SkAlpha stroke_alpha = gfx::Tween::IntValueBetween(
         progress, ThumbStrokeAlphaForState(start_state),
         ThumbStrokeAlphaForState(end_state));
     SkPaint paint;
-    paint.setColor(SkColorSetA(SK_ColorWHITE, stroke_alpha));
+    paint.setColor(SkColorSetA(kMDScrollbarStrokeColor, stroke_alpha));
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(kStrokeWidth);
+
+    // When stroking in skia, there's some surprising behavior so we need to
+    // inset the right and bottom edges first. See the discussion here:
+    // https://groups.google.com/forum/#!topic/skia-discuss/HGZcc3Z7w1Q
+    thumb_rect.Inset(0, 0, kStrokeWidth, kStrokeWidth);
     canvas->drawIRect(gfx::RectToSkIRect(thumb_rect), paint);
 
-    thumb_rect.Inset(kStrokeWidth, kStrokeWidth, kStrokeWidth, kStrokeWidth);
+    // Inset the top and left edges for filling in the stroke below.
+    thumb_rect.Inset(kStrokeWidth, kStrokeWidth, 0, 0);
+
+    // thumb_color = kMDScrollbarThumbColor;
+    if (style == ScrollbarOverlayStyleLight)
+      thumb_color = SK_ColorWHITE;
+    else
+      thumb_color = SK_ColorBLACK;
   } else {
     // If there are no scrollbuttons then provide some padding so that the thumb
     // doesn't touch the top of the track.
     const int kThumbPadding = 2;
     const int extra_padding =
         (scrollbar_button_length() == 0) ? kThumbPadding : 0;
     if (part == NativeTheme::kScrollbarVerticalThumb)
       thumb_rect.Inset(kThumbPadding, extra_padding);
     else
       thumb_rect.Inset(extra_padding, kThumbPadding);
+
+    thumb_color = SK_ColorBLACK;
   }
 
   SkPaint paint;
   SkAlpha alpha = gfx::Tween::IntValueBetween(
       progress, ThumbAlphaForState(start_state), ThumbAlphaForState(end_state));
-  paint.setColor(SkColorSetA(SK_ColorBLACK, alpha));
+  paint.setColor(SkColorSetA(thumb_color, alpha));
   canvas->drawIRect(gfx::RectToSkIRect(thumb_rect), paint);
 }
 
 void NativeThemeAura::PaintScrollbarCorner(SkCanvas* canvas,
                                            State state,
                                            const gfx::Rect& rect) const {
   // Overlay Scrollbar should never paint a scrollbar corner.
   DCHECK(!IsOverlayScrollbarEnabled());
   SkPaint paint;
   paint.setColor(SkColorSetRGB(0xDC, 0xDC, 0xDC));
   canvas->drawIRect(RectToSkIRect(rect), paint);
 }
 
 }  // namespace ui