Move Mac Scrollbar drawing code to NativeThemeMac

This change moves the bulk of the Mac scrollbar drawing code into
NativeThemeMac. This is done in order to bring this more into
alignment with other platforms and to make it easier to transition things over to color pipeline.

It contains changes to do this for both the views UI and web platform ui.
CocoaScrollbarPainter is removed now that all of its previous responsibilities are in NativeThemeMac.

Bug: 1056950
Change-Id: Iedc224b582a7bcbdf920ed4b58855b284bfd0f10
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2195561Reviewed-by: David Bokan <bokan@chromium.org>
Reviewed-by: Alison Maher <almaher@microsoft.com>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Elly Fong-Jones <ellyjones@chromium.org>
Commit-Queue: Joan Barnett <johnsm@microsoft.com>
Cr-Commit-Position: refs/heads/master@{#770796}

content/child/webthemeengine_impl_mac.cc

@@ -4,6 +4,9 @@
 
 #include "content/child/webthemeengine_impl_mac.h"
 
+#include "content/child/webthemeengine_impl_conversions.h"
+#include "ui/native_theme/native_theme.h"
+
 namespace content {
 
 blink::ForcedColors WebThemeEngineMac::GetForcedColors() const {
@@ -15,4 +18,65 @@ void WebThemeEngineMac::SetForcedColors(
   forced_colors_ = forced_colors;
 }
 
+void WebThemeEngineMac::Paint(cc::PaintCanvas* canvas,
+                              WebThemeEngine::Part part,
+                              WebThemeEngine::State state,
+                              const blink::WebRect& rect,
+                              const WebThemeEngine::ExtraParams* extra_params,
+                              blink::WebColorScheme color_scheme) {
+  if (IsScrollbarPart(part)) {
+    PaintMacScrollBarParts(canvas, part, state, rect, extra_params,
+                           color_scheme);
+    return;
+  }
+
+  WebThemeEngineDefault::Paint(canvas, part, state, rect, extra_params,
+                               color_scheme);
+}
+
+bool WebThemeEngineMac::IsScrollbarPart(WebThemeEngine::Part part) {
+  switch (part) {
+    case WebThemeEngine::kPartScrollbarHorizontalTrack:
+    case WebThemeEngine::kPartScrollbarVerticalTrack:
+    case WebThemeEngine::kPartScrollbarHorizontalThumb:
+    case WebThemeEngine::kPartScrollbarVerticalThumb:
+    case WebThemeEngine::kPartScrollbarCorner:
+      return true;
+    default:
+      return false;
+  }
+}
+
+void WebThemeEngineMac::PaintMacScrollBarParts(
+    cc::PaintCanvas* canvas,
+    WebThemeEngine::Part part,
+    WebThemeEngine::State state,
+    const blink::WebRect& rect,
+    const WebThemeEngine::ExtraParams* extra_params,
+    blink::WebColorScheme color_scheme) {
+  ui::NativeTheme::ExtraParams native_theme_extra_params;
+  native_theme_extra_params.scrollbar_extra.is_hovering =
+      extra_params->scrollbar_extra.is_hovering;
+  native_theme_extra_params.scrollbar_extra.is_overlay =
+      extra_params->scrollbar_extra.is_overlay;
+  switch (extra_params->scrollbar_extra.orientation) {
+    case WebThemeEngine::kVerticalOnRight:
+      native_theme_extra_params.scrollbar_extra.orientation =
+          ui::NativeTheme::ScrollbarOrientation::kVerticalOnRight;
+      break;
+    case WebThemeEngine::kVerticalOnLeft:
+      native_theme_extra_params.scrollbar_extra.orientation =
+          ui::NativeTheme::ScrollbarOrientation::kVerticalOnLeft;
+      break;
+    case WebThemeEngine::kHorizontal:
+      native_theme_extra_params.scrollbar_extra.orientation =
+          ui::NativeTheme::ScrollbarOrientation::kHorizontal;
+      break;
+  }
+
+  ui::NativeTheme::GetInstanceForNativeUi()->Paint(
+      canvas, NativeThemePart(part), NativeThemeState(state), gfx::Rect(rect),
+      native_theme_extra_params, NativeColorScheme(color_scheme));
+}
+
 }  // namespace content

content/child/webthemeengine_impl_mac.h

@@ -16,6 +16,22 @@ class WebThemeEngineMac : public WebThemeEngineDefault {
   blink::ForcedColors GetForcedColors() const override;
   void SetForcedColors(const blink::ForcedColors forced_colors) override;
 
+  void Paint(cc::PaintCanvas* canvas,
+             blink::WebThemeEngine::Part part,
+             blink::WebThemeEngine::State state,
+             const blink::WebRect& rect,
+             const blink::WebThemeEngine::ExtraParams* extra_params,
+             blink::WebColorScheme color_scheme) override;
+
+  static bool IsScrollbarPart(WebThemeEngine::Part part);
+  static void PaintMacScrollBarParts(
+      cc::PaintCanvas* canvas,
+      WebThemeEngine::Part part,
+      WebThemeEngine::State state,
+      const blink::WebRect& rect,
+      const WebThemeEngine::ExtraParams* extra_params,
+      blink::WebColorScheme color_scheme);
+
  private:
   blink::ForcedColors forced_colors_ = blink::ForcedColors::kNone;
 };

third_party/blink/public/platform/web_theme_engine.h

@@ -33,6 +33,7 @@
 
 #include "base/optional.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "third_party/blink/public/common/css/forced_colors.h"
 #include "third_party/blink/public/platform/web_color_scheme.h"
 #include "third_party/blink/public/platform/web_rect.h"
@@ -174,6 +175,24 @@ class WebThemeEngine {
     bool right_to_left;
   };
 
+#if defined(OS_MACOSX)
+  enum ScrollbarOrientation {
+    // Vertical scrollbar on the right side of content.
+    kVerticalOnRight,
+    // Vertical scrollbar on the left side of content.
+    kVerticalOnLeft,
+    // Horizontal scrollbar (on the bottom of content).
+    kHorizontal,
+  };
+
+  struct ScrollbarExtraParams {
+    bool is_hovering;
+    bool is_overlay;
+    WebColorScheme scrollbar_theme;
+    ScrollbarOrientation orientation;
+  };
+#endif
+
   union ExtraParams {
     ScrollbarTrackExtraParams scrollbar_track;
     ButtonExtraParams button;
@@ -184,6 +203,9 @@ class WebThemeEngine {
     ProgressBarExtraParams progress_bar;
     ScrollbarThumbExtraParams scrollbar_thumb;
     ScrollbarButtonExtraParams scrollbar_button;
+#if defined(OS_MACOSX)
+    ScrollbarExtraParams scrollbar_extra;
+#endif
   };
 
   virtual ~WebThemeEngine() {}

third_party/blink/renderer/core/DEPS

@@ -101,7 +101,6 @@ include_rules = [
     "+ui/base/resource/scale_factor.h",
     "+ui/base/ui_base_features.h",
     "+ui/display/mojom/display.mojom-blink.h",
-    "+ui/gfx/mac/cocoa_scrollbar_painter.h",
     "+ui/gfx/geometry",
     "+ui/gfx/range/range.h",
     "+ui/gfx/skia_util.h",

third_party/blink/renderer/core/scroll/scrollbar_theme_mac.mm

@@ -43,9 +43,6 @@
 #include "third_party/blink/renderer/platform/runtime_enabled_features.h"
 #include "third_party/blink/renderer/platform/wtf/hash_set.h"
 #include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
-#include "ui/gfx/mac/cocoa_scrollbar_painter.h"
-
-using gfx::CocoaScrollbarPainter;
 
 @interface BlinkScrollbarObserver : NSObject {
   blink::Scrollbar* _scrollbar;
@@ -227,21 +224,34 @@ ScrollbarPainter ScrollbarThemeMac::PainterForScrollbar(
       [GetScrollbarPainterMap().at(const_cast<Scrollbar*>(&scrollbar)) painter];
 }
 
-CocoaScrollbarPainter::Params GetPaintParams(const Scrollbar& scrollbar,
-                                             bool overlay) {
-  CocoaScrollbarPainter::Params params;
-  params.orientation = CocoaScrollbarPainter::Orientation::kVerticalOnRight;
-  if (scrollbar.Orientation() == kHorizontalScrollbar)
-    params.orientation = CocoaScrollbarPainter::Orientation::kHorizontal;
-  if (scrollbar.IsLeftSideVerticalScrollbar())
-    params.orientation = CocoaScrollbarPainter::Orientation::kVerticalOnLeft;
-
-  params.dark_mode = scrollbar.UsedColorScheme() == WebColorScheme::kDark;
-  params.overlay = overlay;
-  if (overlay)
-    params.dark_mode = scrollbar.GetScrollbarOverlayColorTheme() ==
-                       kScrollbarOverlayColorThemeLight;
-  params.hovered = scrollbar.HoveredPart() != ScrollbarPart::kNoPart;
+WebThemeEngine::ExtraParams GetPaintParams(const Scrollbar& scrollbar,
+                                           bool overlay) {
+  WebThemeEngine::ExtraParams params;
+
+  params.scrollbar_extra.orientation =
+      WebThemeEngine::ScrollbarOrientation::kVerticalOnRight;
+  if (scrollbar.Orientation() == kHorizontalScrollbar) {
+    params.scrollbar_extra.orientation =
+        WebThemeEngine::ScrollbarOrientation::kHorizontal;
+  } else if (scrollbar.IsLeftSideVerticalScrollbar()) {
+    params.scrollbar_extra.orientation =
+        WebThemeEngine::ScrollbarOrientation::kVerticalOnLeft;
+  }
+
+  params.scrollbar_extra.scrollbar_theme =
+      (scrollbar.UsedColorScheme() == WebColorScheme::kDark) ? kDark : kLight;
+  params.scrollbar_extra.is_overlay = overlay;
+
+  if (overlay) {
+    params.scrollbar_extra.scrollbar_theme =
+        (scrollbar.GetScrollbarOverlayColorTheme() ==
+         kScrollbarOverlayColorThemeLight)
+            ? kDark
+            : kLight;
+  }
+
+  params.scrollbar_extra.is_hovering =
+      scrollbar.HoveredPart() != ScrollbarPart::kNoPart;
   return params;
 }
 
@@ -271,11 +281,18 @@ void ScrollbarThemeMac::PaintTrack(GraphicsContext& context,
 
   if (opacity != 1)
     context.BeginLayer(opacity);
-  CocoaScrollbarPainter::Params params =
+  WebThemeEngine::ExtraParams params =
       GetPaintParams(scrollbar, UsesOverlayScrollbars());
-  SkIRect bounds = SkIRect::MakeXYWH(0, 0, scrollbar.FrameRect().Width(),
-                                     scrollbar.FrameRect().Height());
-  CocoaScrollbarPainter::PaintTrack(context.Canvas(), bounds, params);
+  IntRect bounds(0, 0, scrollbar.FrameRect().Width(),
+                 scrollbar.FrameRect().Height());
+  WebThemeEngine::Part track_part =
+      params.scrollbar_extra.orientation ==
+              WebThemeEngine::ScrollbarOrientation::kHorizontal
+          ? WebThemeEngine::Part::kPartScrollbarHorizontalTrack
+          : WebThemeEngine::Part::kPartScrollbarVerticalTrack;
+  Platform::Current()->ThemeEngine()->Paint(
+      context.Canvas(), track_part, WebThemeEngine::State::kStateNormal,
+      WebRect(bounds), &params, params.scrollbar_extra.scrollbar_theme);
   if (opacity != 1)
     context.EndLayer();
 }
@@ -298,10 +315,13 @@ void ScrollbarThemeMac::PaintScrollCorner(GraphicsContext& context,
 
   GraphicsContextStateSaver state_saver(context);
   context.Translate(rect.X(), rect.Y());
-  SkIRect bounds = SkIRect::MakeXYWH(0, 0, rect.Width(), rect.Height());
-  CocoaScrollbarPainter::Params params =
+  IntRect bounds(0, 0, rect.Width(), rect.Height());
+  WebThemeEngine::ExtraParams params =
       GetPaintParams(*vertical_scrollbar, UsesOverlayScrollbars());
-  CocoaScrollbarPainter::PaintCorner(context.Canvas(), bounds, params);
+  Platform::Current()->ThemeEngine()->Paint(
+      context.Canvas(), WebThemeEngine::Part::kPartScrollbarCorner,
+      WebThemeEngine::State::kStateNormal, WebRect(bounds), &params,
+      params.scrollbar_extra.scrollbar_theme);
 }
 
 void ScrollbarThemeMac::PaintThumbInternal(GraphicsContext& context,
@@ -360,22 +380,20 @@ void ScrollbarThemeMac::PaintThumbInternal(GraphicsContext& context,
   if (!scrollbar.Enabled())
     return;
 
-  CocoaScrollbarPainter::Params params =
+  WebThemeEngine::ExtraParams params =
       GetPaintParams(scrollbar, UsesOverlayScrollbars());
 
   // Compute the bounds for the thumb, accounting for lack of engorgement.
-  SkIRect bounds;
-  switch (params.orientation) {
-    case CocoaScrollbarPainter::Orientation::kVerticalOnRight:
-      bounds = SkIRect::MakeXYWH(rect.Width() - thumb_size, 0, thumb_size,
-                                 rect.Height());
+  IntRect bounds;
+  switch (params.scrollbar_extra.orientation) {
+    case WebThemeEngine::ScrollbarOrientation::kVerticalOnRight:
+      bounds = IntRect(rect.Width() - thumb_size, 0, thumb_size, rect.Height());
       break;
-    case CocoaScrollbarPainter::Orientation::kVerticalOnLeft:
-      bounds = SkIRect::MakeXYWH(0, 0, thumb_size, rect.Height());
+    case WebThemeEngine::ScrollbarOrientation::kVerticalOnLeft:
+      bounds = IntRect(0, 0, thumb_size, rect.Height());
       break;
-    case CocoaScrollbarPainter::Orientation::kHorizontal:
-      bounds = SkIRect::MakeXYWH(0, rect.Height() - thumb_size, rect.Width(),
-                                 thumb_size);
+    case WebThemeEngine::ScrollbarOrientation::kHorizontal:
+      bounds = IntRect(0, rect.Height() - thumb_size, rect.Width(), thumb_size);
       break;
   }
 
@@ -383,7 +401,15 @@ void ScrollbarThemeMac::PaintThumbInternal(GraphicsContext& context,
     FloatRect float_local_rect(local_rect);
     context.BeginLayer(opacity, SkBlendMode::kSrcOver, &float_local_rect);
   }
-  CocoaScrollbarPainter::PaintThumb(context.Canvas(), bounds, params);
+
+  WebThemeEngine::Part thumb_part =
+      params.scrollbar_extra.orientation ==
+              WebThemeEngine::ScrollbarOrientation::kHorizontal
+          ? WebThemeEngine::Part::kPartScrollbarHorizontalThumb
+          : WebThemeEngine::Part::kPartScrollbarVerticalThumb;
+  Platform::Current()->ThemeEngine()->Paint(
+      context.Canvas(), thumb_part, WebThemeEngine::State::kStateNormal,
+      WebRect(bounds), &params, params.scrollbar_extra.scrollbar_theme);
   if (opacity != 1.0f)
     context.EndLayer();
 }

third_party/blink/tools/blinkpy/presubmit/audit_non_blink_usage.py

@@ -708,13 +708,6 @@ _CONFIG = [
             'base::subtle::TimeTicksNowIgnoringOverride',
         ],
     },
-    {
-        'paths':
-        ['third_party/blink/renderer/core/scroll/scrollbar_theme_mac.mm'],
-        'allowed': [
-            'gfx::CocoaScrollbarPainter',
-        ],
-    },
     {
         'paths': ['third_party/blink/renderer/core/workers/worker_thread.cc'],
         'allowed': [

ui/gfx/BUILD.gn

@@ -170,8 +170,6 @@ jumbo_component("gfx") {
       "image/image_skia_util_mac.h",
       "image/image_skia_util_mac.mm",
       "image/image_util_mac.mm",
-      "mac/cocoa_scrollbar_painter.cc",
-      "mac/cocoa_scrollbar_painter.h",
       "mac/coordinate_conversion.h",
       "mac/coordinate_conversion.mm",
       "mac/nswindow_frame_controls.h",

ui/gfx/mac/cocoa_scrollbar_painter.h

-// Copyright 2019 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.
-
-#ifndef UI_GFX_MAC_COCOA_SCROLLBAR_PAINTER_H_
-#define UI_GFX_MAC_COCOA_SCROLLBAR_PAINTER_H_
-
-#include "cc/paint/paint_canvas.h"
-#include "third_party/skia/include/core/SkRect.h"
-#include "ui/gfx/gfx_export.h"
-
-namespace gfx {
-
-class GFX_EXPORT CocoaScrollbarPainter {
- public:
-  enum class Orientation {
-    // Vertical scrollbar on the right side of content.
-    kVerticalOnRight,
-    // Vertical scrollbar on the left side of content.
-    kVerticalOnLeft,
-    // Horizontal scrollbar (on the bottom of content).
-    kHorizontal,
-  };
-
-  struct Params {
-    // The orientation of the scrollbar.
-    Orientation orientation = Orientation::kVerticalOnRight;
-
-    // Whether or not this is an overlay scrollbar.
-    bool overlay = false;
-
-    // Scrollbars change color in dark mode.
-    bool dark_mode = false;
-
-    // Non-overlay scrollbars change thumb color when they are hovered (or
-    // pressed).
-    bool hovered = false;
-  };
-
-  // Paint the thumb. The |thumb_bounds| changes over time when the thumb
-  // engorges during hover.
-  static void PaintThumb(cc::PaintCanvas* canvas,
-                         const SkIRect& thumb_bounds,
-                         const Params& params);
-  // Paint the track. |track_bounds| is the bounds for the track.
-  static void PaintTrack(cc::PaintCanvas* canvas,
-                         const SkIRect& track_bounds,
-                         const Params& params);
-  // Paint the corner. |corner_bounds| is the bounds for the corner.
-  static void PaintCorner(cc::PaintCanvas* canvas,
-                          const SkIRect& corner_bounds,
-                          const Params& params);
-};
-
-}  // namespace gfx
-
-#endif  // UI_GFX_MAC_COCOA_SCROLLBAR_PAINTER_H_

ui/native_theme/native_theme.h

@@ -251,6 +251,25 @@ class NATIVE_THEME_EXPORT NativeTheme {
     ScrollbarOverlayColorTheme scrollbar_theme;
   };
 
+#if defined(OS_MACOSX)
+  enum ScrollbarOrientation {
+    // Vertical scrollbar on the right side of content.
+    kVerticalOnRight,
+    // Vertical scrollbar on the left side of content.
+    kVerticalOnLeft,
+    // Horizontal scrollbar (on the bottom of content).
+    kHorizontal,
+  };
+
+  // A unique set of scrollbar params. Currently needed for Mac.
+  struct ScrollbarExtraParams {
+    bool is_hovering;
+    bool is_overlay;
+    ScrollbarOverlayColorTheme scrollbar_theme;
+    ScrollbarOrientation orientation;  // Used on Mac for drawing gradients.
+  };
+#endif
+
   struct SliderExtraParams {
     bool vertical;
     bool in_drag;
@@ -292,6 +311,9 @@ class NATIVE_THEME_EXPORT NativeTheme {
     MenuBackgroundExtraParams menu_background;
     ProgressBarExtraParams progress_bar;
     ScrollbarArrowExtraParams scrollbar_arrow;
+#if defined(OS_MACOSX)
+    ScrollbarExtraParams scrollbar_extra;
+#endif
     ScrollbarTrackExtraParams scrollbar_track;
     ScrollbarThumbExtraParams scrollbar_thumb;
     SliderExtraParams slider;

ui/native_theme/native_theme_mac.h

@@ -44,6 +44,12 @@ class NATIVE_THEME_EXPORT NativeThemeMac : public NativeThemeBase {
   SkColor GetSystemButtonPressedColor(SkColor base_color) const override;
 
   // Overridden from NativeThemeBase:
+  void Paint(cc::PaintCanvas* canvas,
+             Part part,
+             State state,
+             const gfx::Rect& rect,
+             const ExtraParams& extra,
+             ColorScheme color_scheme) const override;
   void PaintMenuPopupBackground(
       cc::PaintCanvas* canvas,
       const gfx::Size& size,
@@ -54,6 +60,20 @@ class NATIVE_THEME_EXPORT NativeThemeMac : public NativeThemeBase {
                                const gfx::Rect& rect,
                                const MenuItemExtraParams& menu_item,
                                ColorScheme color_scheme) const override;
+  void PaintMacScrollbarThumb(cc::PaintCanvas* canvas,
+                              Part part,
+                              State state,
+                              const gfx::Rect& rect,
+                              const ScrollbarExtraParams& scroll_thumb,
+                              ColorScheme color_scheme) const;
+  // Paint the track. |track_bounds| is the bounds for the track.
+  void PaintMacScrollBarTrackOrCorner(cc::PaintCanvas* canvas,
+                                      Part part,
+                                      State state,
+                                      const ScrollbarExtraParams& extra_params,
+                                      const gfx::Rect& rect,
+                                      ColorScheme color_scheme,
+                                      bool is_corner) const;
 
   // Paints the styled button shape used for default controls on Mac. The basic
   // style is used for dialog buttons, comboboxes, and tabbed pane tabs.
@@ -81,6 +101,22 @@ class NATIVE_THEME_EXPORT NativeThemeMac : public NativeThemeBase {
                              const gfx::Rect& rect,
                              ColorScheme color_scheme) const;
 
+  void PaintScrollBarTrackGradient(cc::PaintCanvas* canvas,
+                                   const gfx::Rect& rect,
+                                   const ScrollbarExtraParams& extra_params,
+                                   bool is_corner,
+                                   ColorScheme color_scheme) const;
+  void PaintScrollbarTrackInnerBorder(cc::PaintCanvas* canvas,
+                                      const gfx::Rect& rect,
+                                      const ScrollbarExtraParams& extra_params,
+                                      bool is_corner,
+                                      ColorScheme color_scheme) const;
+  void PaintScrollbarTrackOuterBorder(cc::PaintCanvas* canvas,
+                                      const gfx::Rect& rect,
+                                      const ScrollbarExtraParams& extra_params,
+                                      bool is_corner,
+                                      ColorScheme color_scheme) const;
+
   void InitializeDarkModeStateAndObserver();
 
   void ConfigureWebInstance() override;

ui/views/controls/scrollbar/cocoa_scroll_bar.h

@@ -11,7 +11,6 @@
 #import "components/remote_cocoa/app_shim/views_scrollbar_bridge.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/gfx/animation/slide_animation.h"
-#include "ui/gfx/mac/cocoa_scrollbar_painter.h"
 #include "ui/views/controls/scrollbar/scroll_bar.h"
 #include "ui/views/views_export.h"
 
@@ -63,7 +62,7 @@ class VIEWS_EXPORT CocoaScrollBar : public ScrollBar,
   bool IsScrollbarFullyHidden() const;
 
   // Get the parameters for painting.
-  gfx::CocoaScrollbarPainter::Params GetPainterParams() const;
+  ui::NativeTheme::ExtraParams GetPainterParams() const;
 
  protected:
   // ScrollBar:

ui/views/controls/scrollbar/cocoa_scroll_bar.mm

@@ -15,8 +15,6 @@
 #include "ui/gfx/canvas.h"
 #include "ui/views/controls/scrollbar/base_scroll_bar_thumb.h"
 
-using gfx::CocoaScrollbarPainter;
-
 namespace views {
 
 namespace {
@@ -100,9 +98,14 @@ gfx::Size CocoaScrollBarThumb::CalculatePreferredSize() const {
 void CocoaScrollBarThumb::OnPaint(gfx::Canvas* canvas) {
   auto params = cocoa_scroll_bar_->GetPainterParams();
   // Set the hover state based only on the thumb.
-  params.hovered = IsStateHovered() || IsStatePressed();
-  CocoaScrollbarPainter::PaintThumb(
-      canvas->sk_canvas(), gfx::RectToSkIRect(GetLocalBounds()), params);
+  params.scrollbar_extra.is_hovering = IsStateHovered() || IsStatePressed();
+  ui::NativeTheme::Part thumb_part =
+      params.scrollbar_extra.orientation ==
+              ui::NativeTheme::ScrollbarOrientation::kHorizontal
+          ? ui::NativeTheme::kScrollbarHorizontalThumb
+          : ui::NativeTheme::kScrollbarVerticalThumb;
+  GetNativeTheme()->Paint(canvas->sk_canvas(), thumb_part,
+                          ui::NativeTheme::kNormal, GetLocalBounds(), params);
 }
 
 bool CocoaScrollBarThumb::OnMousePressed(const ui::MouseEvent& event) {
@@ -208,9 +211,14 @@ void CocoaScrollBar::OnPaint(gfx::Canvas* canvas) {
   auto params = GetPainterParams();
   // Transparency of the track is handled by the View opacity, so always draw
   // using the non-overlay path.
-  params.overlay = false;
-  CocoaScrollbarPainter::PaintTrack(
-      canvas->sk_canvas(), gfx::RectToSkIRect(GetLocalBounds()), params);
+  params.scrollbar_extra.is_overlay = false;
+  ui::NativeTheme::Part track_part =
+      params.scrollbar_extra.orientation ==
+              ui::NativeTheme::ScrollbarOrientation::kHorizontal
+          ? ui::NativeTheme::kScrollbarHorizontalTrack
+          : ui::NativeTheme::kScrollbarVerticalTrack;
+  GetNativeTheme()->Paint(canvas->sk_canvas(), track_part,
+                          ui::NativeTheme::kNormal, GetLocalBounds(), params);
 }
 
 bool CocoaScrollBar::CanProcessEventsWithinSubtree() const {
@@ -400,16 +408,20 @@ bool CocoaScrollBar::IsScrollbarFullyHidden() const {
   return layer()->opacity() == 0.0f;
 }
 
-CocoaScrollbarPainter::Params CocoaScrollBar::GetPainterParams() const {
-  CocoaScrollbarPainter::Params params;
-  if (IsHorizontal())
-    params.orientation = CocoaScrollbarPainter::Orientation::kHorizontal;
-  else if (base::i18n::IsRTL())
-    params.orientation = CocoaScrollbarPainter::Orientation::kVerticalOnLeft;
-  else
-    params.orientation = CocoaScrollbarPainter::Orientation::kVerticalOnRight;
-  params.overlay = GetScrollerStyle() == NSScrollerStyleOverlay;
-  params.dark_mode = GetNativeTheme()->ShouldUseDarkColors();
+ui::NativeTheme::ExtraParams CocoaScrollBar::GetPainterParams() const {
+  ui::NativeTheme::ExtraParams params;
+  if (IsHorizontal()) {
+    params.scrollbar_extra.orientation =
+        ui::NativeTheme::ScrollbarOrientation::kHorizontal;
+  } else if (base::i18n::IsRTL()) {
+    params.scrollbar_extra.orientation =
+        ui::NativeTheme::ScrollbarOrientation::kVerticalOnLeft;
+  } else {
+    params.scrollbar_extra.orientation =
+        ui::NativeTheme::ScrollbarOrientation::kVerticalOnRight;
+  }
+  params.scrollbar_extra.is_overlay =
+      GetScrollerStyle() == NSScrollerStyleOverlay;
   return params;
 }