Re-add snap-back behavior (Blink side)

Source/platform/scroll/ScrollbarTheme.cpp

 /*
  * Copyright (C) 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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/scroll/ScrollbarTheme.h"
 
 #include "RuntimeEnabledFeatures.h"
+#include "platform/PlatformMouseEvent.h"
 #include "platform/scroll/ScrollbarThemeClient.h"
 #include "platform/scroll/ScrollbarThemeMock.h"
 #include "platform/scroll/ScrollbarThemeOverlayMock.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebPoint.h"
+#include "public/platform/WebScrollbarBehavior.h"
 
 #if !OS(MACOSX)
-#include "public/platform/Platform.h"
 #include "public/platform/WebRect.h"
 #include "public/platform/WebThemeEngine.h"
 #endif
 
 namespace WebCore {
 
-ScrollbarTheme* ScrollbarTheme::theme()
-{
-    if (ScrollbarTheme::mockScrollbarsEnabled()) {
-        if (RuntimeEnabledFeatures::overlayScrollbarsEnabled()) {
-            DEFINE_STATIC_LOCAL(ScrollbarThemeOverlayMock, overlayMockTheme, ());
-            return &overlayMockTheme;
-        }
-
-        DEFINE_STATIC_LOCAL(ScrollbarThemeMock, mockTheme, ());
-        return &mockTheme;
-    }
-    return nativeTheme();
-}
-
 bool ScrollbarTheme::gMockScrollbarsEnabled = false;
 
-void ScrollbarTheme::setMockScrollbarsEnabled(bool flag)
-{
-    gMockScrollbarsEnabled = flag;
-}
-
-bool ScrollbarTheme::mockScrollbarsEnabled()
-{
-    return gMockScrollbarsEnabled;
-}
-
 bool ScrollbarTheme::paint(ScrollbarThemeClient* scrollbar, GraphicsContext* graphicsContext, const IntRect& damageRect)
 {
     // Create the ScrollbarControlPartMask based on the damageRect
     ScrollbarControlPartMask scrollMask = NoPart;
 
     IntRect backButtonStartPaintRect;
     IntRect backButtonEndPaintRect;
     IntRect forwardButtonStartPaintRect;
     IntRect forwardButtonEndPaintRect;
     if (hasButtons(scrollbar)) {
@@ skipping 135 matching lines @@
         else if (part == ForwardTrackPart)
             result = afterThumbRect;
         else
             result = thumbRect;
     }
     }
     result.moveBy(-scrollbar->location());
     scrollbar->invalidateRect(result);
 }
 
-void ScrollbarTheme::splitTrack(ScrollbarThemeClient* scrollbar, const IntRect& unconstrainedTrackRect, IntRect& beforeThumbRect, IntRect& thumbRect, IntRect& afterThumbRect)
+void ScrollbarTheme::paintScrollCorner(GraphicsContext* context, const IntRect& cornerRect)
 {
-    // This function won't even get called unless we're big enough to have some combination of these three rects where at least
-    // one of them is non-empty.
-    IntRect trackRect = constrainTrackRectToTrackPieces(scrollbar, unconstrainedTrackRect);
-    int thumbPos = thumbPosition(scrollbar);
-    if (scrollbar->orientation() == HorizontalScrollbar) {
-        thumbRect = IntRect(trackRect.x() + thumbPos, trackRect.y(), thumbLength(scrollbar), scrollbar->height());
-        beforeThumbRect = IntRect(trackRect.x(), trackRect.y(), thumbPos + thumbRect.width() / 2, trackRect.height());
-        afterThumbRect = IntRect(trackRect.x() + beforeThumbRect.width(), trackRect.y(), trackRect.maxX() - beforeThumbRect.maxX(), trackRect.height());
-    } else {
-        thumbRect = IntRect(trackRect.x(), trackRect.y() + thumbPos, scrollbar->width(), thumbLength(scrollbar));
-        beforeThumbRect = IntRect(trackRect.x(), trackRect.y(), trackRect.width(), thumbPos + thumbRect.height() / 2);
-        afterThumbRect = IntRect(trackRect.x(), trackRect.y() + beforeThumbRect.height(), trackRect.width(), trackRect.maxY() - beforeThumbRect.maxY());
-    }
+    if (cornerRect.isEmpty())
+        return;
+
+#if OS(MACOSX)
+    context->fillRect(cornerRect, Color::white);
+#else
+    blink::Platform::current()->themeEngine()->paint(context->canvas(), blink::WebThemeEngine::PartScrollbarCorner, blink::WebThemeEngine::StateNormal, blink::WebRect(cornerRect), 0);
+#endif
+}
+
+void ScrollbarTheme::paintOverhangBackground(GraphicsContext* context, const IntRect& horizontalOverhangRect, const IntRect& verticalOverhangRect, const IntRect& dirtyRect)
+{
+    context->setFillColor(Color::white);
+    if (!horizontalOverhangRect.isEmpty())
+        context->fillRect(intersection(horizontalOverhangRect, dirtyRect));
+    if (!verticalOverhangRect.isEmpty())
+        context->fillRect(intersection(verticalOverhangRect, dirtyRect));
+}
+
+bool ScrollbarTheme::shouldCenterOnThumb(ScrollbarThemeClient* scrollbar, const PlatformMouseEvent& evt)
+{
+    return blink::Platform::current()->scrollbarBehavior()->shouldCenterOnThumb(static_cast<blink::WebScrollbarBehavior::Button>(evt.button()), evt.shiftKey(), evt.altKey());
+}
+
+bool ScrollbarTheme::shouldSnapBackToDragOrigin(ScrollbarThemeClient* scrollbar, const PlatformMouseEvent& evt)
+{
+    IntPoint mousePosition = scrollbar->convertFromContainingWindow(evt.position());
+    mousePosition.move(scrollbar->x(), scrollbar->y());
+    return blink::Platform::current()->scrollbarBehavior()->shouldSnapBackToDragOrigin(mousePosition, trackRect(scrollbar), scrollbar->orientation() == HorizontalScrollbar);
 }
 
 // Returns the size represented by track taking into account scrolling past
 // the end of the document.
 static float usedTotalSize(ScrollbarThemeClient* scrollbar)
 {
     float overhangAtStart = -scrollbar->currentPos();
     float overhangAtEnd = scrollbar->currentPos() + scrollbar->visibleSize() - scrollbar->totalSize();
     float overhang = std::max(0.0f, std::max(overhangAtStart, overhangAtEnd));
     return scrollbar->totalSize() + overhang;
@@ skipping 24 matching lines @@
         overhang = scrollbar->currentPos() + scrollbar->visibleSize() - scrollbar->totalSize();
     float proportion = (scrollbar->visibleSize() - overhang) / usedTotalSize(scrollbar);
     int trackLen = trackLength(scrollbar);
     int length = round(proportion * trackLen);
     length = std::max(length, minimumThumbLength(scrollbar));
     if (length > trackLen)
         length = 0; // Once the thumb is below the track length, it just goes away (to make more room for the track).
     return length;
 }
 
-int ScrollbarTheme::minimumThumbLength(ScrollbarThemeClient* scrollbar)
-{
-    return scrollbarThickness(scrollbar->controlSize());
-}
-
 int ScrollbarTheme::trackPosition(ScrollbarThemeClient* scrollbar)
 {
     IntRect constrainedTrackRect = constrainTrackRectToTrackPieces(scrollbar, trackRect(scrollbar));
     return (scrollbar->orientation() == HorizontalScrollbar) ? constrainedTrackRect.x() - scrollbar->x() : constrainedTrackRect.y() - scrollbar->y();
 }
 
 int ScrollbarTheme::trackLength(ScrollbarThemeClient* scrollbar)
 {
     IntRect constrainedTrackRect = constrainTrackRectToTrackPieces(scrollbar, trackRect(scrollbar));
     return (scrollbar->orientation() == HorizontalScrollbar) ? constrainedTrackRect.width() : constrainedTrackRect.height();
 }
 
-void ScrollbarTheme::paintScrollCorner(GraphicsContext* context, const IntRect& cornerRect)
-{
-    if (cornerRect.isEmpty())
-        return;
-
-#if OS(MACOSX)
-    context->fillRect(cornerRect, Color::white);
-#else
-    blink::Platform::current()->themeEngine()->paint(context->canvas(), blink::WebThemeEngine::PartScrollbarCorner, blink::WebThemeEngine::StateNormal, blink::WebRect(cornerRect), 0);
-#endif
-}
-
 IntRect ScrollbarTheme::thumbRect(ScrollbarThemeClient* scrollbar)
 {
     if (!hasThumb(scrollbar))
         return IntRect();
 
     IntRect track = trackRect(scrollbar);
     IntRect startTrackRect;
     IntRect thumbRect;
     IntRect endTrackRect;
     splitTrack(scrollbar, track, startTrackRect, thumbRect, endTrackRect);
 
     return thumbRect;
 }
 
 int ScrollbarTheme::thumbThickness(ScrollbarThemeClient* scrollbar)
 {
     IntRect track = trackRect(scrollbar);
     return scrollbar->orientation() == HorizontalScrollbar ? track.height() : track.width();
 }
 
-void ScrollbarTheme::paintOverhangBackground(GraphicsContext* context, const IntRect& horizontalOverhangRect, const IntRect& verticalOverhangRect, const IntRect& dirtyRect)
+int ScrollbarTheme::minimumThumbLength(ScrollbarThemeClient* scrollbar)
 {
-    context->setFillColor(Color::white);
-    if (!horizontalOverhangRect.isEmpty())
-        context->fillRect(intersection(horizontalOverhangRect, dirtyRect));
-    if (!verticalOverhangRect.isEmpty())
-        context->fillRect(intersection(verticalOverhangRect, dirtyRect));
+    return scrollbarThickness(scrollbar->controlSize());
+}
+
+void ScrollbarTheme::splitTrack(ScrollbarThemeClient* scrollbar, const IntRect& unconstrainedTrackRect, IntRect& beforeThumbRect, IntRect& thumbRect, IntRect& afterThumbRect)
+{
+    // This function won't even get called unless we're big enough to have some combination of these three rects where at least
+    // one of them is non-empty.
+    IntRect trackRect = constrainTrackRectToTrackPieces(scrollbar, unconstrainedTrackRect);
+    int thumbPos = thumbPosition(scrollbar);
+    if (scrollbar->orientation() == HorizontalScrollbar) {
+        thumbRect = IntRect(trackRect.x() + thumbPos, trackRect.y(), thumbLength(scrollbar), scrollbar->height());
+        beforeThumbRect = IntRect(trackRect.x(), trackRect.y(), thumbPos + thumbRect.width() / 2, trackRect.height());
+        afterThumbRect = IntRect(trackRect.x() + beforeThumbRect.width(), trackRect.y(), trackRect.maxX() - beforeThumbRect.maxX(), trackRect.height());
+    } else {
+        thumbRect = IntRect(trackRect.x(), trackRect.y() + thumbPos, scrollbar->width(), thumbLength(scrollbar));
+        beforeThumbRect = IntRect(trackRect.x(), trackRect.y(), trackRect.width(), thumbPos + thumbRect.height() / 2);
+        afterThumbRect = IntRect(trackRect.x(), trackRect.y() + beforeThumbRect.height(), trackRect.width(), trackRect.maxY() - beforeThumbRect.maxY());
+    }
+}
+
+ScrollbarTheme* ScrollbarTheme::theme()
+{
+    if (ScrollbarTheme::mockScrollbarsEnabled()) {
+        if (RuntimeEnabledFeatures::overlayScrollbarsEnabled()) {
+            DEFINE_STATIC_LOCAL(ScrollbarThemeOverlayMock, overlayMockTheme, ());
+            return &overlayMockTheme;
+        }
+
+        DEFINE_STATIC_LOCAL(ScrollbarThemeMock, mockTheme, ());
+        return &mockTheme;
+    }
+    return nativeTheme();
+}
+
+void ScrollbarTheme::setMockScrollbarsEnabled(bool flag)
+{
+    gMockScrollbarsEnabled = flag;
+}
+
+bool ScrollbarTheme::mockScrollbarsEnabled()
+{
+    return gMockScrollbarsEnabled;
 }
 
 }