Allow objects without scrollbars to be scrollable

Source/core/platform/ScrollAnimator.cpp

 /*
  * Copyright (c) 2010, Google 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:
  * 
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 58 matching lines @@
 void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
 {
     FloatSize delta = FloatSize(offset.x() - m_currentPosX, offset.y() - m_currentPosY);
     m_currentPosX = offset.x();
     m_currentPosY = offset.y();
     notifyPositionChanged(delta);
 }
 
 bool ScrollAnimator::handleWheelEvent(const PlatformWheelEvent& e)
 {
-    Scrollbar* horizontalScrollbar = m_scrollableArea->horizontalScrollbar();
-    Scrollbar* verticalScrollbar = m_scrollableArea->verticalScrollbar();
+    bool canScrollX = m_scrollableArea->isHorizontallyScrollable();
+    bool canScrollY = m_scrollableArea->isVerticallyScrollable();
 
-    // Accept the event if we have a scrollbar in that direction and can still
+    // Accept the event if we are scrollable in that direction and can still
     // scroll any further.
-    float deltaX = horizontalScrollbar ? e.deltaX() : 0;
-    float deltaY = verticalScrollbar ? e.deltaY() : 0;
+    float deltaX = canScrollX ? e.deltaX() : 0;
+    float deltaY = canScrollY ? e.deltaY() : 0;
 
     bool handled = false;
 
 #if !OS(DARWIN)
     ScrollGranularity granularity = e.hasPreciseScrollingDeltas() ? ScrollByPrecisePixel : ScrollByPixel;
 #else
     ScrollGranularity granularity = ScrollByPixel;
 #endif
 
     IntSize maxForwardScrollDelta = m_scrollableArea->maximumScrollPosition() - m_scrollableArea->scrollPosition();
     IntSize maxBackwardScrollDelta = m_scrollableArea->scrollPosition() - m_scrollableArea->minimumScrollPosition();
     if ((deltaX < 0 && maxForwardScrollDelta.width() > 0)
         || (deltaX > 0 && maxBackwardScrollDelta.width() > 0)
         || (deltaY < 0 && maxForwardScrollDelta.height() > 0)
         || (deltaY > 0 && maxBackwardScrollDelta.height() > 0)) {
         handled = true;
 
         if (deltaY) {
             if (e.granularity() == ScrollByPageWheelEvent) {
                 bool negative = deltaY < 0;
                 deltaY = max(max(static_cast<float>(m_scrollableArea->visibleHeight()) * Scrollbar::minFractionToStepWhenPaging(), static_cast<float>(m_scrollableArea->visibleHeight() - Scrollbar::maxOverlapBetweenPages())), 1.0f);
                 if (negative)
                     deltaY = -deltaY;
             }
-            scroll(VerticalScrollbar, granularity, verticalScrollbar->pixelStep(), -deltaY);
+
+            float step = 1;
+            Scrollbar* verticalScrollbar = m_scrollableArea->verticalScrollbar();
+            if (verticalScrollbar)
+                step = verticalScrollbar->pixelStep();
+
+            scroll(VerticalScrollbar, granularity, step, -deltaY);
         }
 
         if (deltaX) {
             if (e.granularity() == ScrollByPageWheelEvent) {
                 bool negative = deltaX < 0;
                 deltaX = max(max(static_cast<float>(m_scrollableArea->visibleWidth()) * Scrollbar::minFractionToStepWhenPaging(), static_cast<float>(m_scrollableArea->visibleWidth() - Scrollbar::maxOverlapBetweenPages())), 1.0f);
                 if (negative)
                     deltaX = -deltaX;
             }
-            scroll(HorizontalScrollbar, granularity, horizontalScrollbar->pixelStep(), -deltaX);
+
+            float step = 1;
+            Scrollbar* horizontalScrollbar = m_scrollableArea->horizontalScrollbar();
+            if (horizontalScrollbar)
+                step = horizontalScrollbar->pixelStep();
+
+            scroll(HorizontalScrollbar, granularity, step, -deltaX);
         }
     }
     return handled;
 }
 
 void ScrollAnimator::setCurrentPosition(const FloatPoint& position)
 {
     m_currentPosX = position.x();
     m_currentPosY = position.y();
 }
@@ skipping 10 matching lines @@
 }
 
 float ScrollAnimator::clampScrollPosition(ScrollbarOrientation orientation, float pos)
 {
     float maxScrollPos = m_scrollableArea->maximumScrollPosition(orientation);
     float minScrollPos = m_scrollableArea->minimumScrollPosition(orientation);
     return std::max(std::min(pos, maxScrollPos), minScrollPos);
 }
 
 } // namespace WebCore