Selectively disable rubber banding on mac.

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 82 matching lines @@
 - (id)initWithScrollAnimator:(WebCore::ScrollAnimatorMac*)scrollAnimator;
 @end
 
 static NSSize abs(NSSize size)
 {
     NSSize finalSize = size;
     if (finalSize.width < 0)
         finalSize.width = -finalSize.width;
     if (finalSize.height < 0)
         finalSize.height = -finalSize.height;
-    return finalSize;    
+    return finalSize;
 }
 
 @implementation WebScrollAnimationHelperDelegate
 
 - (id)initWithScrollAnimator:(WebCore::ScrollAnimatorMac*)scrollAnimator
 {
     self = [super init];
     if (!self)
         return nil;
 
@@ skipping 75 matching lines @@
 - (id)initWithScrollableArea:(ScrollableArea*)scrollableArea;
 @end
 
 @implementation WebScrollbarPainterControllerDelegate
 
 - (id)initWithScrollableArea:(ScrollableArea*)scrollableArea
 {
     self = [super init];
     if (!self)
         return nil;
-    
+
     _scrollableArea = scrollableArea;
     return self;
 }
 
 - (void)invalidate
 {
     _scrollableArea = 0;
 }
 
 - (NSRect)contentAreaRectForScrollerImpPair:(id)scrollerImpPair
@@ skipping 23 matching lines @@
 
 - (NSPoint)scrollerImpPair:(id)scrollerImpPair convertContentPoint:(NSPoint)pointInContentArea toScrollerImp:(id)scrollerImp
 {
 
     if (!_scrollableArea || !scrollerImp)
         return NSZeroPoint;
 
     WebCore::Scrollbar* scrollbar = 0;
     if ([scrollerImp isHorizontal])
         scrollbar = _scrollableArea->horizontalScrollbar();
-    else 
+    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;
 
@@ skipping 140 matching lines @@
 - (void)cancelAnimations;
 @end
 
 @implementation WebScrollbarPainterDelegate
 
 - (id)initWithScrollbar:(WebCore::Scrollbar*)scrollbar
 {
     self = [super init];
     if (!self)
         return nil;
-    
+
     _scrollbar = scrollbar;
     return self;
 }
 
 - (void)cancelAnimations
 {
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
     [_knobAlphaAnimation.get() stopAnimation];
     [_trackAlphaAnimation.get() stopAnimation];
     [_uiStateTransitionAnimation.get() stopAnimation];
@@ skipping 21 matching lines @@
     if (!_scrollbar)
         return NSZeroPoint;
 
     ASSERT_UNUSED(scrollerImp, scrollerImp == scrollbarPainterForScrollbar(_scrollbar));
 
     return _scrollbar->convertFromContainingView(_scrollbar->scrollableArea()->lastKnownMousePosition());
 }
 
 - (void)setUpAlphaAnimation:(RetainPtr<WebScrollbarPartAnimation>&)scrollbarPartAnimation scrollerPainter:(ScrollbarPainter)scrollerPainter part:(WebCore::ScrollbarPart)part animateAlphaTo:(CGFloat)newAlpha duration:(NSTimeInterval)duration
 {
-    // If the user has scrolled the page, then the scrollbars must be animated here. 
+    // If the user has scrolled the page, then the scrollbars must be animated here.
     // This overrides the early returns.
     bool mustAnimate = [self scrollAnimator]->haveScrolledSincePageLoad();
 
     if ([self scrollAnimator]->scrollbarPaintTimerIsActive() && !mustAnimate)
         return;
 
     if (_scrollbar->scrollableArea()->shouldSuspendScrollAnimations() && !mustAnimate) {
         [self scrollAnimator]->startScrollbarPaintTimer();
         return;
     }
 
     // At this point, we are definitely going to animate now, so stop the timer.
     [self scrollAnimator]->stopScrollbarPaintTimer();
 
     // If we are currently animating, stop
     if (scrollbarPartAnimation) {
         [scrollbarPartAnimation.get() stopAnimation];
         scrollbarPartAnimation = nil;
     }
 
     if (part == WebCore::ThumbPart && _scrollbar->orientation() == VerticalScrollbar) {
         if (newAlpha == 1) {
             IntRect thumbRect = IntRect([scrollerPainter rectForPart:NSScrollerKnob]);
             [self scrollAnimator]->setVisibleScrollerThumbRect(thumbRect);
         } else
             [self scrollAnimator]->setVisibleScrollerThumbRect(IntRect());
     }
 
-    scrollbarPartAnimation.adoptNS([[WebScrollbarPartAnimation alloc] initWithScrollbar:_scrollbar 
+    scrollbarPartAnimation.adoptNS([[WebScrollbarPartAnimation alloc] initWithScrollbar:_scrollbar
                                                                        featureToAnimate:part == ThumbPart ? ThumbAlpha : TrackAlpha
                                                                             animateFrom:part == ThumbPart ? [scrollerPainter knobAlpha] : [scrollerPainter trackAlpha]
-                                                                              animateTo:newAlpha 
+                                                                              animateTo:newAlpha
                                                                                duration:duration]);
     [scrollbarPartAnimation.get() startAnimation];
 }
 
 - (void)scrollerImp:(id)scrollerImp animateKnobAlphaTo:(CGFloat)newKnobAlpha duration:(NSTimeInterval)duration
 {
     if (!_scrollbar)
         return;
 
     ASSERT(scrollerImp == scrollbarPainterForScrollbar(_scrollbar));
 
     ScrollbarPainter scrollerPainter = (ScrollbarPainter)scrollerImp;
     [self setUpAlphaAnimation:_knobAlphaAnimation scrollerPainter:scrollerPainter part:WebCore::ThumbPart animateAlphaTo:newKnobAlpha duration:duration];
 }
 
 - (void)scrollerImp:(id)scrollerImp animateTrackAlphaTo:(CGFloat)newTrackAlpha duration:(NSTimeInterval)duration
 {
     if (!_scrollbar)
         return;
 
     ASSERT(scrollerImp == scrollbarPainterForScrollbar(_scrollbar));
-    
+
     ScrollbarPainter scrollerPainter = (ScrollbarPainter)scrollerImp;
     [self setUpAlphaAnimation:_trackAlphaAnimation scrollerPainter:scrollerPainter part:WebCore::BackTrackPart animateAlphaTo:newTrackAlpha duration:duration];
 }
 
 - (void)scrollerImp:(id)scrollerImp animateUIStateTransitionWithDuration:(NSTimeInterval)duration
 {
     if (!_scrollbar)
         return;
 
     if (!supportsUIStateTransitionProgress())
         return;
 
     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 
+        _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];
     }
@@ skipping 84 matching lines @@
         [m_scrollbarPainterController.get() setDelegate:nil];
         [m_horizontalScrollbarPainterDelegate.get() invalidate];
         [m_verticalScrollbarPainterDelegate.get() invalidate];
         [m_scrollAnimationHelperDelegate.get() invalidate];
         END_BLOCK_OBJC_EXCEPTIONS;
     }
 }
 
 static bool scrollAnimationEnabledForSystem()
 {
-    NSString* scrollAnimationDefaultsKey = 
+    NSString* scrollAnimationDefaultsKey =
         @"AppleScrollAnimationEnabled";
     static bool enabled = [[NSUserDefaults standardUserDefaults] boolForKey:scrollAnimationDefaultsKey];
     return enabled;
 }
 
 #if USE(RUBBER_BANDING)
 static bool rubberBandingEnabledForSystem()
 {
     static bool initialized = false;
     static bool enabled = true;
@@ skipping 52 matching lines @@
 
     float newX = max<float>(min<float>(position.x(), maxPos.x()), minPos.x());
     float newY = max<float>(min<float>(position.y(), maxPos.y()), minPos.y());
 
     return FloatPoint(newX, newY);
 }
 
 void ScrollAnimatorMac::immediateScrollTo(const FloatPoint& newPosition)
 {
     FloatPoint adjustedPosition = adjustScrollPositionIfNecessary(newPosition);
- 
+
     bool positionChanged = adjustedPosition.x() != m_currentPosX || adjustedPosition.y() != m_currentPosY;
     if (!positionChanged && !scrollableArea()->scrollOriginChanged())
         return;
 
     FloatSize delta = FloatSize(adjustedPosition.x() - m_currentPosX, adjustedPosition.y() - m_currentPosY);
 
     m_currentPosX = adjustedPosition.x();
     m_currentPosY = adjustedPosition.y();
     notifyPositionChanged(delta);
 }
@@ skipping 246 matching lines @@
     if (!painter)
         return false;
     return [painter knobAlpha] > 0;
 }
 
 void ScrollAnimatorMac::notifyContentAreaScrolled(const FloatSize& delta)
 {
     if (!ScrollbarThemeMacCommon::isOverlayAPIAvailable())
         return;
 
-    // This function is called when a page is going into the page cache, but the page 
+    // This function is called when a page is going into the page cache, but the page
     // isn't really scrolling in that case. We should only pass the message on to the
     // ScrollbarPainterController when we're really scrolling on an active page.
     if (scrollableArea()->scrollbarsCanBeActive())
         sendContentAreaScrolledSoon(delta);
 }
 
 void ScrollAnimatorMac::cancelAnimations()
 {
     m_haveScrolledSincePageLoad = false;
 
@@ skipping 13 matching lines @@
 
     if (phase == PlatformWheelEventPhaseBegan)
         didBeginScrollGesture();
     else if (phase == PlatformWheelEventPhaseEnded || phase == PlatformWheelEventPhaseCancelled)
         didEndScrollGesture();
     else if (phase == PlatformWheelEventPhaseMayBegin)
         mayBeginScrollGesture();
 }
 
 #if USE(RUBBER_BANDING)
-bool ScrollAnimatorMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
+bool ScrollAnimatorMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent, bool canRubberbandLeft, bool canRubberbandRight)
 {
     m_haveScrolledSincePageLoad = true;
 
     if (!wheelEvent.hasPreciseScrollingDeltas() || !rubberBandingEnabledForSystem())
-        return ScrollAnimator::handleWheelEvent(wheelEvent);
+        return ScrollAnimator::handleWheelEvent(wheelEvent, canRubberbandLeft, canRubberbandRight);
 
     // FIXME: This is somewhat roundabout hack to allow forwarding wheel events
     // up to the parent scrollable area. It takes advantage of the fact that
     // the base class implementation of handleWheelEvent will not accept the
     // wheel event if there is nowhere to scroll.
     if (fabsf(wheelEvent.deltaY()) >= fabsf(wheelEvent.deltaX())) {
         if (!allowsVerticalStretching())
-            return ScrollAnimator::handleWheelEvent(wheelEvent);
+            return ScrollAnimator::handleWheelEvent(wheelEvent, canRubberbandLeft, canRubberbandRight);
     } else {
         if (!allowsHorizontalStretching())
-            return ScrollAnimator::handleWheelEvent(wheelEvent);
+            return ScrollAnimator::handleWheelEvent(wheelEvent, canRubberbandLeft, canRubberbandRight);
     }
 
-    bool didHandleEvent = m_scrollElasticityController.handleWheelEvent(wheelEvent);
+    bool didHandleEvent = m_scrollElasticityController.handleWheelEvent(wheelEvent, canRubberbandLeft, canRubberbandRight);
 
     // The elasticity controller can return false on a phase end event if rubber banding wasn't in progress.
     // In this case, the wheel phase must still be handled so that that overlay scroll bars get hidden.
     if (didHandleEvent || wheelEvent.phase() == PlatformWheelEventPhaseEnded || wheelEvent.phase() == PlatformWheelEventPhaseCancelled)
         handleWheelEventPhase(wheelEvent.phase());
 
     return didHandleEvent;
 }
 
 bool ScrollAnimatorMac::pinnedInDirection(float deltaX, float deltaY)
 {
     FloatSize limitDelta;
     if (fabsf(deltaY) >= fabsf(deltaX)) {
         if (deltaY < 0) {
             // We are trying to scroll up.  Make sure we are not pinned to the top
             limitDelta.setHeight(m_scrollableArea->visibleContentRect().y() + + m_scrollableArea->scrollOrigin().y());
         } else {
             // We are trying to scroll down.  Make sure we are not pinned to the bottom
             limitDelta.setHeight(m_scrollableArea->contentsSize().height() - (m_scrollableArea->visibleContentRect().maxY() + m_scrollableArea->scrollOrigin().y()));
         }
     } else if (deltaX != 0) {
         if (deltaX < 0) {
             // We are trying to scroll left.  Make sure we are not pinned to the left
             limitDelta.setWidth(m_scrollableArea->visibleContentRect().x() + m_scrollableArea->scrollOrigin().x());
         } else {
             // We are trying to scroll right.  Make sure we are not pinned to the right
             limitDelta.setWidth(m_scrollableArea->contentsSize().width() - (m_scrollableArea->visibleContentRect().maxX() + m_scrollableArea->scrollOrigin().x()));
         }
     }
-    
+
     if ((deltaX != 0 || deltaY != 0) && (limitDelta.width() < 1 && limitDelta.height() < 1))
         return true;
     return false;
 }
 
 bool ScrollAnimatorMac::allowsVerticalStretching()
 {
     switch (m_scrollableArea->verticalScrollElasticity()) {
     case ScrollElasticityAutomatic: {
         Scrollbar* hScroller = m_scrollableArea->horizontalScrollbar();
@@ skipping 126 matching lines @@
         m_needsScrollerStyleUpdate = false;
         return;
     }
 
     NSScrollerStyle newStyle = [m_scrollbarPainterController.get() scrollerStyle];
 
     if (Scrollbar* verticalScrollbar = scrollableArea()->verticalScrollbar()) {
         verticalScrollbar->invalidate();
 
         ScrollbarPainter oldVerticalPainter = [m_scrollbarPainterController.get() verticalScrollerImp];
-        ScrollbarPainter newVerticalPainter = [NSClassFromString(@"NSScrollerImp") scrollerImpWithStyle:newStyle 
-                                                                                    controlSize:(NSControlSize)verticalScrollbar->controlSize() 
-                                                                                    horizontal:NO 
+        ScrollbarPainter newVerticalPainter = [NSClassFromString(@"NSScrollerImp") scrollerImpWithStyle:newStyle
+                                                                                    controlSize:(NSControlSize)verticalScrollbar->controlSize()
+                                                                                    horizontal:NO
                                                                                     replacingScrollerImp:oldVerticalPainter];
         [m_scrollbarPainterController.get() setVerticalScrollerImp:newVerticalPainter];
         macTheme->setNewPainterForScrollbar(verticalScrollbar, newVerticalPainter);
 
-        // The different scrollbar styles have different thicknesses, so we must re-set the 
+        // 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->invalidate();
 
         ScrollbarPainter oldHorizontalPainter = [m_scrollbarPainterController.get() horizontalScrollerImp];
-        ScrollbarPainter newHorizontalPainter = [NSClassFromString(@"NSScrollerImp") scrollerImpWithStyle:newStyle 
-                                                                                    controlSize:(NSControlSize)horizontalScrollbar->controlSize() 
-                                                                                    horizontal:YES 
+        ScrollbarPainter newHorizontalPainter = [NSClassFromString(@"NSScrollerImp") scrollerImpWithStyle:newStyle
+                                                                                    controlSize:(NSControlSize)horizontalScrollbar->controlSize()
+                                                                                    horizontal:YES
                                                                                     replacingScrollerImp:oldHorizontalPainter];
         [m_scrollbarPainterController.get() setHorizontalScrollerImp:newHorizontalPainter];
         macTheme->setNewPainterForScrollbar(horizontalScrollbar, newHorizontalPainter);
 
-        // The different scrollbar styles have different thicknesses, so we must re-set the 
+        // 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 
+    // 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.
     scrollableArea()->scrollbarStyleChanged(newStyle, !m_needsScrollerStyleUpdate);
 
     m_needsScrollerStyleUpdate = false;
 }
 
 void ScrollAnimatorMac::startScrollbarPaintTimer()
 {
     m_initialScrollbarPaintTimer.startOneShot(0.1);
 }
@@ skipping 45 matching lines @@
         return;
 
     m_visibleScrollerThumbRect = rectInViewCoordinates;
 }
 
 bool ScrollAnimatorMac::canUseCoordinatedScrollbar() {
     return ScrollbarThemeMacCommon::isOverlayAPIAvailable();
 }
 
 } // namespace WebCore