Allow objects without scrollbars to be scrollable

Source/core/platform/ScrollableArea.cpp

 /*
  * Copyright (c) 2010, Google Inc. All rights reserved.
  * Copyright (C) 2008, 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 22 matching lines @@
 #include "core/platform/ScrollableArea.h"
 
 #include "core/platform/ScrollAnimator.h"
 #include "core/platform/ScrollbarTheme.h"
 #include "core/platform/graphics/FloatPoint.h"
 #include "core/platform/graphics/GraphicsLayer.h"
 #include "wtf/PassOwnPtr.h"
 
 #include "core/platform/chromium/TraceEvent.h"
 
+static const int kPixelsPerLineStep = 40;
+static const float kMinFractionToStepWhenPaging = 0.875f;
+
 namespace WebCore {
 
 struct SameSizeAsScrollableArea {
     virtual ~SameSizeAsScrollableArea();
     void* pointer;
     unsigned bitfields : 16;
     IntPoint origin;
 };
 
 COMPILE_ASSERT(sizeof(ScrollableArea) == sizeof(SameSizeAsScrollableArea), ScrollableArea_should_stay_small);
 
+int ScrollableArea::pixelsPerLineStep()
+{
+    return kPixelsPerLineStep;
+}
+
+float ScrollableArea::minFractionToStepWhenPaging()
+{
+    return kMinFractionToStepWhenPaging;
+}
+
+int ScrollableArea::maxOverlapBetweenPages()
+{
+    static int maxOverlapBetweenPages = ScrollbarTheme::theme()->maxOverlapBetweenPages();
+    return maxOverlapBetweenPages;
+}
+
 ScrollableArea::ScrollableArea()
     : m_constrainsScrollingToContentEdge(true)
     , m_inLiveResize(false)
     , m_verticalScrollElasticity(ScrollElasticityNone)
     , m_horizontalScrollElasticity(ScrollElasticityNone)
     , m_scrollbarOverlayStyle(ScrollbarOverlayStyleDefault)
     , m_scrollOriginChanged(false)
 {
 }
 
@@ skipping 13 matching lines @@
 {
     if (m_scrollOrigin != origin) {
         m_scrollOrigin = origin;
         m_scrollOriginChanged = true;
     }
 }
 
 bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)
 {
     ScrollbarOrientation orientation;
-    Scrollbar* scrollbar;
-    if (direction == ScrollUp || direction == ScrollDown) {
+
+    if (direction == ScrollUp || direction == ScrollDown)
         orientation = VerticalScrollbar;
-        scrollbar = verticalScrollbar();
-    } else {
+    else
         orientation = HorizontalScrollbar;
-        scrollbar = horizontalScrollbar();
-    }
 
-    if (!scrollbar)
+    if (!userInputScrollable(orientation))
         return false;
 
     float step = 0;
     switch (granularity) {
     case ScrollByLine:
-        step = scrollbar->lineStep();
+        step = lineStep(orientation);
         break;
     case ScrollByPage:
-        step = scrollbar->pageStep();
+        step = pageStep(orientation);
         break;
     case ScrollByDocument:
-        step = scrollbar->totalSize();
+        step = documentStep(orientation);
         break;
     case ScrollByPixel:
     case ScrollByPrecisePixel:
-        step = scrollbar->pixelStep();
+        step = pixelStep(orientation);
         break;
     }
 
     if (direction == ScrollUp || direction == ScrollLeft)
         multiplier = -multiplier;
 
     return scrollAnimator()->scroll(orientation, granularity, step, multiplier);
 }
 
 void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
@@ skipping 233 matching lines @@
 {
     return layerForScrollCorner();
 }
 
 void ScrollableArea::serviceScrollAnimations()
 {
     if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
         scrollAnimator->serviceScrollAnimations();
 }
 
-IntPoint ScrollableArea::scrollPosition() const
-{
-    int x = horizontalScrollbar() ? horizontalScrollbar()->value() : 0;
-    int y = verticalScrollbar() ? verticalScrollbar()->value() : 0;
-    return IntPoint(x, y);
-}
-
-IntPoint ScrollableArea::minimumScrollPosition() const
-{
-    return IntPoint();
-}
-
-IntPoint ScrollableArea::maximumScrollPosition() const
-{
-    return IntPoint(contentsSize().width() - visibleWidth(), contentsSize().height() - visibleHeight());
-}
-
 IntRect ScrollableArea::visibleContentRect(VisibleContentRectIncludesScrollbars scrollbarInclusion) const
 {
     int verticalScrollbarWidth = 0;
     int horizontalScrollbarHeight = 0;
 
     if (scrollbarInclusion == IncludeScrollbars) {
         if (Scrollbar* verticalBar = verticalScrollbar())
             verticalScrollbarWidth = !verticalBar->isOverlayScrollbar() ? verticalBar->width() : 0;
         if (Scrollbar* horizontalBar = horizontalScrollbar())
             horizontalScrollbarHeight = !horizontalBar->isOverlayScrollbar() ? horizontalBar->height() : 0;
     }
 
     return IntRect(scrollPosition().x(),
                    scrollPosition().y(),
                    std::max(0, visibleWidth() + verticalScrollbarWidth),
                    std::max(0, visibleHeight() + horizontalScrollbarHeight));
 }
 
 IntPoint ScrollableArea::clampScrollPosition(const IntPoint& scrollPosition) const
 {
     return scrollPosition.shrunkTo(maximumScrollPosition()).expandedTo(minimumScrollPosition());
 }
 
+int ScrollableArea::lineStep(ScrollbarOrientation) const
+{
+    return pixelsPerLineStep();
+}
+
+int ScrollableArea::documentStep(ScrollbarOrientation orientation) const
+{
+    return scrollSize(orientation);
+}
+
+float ScrollableArea::pixelStep(ScrollbarOrientation) const
+{
+    return 1;
+}
+
 } // namespace WebCore