Use refs for non-null GraphicsContext, Scrollbar, etc. in scrollbar related code

third_party/WebKit/Source/platform/mac/ScrollAnimatorMac.mm

 /*
  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 48 matching lines @@
 
 static bool supportsContentAreaScrolledInDirection()
 {
     static bool globalSupportsContentAreaScrolledInDirection = [NSClassFromString(@"NSScrollerImpPair") instancesRespondToSelector:@selector(contentAreaScrolledInDirection:)];
     return globalSupportsContentAreaScrolledInDirection;
 }
 
 static ScrollbarThemeMacOverlayAPI* macOverlayScrollbarTheme()
 {
     RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(ScrollbarThemeMacCommon::isOverlayAPIAvailable());
-    ScrollbarTheme* scrollbarTheme = ScrollbarTheme::theme();
-    return !scrollbarTheme->isMockTheme() ? static_cast<ScrollbarThemeMacOverlayAPI*>(scrollbarTheme) : 0;
+    ScrollbarTheme& scrollbarTheme = ScrollbarTheme::theme();
+    return !scrollbarTheme.isMockTheme() ? static_cast<ScrollbarThemeMacOverlayAPI*>(&scrollbarTheme) : nil;
 }
 
-static ScrollbarPainter scrollbarPainterForScrollbar(Scrollbar* scrollbar)
+static ScrollbarPainter scrollbarPainterForScrollbar(Scrollbar& scrollbar)
 {
     if (ScrollbarThemeMacOverlayAPI* scrollbarTheme = macOverlayScrollbarTheme())
         return scrollbarTheme->painterForScrollbar(scrollbar);
 
     return nil;
 }
 
 @interface NSObject (ScrollAnimationHelperDetails)
 - (id)initWithDelegate:(id)delegate;
 - (void)_stopRun;
@@ skipping 146 matching lines @@
 
     return _scrollableArea->lastKnownMousePosition();
 }
 
 - (NSPoint)scrollerImpPair:(id)scrollerImpPair convertContentPoint:(NSPoint)pointInContentArea toScrollerImp:(id)scrollerImp
 {
 
     if (!_scrollableArea || !scrollerImp)
         return NSZeroPoint;
 
-    blink::Scrollbar* scrollbar = 0;
+    blink::Scrollbar* scrollbar = nil;
     if ([scrollerImp isHorizontal])
         scrollbar = _scrollableArea->horizontalScrollbar();
     else
         scrollbar = _scrollableArea->verticalScrollbar();
 
     // It is possible to have a null scrollbar here since it is possible for this delegate
     // method to be called between the moment when a scrollbar has been set to 0 and the
     // moment when its destructor has been called. We should probably de-couple some
     // of the clean-up work in ScrollbarThemeMac::unregisterScrollbar() to avoid this
     // issue.
     if (!scrollbar)
         return NSZeroPoint;
 
-    ASSERT(scrollerImp == scrollbarPainterForScrollbar(scrollbar));
+    ASSERT(scrollerImp == scrollbarPainterForScrollbar(*scrollbar));
 
     return scrollbar->convertFromContainingWidget(blink::IntPoint(pointInContentArea));
 }
 
 - (void)scrollerImpPair:(id)scrollerImpPair setContentAreaNeedsDisplayInRect:(NSRect)rect
 {
     if (!_scrollableArea)
         return;
 
     if (!_scrollableArea->scrollbarsCanBeActive())
         return;
 
-    _scrollableArea->scrollAnimator()->contentAreaWillPaint();
+    _scrollableArea->scrollAnimator().contentAreaWillPaint();
 }
 
 - (void)scrollerImpPair:(id)scrollerImpPair updateScrollerStyleForNewRecommendedScrollerStyle:(NSScrollerStyle)newRecommendedScrollerStyle
 {
     // Chrome has a single process mode which is used for testing on Mac. In that mode, WebKit runs on a thread in the
     // browser process. This notification is called by the OS on the main thread in the browser process, and not on the
     // the WebKit thread. Better to not update the style than crash.
     // http://crbug.com/126514
     if (!isMainThread())
         return;
 
     if (!_scrollableArea)
         return;
 
     [scrollerImpPair setScrollerStyle:newRecommendedScrollerStyle];
 
-    static_cast<ScrollAnimatorMac*>(_scrollableArea->scrollAnimator())->updateScrollerStyle();
+    static_cast<ScrollAnimatorMac&>(_scrollableArea->scrollAnimator()).updateScrollerStyle();
 }
 
 @end
 
 enum FeatureToAnimate {
     ThumbAlpha,
     TrackAlpha,
     UIStateTransition,
     ExpansionTransition
 };
@@ skipping 88 matching lines @@
     _startValue = startValue;
     _endValue = endValue;
 
     return self;
 }
 
 - (void)startAnimation
 {
     ASSERT(_scrollbar);
 
-    _scrollbarPainter = scrollbarPainterForScrollbar(_scrollbar);
+    _scrollbarPainter = scrollbarPainterForScrollbar(*_scrollbar);
     _timer->start();
 }
 
 - (void)stopAnimation
 {
     _timer->stop();
 }
 
 - (void)setDuration:(CFTimeInterval)duration
 {
@@ skipping 75 matching lines @@
     if (!self)
         return nil;
 
     _scrollbar = scrollbar;
     return self;
 }
 
 - (void)updateVisibilityImmediately:(bool)show
 {
     [self cancelAnimations];
-    [scrollbarPainterForScrollbar(_scrollbar) setKnobAlpha:(show ? 1.0 : 0.0)];
+    [scrollbarPainterForScrollbar(*_scrollbar) setKnobAlpha:(show ? 1.0 : 0.0)];
 }
 
 - (void)cancelAnimations
 {
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
     [_knobAlphaAnimation.get() stopAnimation];
     [_trackAlphaAnimation.get() stopAnimation];
     [_uiStateTransitionAnimation.get() stopAnimation];
     [_expansionTransitionAnimation.get() stopAnimation];
     END_BLOCK_OBJC_EXCEPTIONS;
 }
 
-- (ScrollAnimatorMac*)scrollAnimator
+- (ScrollAnimatorMac&)scrollAnimator
 {
-    return static_cast<ScrollAnimatorMac*>(_scrollbar->scrollableArea()->scrollAnimator());
+    return static_cast<ScrollAnimatorMac&>(_scrollbar->scrollableArea()->scrollAnimator());
 }
 
 - (NSRect)convertRectToBacking:(NSRect)aRect
 {
     return aRect;
 }
 
 - (NSRect)convertRectFromBacking:(NSRect)aRect
 {
     return aRect;
 }
 
 - (NSPoint)mouseLocationInScrollerForScrollerImp:(id)scrollerImp
 {
     if (!_scrollbar)
         return NSZeroPoint;
 
-    ASSERT_UNUSED(scrollerImp, scrollerImp == scrollbarPainterForScrollbar(_scrollbar));
+    ASSERT_UNUSED(scrollerImp, scrollerImp == scrollbarPainterForScrollbar(*_scrollbar));
 
     return _scrollbar->convertFromContainingWidget(_scrollbar->scrollableArea()->lastKnownMousePosition());
 }
 
 - (void)setUpAlphaAnimation:(RetainPtr<WebScrollbarPartAnimation>&)scrollbarPartAnimation scrollerPainter:(ScrollbarPainter)scrollerPainter part:(blink::ScrollbarPart)part animateAlphaTo:(CGFloat)newAlpha duration:(NSTimeInterval)duration
 {
     // If the user has scrolled the page, then the scrollbars must be animated here.
     // This overrides the early returns.
-    bool mustAnimate = [self scrollAnimator]->haveScrolledSincePageLoad();
+    bool mustAnimate = [self scrollAnimator].haveScrolledSincePageLoad();
 
-    if ([self scrollAnimator]->scrollbarPaintTimerIsActive() && !mustAnimate)
+    if ([self scrollAnimator].scrollbarPaintTimerIsActive() && !mustAnimate)
         return;
 
     if (_scrollbar->scrollableArea()->shouldSuspendScrollAnimations() && !mustAnimate) {
-        [self scrollAnimator]->startScrollbarPaintTimer();
+        [self scrollAnimator].startScrollbarPaintTimer();
         return;
     }
 
     // At this point, we are definitely going to animate now, so stop the timer.
-    [self scrollAnimator]->stopScrollbarPaintTimer();
+    [self scrollAnimator].stopScrollbarPaintTimer();
 
     // If we are currently animating, stop
     if (scrollbarPartAnimation) {
         [scrollbarPartAnimation.get() stopAnimation];
         scrollbarPartAnimation = nullptr;
     }
 
     if (part == blink::ThumbPart && _scrollbar->orientation() == VerticalScrollbar) {
         if (newAlpha == 1) {
             IntRect thumbRect = IntRect([scrollerPainter rectForPart:NSScrollerKnob]);
-            [self scrollAnimator]->setVisibleScrollerThumbRect(thumbRect);
+            [self scrollAnimator].setVisibleScrollerThumbRect(thumbRect);
         } else
-            [self scrollAnimator]->setVisibleScrollerThumbRect(IntRect());
+            [self scrollAnimator].setVisibleScrollerThumbRect(IntRect());
     }
 
     scrollbarPartAnimation.adoptNS([[WebScrollbarPartAnimation alloc] initWithScrollbar:_scrollbar
                                                                        featureToAnimate:part == ThumbPart ? ThumbAlpha : TrackAlpha
                                                                             animateFrom:part == ThumbPart ? [scrollerPainter knobAlpha] : [scrollerPainter trackAlpha]
                                                                               animateTo:newAlpha
                                                                                duration:duration]);
     [scrollbarPartAnimation.get() startAnimation];
 }
 
 - (void)scrollerImp:(id)scrollerImp animateKnobAlphaTo:(CGFloat)newKnobAlpha duration:(NSTimeInterval)duration
 {
     if (!_scrollbar)
         return;
 
-    ASSERT(scrollerImp == scrollbarPainterForScrollbar(_scrollbar));
+    ASSERT(scrollerImp == scrollbarPainterForScrollbar(*_scrollbar));
 
     ScrollbarPainter scrollerPainter = (ScrollbarPainter)scrollerImp;
     [self setUpAlphaAnimation:_knobAlphaAnimation scrollerPainter:scrollerPainter part:blink::ThumbPart animateAlphaTo:newKnobAlpha duration:duration];
 }
 
 - (void)scrollerImp:(id)scrollerImp animateTrackAlphaTo:(CGFloat)newTrackAlpha duration:(NSTimeInterval)duration
 {
     if (!_scrollbar)
         return;
 
-    ASSERT(scrollerImp == scrollbarPainterForScrollbar(_scrollbar));
+    ASSERT(scrollerImp == scrollbarPainterForScrollbar(*_scrollbar));
 
     ScrollbarPainter scrollerPainter = (ScrollbarPainter)scrollerImp;
     [self setUpAlphaAnimation:_trackAlphaAnimation scrollerPainter:scrollerPainter part:blink::BackTrackPart animateAlphaTo:newTrackAlpha duration:duration];
 }
 
 - (void)scrollerImp:(id)scrollerImp animateUIStateTransitionWithDuration:(NSTimeInterval)duration
 {
     if (!_scrollbar)
         return;
 
     if (!supportsUIStateTransitionProgress())
         return;
 
-    ASSERT(scrollerImp == scrollbarPainterForScrollbar(_scrollbar));
+    ASSERT(scrollerImp == scrollbarPainterForScrollbar(*_scrollbar));
 
     ScrollbarPainter scrollbarPainter = (ScrollbarPainter)scrollerImp;
 
     // UIStateTransition always animates to 1. In case an animation is in progress this avoids a hard transition.
     [scrollbarPainter setUiStateTransitionProgress:1 - [scrollerImp uiStateTransitionProgress]];
 
     if (!_uiStateTransitionAnimation)
         _uiStateTransitionAnimation.adoptNS([[WebScrollbarPartAnimation alloc] initWithScrollbar:_scrollbar
                                                                                 featureToAnimate:UIStateTransition
                                                                                      animateFrom:[scrollbarPainter uiStateTransitionProgress]
                                                                                        animateTo:1.0
                                                                                         duration:duration]);
     else {
         // If we don't need to initialize the animation, just reset the values in case they have changed.
         [_uiStateTransitionAnimation.get() setStartValue:[scrollbarPainter uiStateTransitionProgress]];
         [_uiStateTransitionAnimation.get() setEndValue:1.0];
         [_uiStateTransitionAnimation.get() setDuration:duration];
     }
     [_uiStateTransitionAnimation.get() startAnimation];
 }
 
 - (void)scrollerImp:(id)scrollerImp animateExpansionTransitionWithDuration:(NSTimeInterval)duration
 {
     if (!_scrollbar)
         return;
 
     if (!supportsExpansionTransitionProgress())
         return;
 
-    ASSERT(scrollerImp == scrollbarPainterForScrollbar(_scrollbar));
+    ASSERT(scrollerImp == scrollbarPainterForScrollbar(*_scrollbar));
 
     ScrollbarPainter scrollbarPainter = (ScrollbarPainter)scrollerImp;
 
     // ExpansionTransition always animates to 1. In case an animation is in progress this avoids a hard transition.
     [scrollbarPainter setExpansionTransitionProgress:1 - [scrollerImp expansionTransitionProgress]];
 
     if (!_expansionTransitionAnimation) {
         _expansionTransitionAnimation.adoptNS([[WebScrollbarPartAnimation alloc] initWithScrollbar:_scrollbar
                                                                                   featureToAnimate:ExpansionTransition
                                                                                        animateFrom:[scrollbarPainter expansionTransitionProgress]
@@ skipping 86 matching lines @@
         [m_verticalScrollbarPainterDelegate.get() invalidate];
         [m_scrollAnimationHelperDelegate.get() invalidate];
         END_BLOCK_OBJC_EXCEPTIONS;
     }
     m_initialScrollbarPaintTimer.stop();
     m_sendContentAreaScrolledTimer.stop();
 }
 
 ScrollResultOneDimensional ScrollAnimatorMac::userScroll(ScrollbarOrientation orientation, ScrollGranularity granularity, float step, float delta)
 {
-    bool scrollAnimationEnabledForSystem = static_cast<ScrollbarThemeMacCommon*>(
+    bool scrollAnimationEnabledForSystem = static_cast<ScrollbarThemeMacCommon&>(
                                                ScrollbarTheme::theme())
-                                               ->scrollAnimationEnabledForSystem();
+                                               .scrollAnimationEnabledForSystem();
     m_haveScrolledSincePageLoad = true;
 
     if (!scrollAnimationEnabledForSystem || !m_scrollableArea->scrollAnimatorEnabled())
         return ScrollAnimatorBase::userScroll(orientation, granularity, step, delta);
 
     if (granularity == ScrollByPixel || granularity == ScrollByPrecisePixel)
         return ScrollAnimatorBase::userScroll(orientation, granularity, step, delta);
 
     float currentPos = orientation == HorizontalScrollbar ? m_currentPosX : m_currentPosY;
     float newPos = std::max<float>(std::min<float>(currentPos + (step * delta), m_scrollableArea->maximumScrollPosition(orientation)), m_scrollableArea->minimumScrollPosition(orientation));
@@ skipping 77 matching lines @@
 }
 
 void ScrollAnimatorMac::mouseMovedInContentArea() const
 {
     if (!scrollableArea()->scrollbarsCanBeActive())
         return;
     if (ScrollbarThemeMacCommon::isOverlayAPIAvailable())
         [m_scrollbarPainterController.get() mouseMovedInContentArea];
 }
 
-void ScrollAnimatorMac::mouseEnteredScrollbar(Scrollbar* scrollbar) const
+void ScrollAnimatorMac::mouseEnteredScrollbar(Scrollbar& scrollbar) const
 {
     if (!scrollableArea()->scrollbarsCanBeActive())
         return;
 
     if (ScrollbarThemeMacCommon::isOverlayAPIAvailable()) {
         if (!supportsUIStateTransitionProgress())
             return;
         if (ScrollbarPainter painter = scrollbarPainterForScrollbar(scrollbar))
             [painter mouseEnteredScroller];
     }
 }
 
-void ScrollAnimatorMac::mouseExitedScrollbar(Scrollbar* scrollbar) const
+void ScrollAnimatorMac::mouseExitedScrollbar(Scrollbar& scrollbar) const
 {
     if (!scrollableArea()->scrollbarsCanBeActive())
         return;
 
     if (ScrollbarThemeMacCommon::isOverlayAPIAvailable()) {
         if (!supportsUIStateTransitionProgress())
             return;
         if (ScrollbarPainter painter = scrollbarPainterForScrollbar(scrollbar))
             [painter mouseExitedScroller];
     }
@@ skipping 66 matching lines @@
     [m_scrollbarPainterController.get() contentAreaScrolled];
 }
 
 void ScrollAnimatorMac::finishCurrentScrollAnimations()
 {
     if (ScrollbarThemeMacCommon::isOverlayAPIAvailable()) {
         [m_scrollbarPainterController.get() hideOverlayScrollers];
     }
 }
 
-void ScrollAnimatorMac::didAddVerticalScrollbar(Scrollbar* scrollbar)
+void ScrollAnimatorMac::didAddVerticalScrollbar(Scrollbar& scrollbar)
 {
     if (!ScrollbarThemeMacCommon::isOverlayAPIAvailable())
         return;
 
     ScrollbarPainter painter = scrollbarPainterForScrollbar(scrollbar);
     if (!painter)
         return;
 
     ASSERT(!m_verticalScrollbarPainterDelegate);
-    m_verticalScrollbarPainterDelegate.adoptNS([[WebScrollbarPainterDelegate alloc] initWithScrollbar:scrollbar]);
+    m_verticalScrollbarPainterDelegate.adoptNS([[WebScrollbarPainterDelegate alloc] initWithScrollbar:&scrollbar]);
 
     [painter setDelegate:m_verticalScrollbarPainterDelegate.get()];
     [m_scrollbarPainterController.get() setVerticalScrollerImp:painter];
     if (scrollableArea()->inLiveResize())
         [painter setKnobAlpha:1];
 }
 
-void ScrollAnimatorMac::willRemoveVerticalScrollbar(Scrollbar* scrollbar)
+void ScrollAnimatorMac::willRemoveVerticalScrollbar(Scrollbar& scrollbar)
 {
     if (!ScrollbarThemeMacCommon::isOverlayAPIAvailable())
         return;
 
     ScrollbarPainter painter = scrollbarPainterForScrollbar(scrollbar);
     if (!painter)
         return;
 
     ASSERT(m_verticalScrollbarPainterDelegate);
     [m_verticalScrollbarPainterDelegate.get() invalidate];
     m_verticalScrollbarPainterDelegate = nullptr;
 
     [painter setDelegate:nil];
     [m_scrollbarPainterController.get() setVerticalScrollerImp:nil];
 }
 
-void ScrollAnimatorMac::didAddHorizontalScrollbar(Scrollbar* scrollbar)
+void ScrollAnimatorMac::didAddHorizontalScrollbar(Scrollbar& scrollbar)
 {
     if (!ScrollbarThemeMacCommon::isOverlayAPIAvailable())
         return;
 
     ScrollbarPainter painter = scrollbarPainterForScrollbar(scrollbar);
     if (!painter)
         return;
 
     ASSERT(!m_horizontalScrollbarPainterDelegate);
-    m_horizontalScrollbarPainterDelegate.adoptNS([[WebScrollbarPainterDelegate alloc] initWithScrollbar:scrollbar]);
+    m_horizontalScrollbarPainterDelegate.adoptNS([[WebScrollbarPainterDelegate alloc] initWithScrollbar:&scrollbar]);
 
     [painter setDelegate:m_horizontalScrollbarPainterDelegate.get()];
     [m_scrollbarPainterController.get() setHorizontalScrollerImp:painter];
     if (scrollableArea()->inLiveResize())
         [painter setKnobAlpha:1];
 }
 
-void ScrollAnimatorMac::willRemoveHorizontalScrollbar(Scrollbar* scrollbar)
+void ScrollAnimatorMac::willRemoveHorizontalScrollbar(Scrollbar& scrollbar)
 {
     if (!ScrollbarThemeMacCommon::isOverlayAPIAvailable())
         return;
 
     ScrollbarPainter painter = scrollbarPainterForScrollbar(scrollbar);
     if (!painter)
         return;
 
     ASSERT(m_horizontalScrollbarPainterDelegate);
     [m_horizontalScrollbarPainterDelegate.get() invalidate];
     m_horizontalScrollbarPainterDelegate = nullptr;
 
     [painter setDelegate:nil];
     [m_scrollbarPainterController.get() setHorizontalScrollerImp:nil];
 }
 
-bool ScrollAnimatorMac::shouldScrollbarParticipateInHitTesting(Scrollbar* scrollbar)
+bool ScrollAnimatorMac::shouldScrollbarParticipateInHitTesting(Scrollbar& scrollbar)
 {
     // Non-overlay scrollbars should always participate in hit testing.
     if (ScrollbarThemeMacCommon::recommendedScrollerStyle() != NSScrollerStyleOverlay)
         return true;
 
     if (!ScrollbarThemeMacCommon::isOverlayAPIAvailable())
         return true;
 
-    if (scrollbar->isAlphaLocked())
+    if (scrollbar.isAlphaLocked())
         return true;
 
     // Overlay scrollbars should participate in hit testing whenever they are at all visible.
     ScrollbarPainter painter = scrollbarPainterForScrollbar(scrollbar);
     if (!painter)
         return false;
     return [painter knobAlpha] > 0;
 }
 
 void ScrollAnimatorMac::notifyContentAreaScrolled(const FloatSize& delta)
@@ skipping 82 matching lines @@
         verticalScrollbar->setTrackNeedsRepaint(true);
         verticalScrollbar->setThumbNeedsRepaint(true);
         verticalScrollbar->setNeedsPaintInvalidation();
 
         ScrollbarPainter oldVerticalPainter = [m_scrollbarPainterController.get() verticalScrollerImp];
         ScrollbarPainter newVerticalPainter = [NSClassFromString(@"NSScrollerImp") scrollerImpWithStyle:newStyle
                                                                                     controlSize:(NSControlSize)verticalScrollbar->controlSize()
                                                                                     horizontal:NO
                                                                                     replacingScrollerImp:oldVerticalPainter];
         [m_scrollbarPainterController.get() setVerticalScrollerImp:newVerticalPainter];
-        macTheme->setNewPainterForScrollbar(verticalScrollbar, newVerticalPainter);
+        macTheme->setNewPainterForScrollbar(*verticalScrollbar, newVerticalPainter);
 
         // The different scrollbar styles have different thicknesses, so we must re-set the
         // frameRect to the new thickness, and the re-layout below will ensure the position
         // and length are properly updated.
         int thickness = macTheme->scrollbarThickness(verticalScrollbar->controlSize());
         verticalScrollbar->setFrameRect(IntRect(0, 0, thickness, thickness));
     }
 
     if (Scrollbar* horizontalScrollbar = scrollableArea()->horizontalScrollbar()) {
         horizontalScrollbar->setTrackNeedsRepaint(true);
         horizontalScrollbar->setThumbNeedsRepaint(true);
         horizontalScrollbar->setNeedsPaintInvalidation();
 
         ScrollbarPainter oldHorizontalPainter = [m_scrollbarPainterController.get() horizontalScrollerImp];
         ScrollbarPainter newHorizontalPainter = [NSClassFromString(@"NSScrollerImp") scrollerImpWithStyle:newStyle
                                                                                     controlSize:(NSControlSize)horizontalScrollbar->controlSize()
                                                                                     horizontal:YES
                                                                                     replacingScrollerImp:oldHorizontalPainter];
         [m_scrollbarPainterController.get() setHorizontalScrollerImp:newHorizontalPainter];
-        macTheme->setNewPainterForScrollbar(horizontalScrollbar, newHorizontalPainter);
+        macTheme->setNewPainterForScrollbar(*horizontalScrollbar, newHorizontalPainter);
 
         // The different scrollbar styles have different thicknesses, so we must re-set the
         // frameRect to the new thickness, and the re-layout below will ensure the position
         // and length are properly updated.
         int thickness = macTheme->scrollbarThickness(horizontalScrollbar->controlSize());
         horizontalScrollbar->setFrameRect(IntRect(0, 0, thickness, thickness));
     }
 
     // If m_needsScrollerStyleUpdate is true, then the page is restoring from the page cache, and
     // a relayout will happen on its own. Otherwise, we must initiate a re-layout ourselves.
@@ skipping 55 matching lines @@
         return;
 
     m_visibleScrollerThumbRect = rectInViewCoordinates;
 }
 
 bool ScrollAnimatorMac::canUseCoordinatedScrollbar() {
     return ScrollbarThemeMacCommon::isOverlayAPIAvailable();
 }
 
 } // namespace blink