Revert of Calculate paint invalidation rect for scrollbars

third_party/WebKit/Source/platform/scroll/Scrollbar.cpp

 /*
  * Copyright (C) 2004, 2006, 2008 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 16 matching lines @@
 #include "platform/scroll/Scrollbar.h"
 
 #include <algorithm>
 #include "platform/PlatformGestureEvent.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/graphics/paint/CullRect.h"
 #include "platform/scroll/ScrollAnimatorBase.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "platform/scroll/ScrollbarTheme.h"
 
+#if ((OS(POSIX) && !OS(MACOSX)) || OS(WIN))
+// The position of the scrollbar thumb affects the appearance of the steppers, so
+// when the thumb moves, we have to invalidate them for painting.
+#define THUMB_POSITION_AFFECTS_BUTTONS
+#endif
+
 namespace blink {
 
 PassRefPtrWillBeRawPtr<Scrollbar> Scrollbar::create(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, ScrollbarControlSize size)
 {
     return adoptRefWillBeNoop(new Scrollbar(scrollableArea, orientation, size));
 }
 
 Scrollbar::Scrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, ScrollbarControlSize controlSize, ScrollbarTheme* theme)
     : m_scrollableArea(scrollableArea)
     , m_orientation(orientation)
     , m_controlSize(controlSize)
     , m_theme(theme)
     , m_visibleSize(0)
     , m_totalSize(0)
     , m_currentPos(0)
     , m_dragOrigin(0)
     , m_hoveredPart(NoPart)
     , m_pressedPart(NoPart)
     , m_pressedPos(0)
     , m_scrollPos(0)
     , m_draggingDocument(false)
     , m_documentDragPos(0)
     , m_enabled(true)
     , m_scrollTimer(this, &Scrollbar::autoscrollTimerFired)
     , m_overlapsResizer(false)
+    , m_suppressInvalidation(false)
     , m_isAlphaLocked(false)
     , m_elasticOverscroll(0)
 {
     if (!m_theme)
         m_theme = ScrollbarTheme::theme();
 
     m_theme->registerScrollbar(this);
 
     // FIXME: This is ugly and would not be necessary if we fix cross-platform code to actually query for
     // scrollbar thickness and use it when sizing scrollbars (rather than leaving one dimension of the scrollbar
@@ skipping 13 matching lines @@
 {
     visitor->trace(m_scrollableArea);
     Widget::trace(visitor);
 }
 
 void Scrollbar::setFrameRect(const IntRect& frameRect)
 {
     if (frameRect == this->frameRect())
         return;
 
+    invalidate();
     Widget::setFrameRect(frameRect);
-    setNeedsPaintInvalidation();
+    invalidate();
 }
 
 ScrollbarOverlayStyle Scrollbar::scrollbarOverlayStyle() const
 {
     return m_scrollableArea ? m_scrollableArea->scrollbarOverlayStyle() : ScrollbarOverlayStyleDefault;
 }
 
 void Scrollbar::getTickmarks(Vector<IntRect>& tickmarks) const
 {
     if (m_scrollableArea)
@@ skipping 38 matching lines @@
         return;
 
     m_visibleSize = visibleSize;
     m_totalSize = totalSize;
 
     updateThumbProportion();
 }
 
 void Scrollbar::updateThumb()
 {
-    setNeedsPaintInvalidation();
+#ifdef THUMB_POSITION_AFFECTS_BUTTONS
+    invalidate();
+#else
+    theme()->invalidateParts(this, ForwardTrackPart | BackTrackPart | ThumbPart);
+#endif
 }
 
 void Scrollbar::updateThumbPosition()
 {
     updateThumb();
 }
 
 void Scrollbar::updateThumbProportion()
 {
     updateThumb();
@@ skipping 21 matching lines @@
 }
 
 void Scrollbar::autoscrollPressedPart(double delay)
 {
     // Don't do anything for the thumb or if nothing was pressed.
     if (m_pressedPart == ThumbPart || m_pressedPart == NoPart)
         return;
 
     // Handle the track.
     if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && thumbUnderMouse(this)) {
-        setNeedsPaintInvalidation();
+        theme()->invalidatePart(this, m_pressedPart);
         setHoveredPart(ThumbPart);
         return;
     }
 
     // Handle the arrows and track.
     if (m_scrollableArea && m_scrollableArea->userScroll(pressedPartScrollDirectionPhysical(), pressedPartScrollGranularity()).didScroll)
         startTimerIfNeeded(delay);
 }
 
 void Scrollbar::startTimerIfNeeded(double delay)
 {
     // Don't do anything for the thumb.
     if (m_pressedPart == ThumbPart)
         return;
 
     // Handle the track.  We halt track scrolling once the thumb is level
     // with us.
     if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && thumbUnderMouse(this)) {
-        setNeedsPaintInvalidation();
+        theme()->invalidatePart(this, m_pressedPart);
         setHoveredPart(ThumbPart);
         return;
     }
 
     // We can't scroll if we've hit the beginning or end.
     ScrollDirectionPhysical dir = pressedPartScrollDirectionPhysical();
     if (dir == ScrollUp || dir == ScrollLeft) {
         if (m_currentPos == 0)
             return;
     } else {
@@ skipping 73 matching lines @@
         float newPosition = static_cast<float>(thumbPos + delta) * (maxPos - minPos) / (trackLen - thumbLen) + minPos;
         m_scrollableArea->setScrollPositionSingleAxis(m_orientation, newPosition, UserScroll);
     }
 }
 
 void Scrollbar::setHoveredPart(ScrollbarPart part)
 {
     if (part == m_hoveredPart)
         return;
 
-    if (((m_hoveredPart == NoPart || part == NoPart) && theme()->invalidateOnMouseEnterExit())
-        // When there's a pressed part, we don't draw a hovered state, so there's no reason to invalidate.
-        || m_pressedPart == NoPart)
-        setNeedsPaintInvalidation();
-
+    if ((m_hoveredPart == NoPart || part == NoPart) && theme()->invalidateOnMouseEnterExit())
+        invalidate();  // Just invalidate the whole scrollbar, since the buttons at either end change anyway.
+    else if (m_pressedPart == NoPart) {  // When there's a pressed part, we don't draw a hovered state, so there's no reason to invalidate.
+        theme()->invalidatePart(this, part);
+        theme()->invalidatePart(this, m_hoveredPart);
+    }
     m_hoveredPart = part;
 }
 
 void Scrollbar::setPressedPart(ScrollbarPart part)
 {
-    if (m_pressedPart != NoPart
-        // When we no longer have a pressed part, we can start drawing a hovered state on the hovered part.
-        || m_hoveredPart != NoPart)
-        setNeedsPaintInvalidation();
+    if (m_pressedPart != NoPart)
+        theme()->invalidatePart(this, m_pressedPart);
     m_pressedPart = part;
+    if (m_pressedPart != NoPart)
+        theme()->invalidatePart(this, m_pressedPart);
+    else if (m_hoveredPart != NoPart)  // When we no longer have a pressed part, we can start drawing a hovered state on the hovered part.
+        theme()->invalidatePart(this, m_hoveredPart);
 }
 
 bool Scrollbar::gestureEvent(const PlatformGestureEvent& evt)
 {
     switch (evt.type()) {
     case PlatformEvent::GestureTapDown:
         setPressedPart(theme()->hitTest(this, evt.position()));
         m_pressedPos = orientation() == HorizontalScrollbar ? convertFromContainingWindow(evt.position()).x() : convertFromContainingWindow(evt.position()).y();
         return true;
     case PlatformEvent::GestureTapDownCancel:
@@ skipping 49 matching lines @@
     if (m_pressedPart != NoPart)
         m_pressedPos = orientation() == HorizontalScrollbar ? convertFromContainingWindow(evt.position()).x() : convertFromContainingWindow(evt.position()).y();
 
     ScrollbarPart part = theme()->hitTest(this, evt.position());
     if (part != m_hoveredPart) {
         if (m_pressedPart != NoPart) {
             if (part == m_pressedPart) {
                 // The mouse is moving back over the pressed part.  We
                 // need to start up the timer action again.
                 startTimerIfNeeded(theme()->autoscrollTimerDelay());
-                setNeedsPaintInvalidation();
+                theme()->invalidatePart(this, m_pressedPart);
             } else if (m_hoveredPart == m_pressedPart) {
                 // The mouse is leaving the pressed part.  Kill our timer
                 // if needed.
                 stopTimerIfNeeded();
-                setNeedsPaintInvalidation();
+                theme()->invalidatePart(this, m_pressedPart);
             }
         }
 
         setHoveredPart(part);
     }
 
     return;
 }
 
 void Scrollbar::mouseEntered()
@@ skipping 58 matching lines @@
     if (m_scrollableArea)
         m_scrollableArea->scrollbarVisibilityChanged();
 }
 
 void Scrollbar::setEnabled(bool e)
 {
     if (m_enabled == e)
         return;
     m_enabled = e;
     theme()->updateEnabledState(this);
-    setNeedsPaintInvalidation();
+    invalidate();
 }
 
 bool Scrollbar::isOverlayScrollbar() const
 {
     return m_theme->usesOverlayScrollbars();
 }
 
 bool Scrollbar::shouldParticipateInHitTesting()
 {
     // Non-overlay scrollbars should always participate in hit testing.
     if (!isOverlayScrollbar())
         return true;
     return m_scrollableArea->scrollAnimator()->shouldScrollbarParticipateInHitTesting(this);
 }
 
 bool Scrollbar::isWindowActive() const
 {
     return m_scrollableArea && m_scrollableArea->isActive();
 }
 
+void Scrollbar::invalidateRect(const IntRect& rect)
+{
+    if (suppressInvalidation())
+        return;
+
+    if (m_scrollableArea)
+        m_scrollableArea->invalidateScrollbar(this, rect);
+}
+
 IntRect Scrollbar::convertToContainingView(const IntRect& localRect) const
 {
     if (m_scrollableArea)
         return m_scrollableArea->convertFromScrollbarToContainingView(this, localRect);
 
     return Widget::convertToContainingView(localRect);
 }
 
 IntRect Scrollbar::convertFromContainingView(const IntRect& parentRect) const
 {
@@ skipping 23 matching lines @@
 {
     if (!m_scrollableArea)
         return 0;
 
     if (m_orientation == HorizontalScrollbar)
         return m_scrollableArea->scrollPosition().x() - m_scrollableArea->minimumScrollPosition().x();
 
     return m_scrollableArea->scrollPosition().y() - m_scrollableArea->minimumScrollPosition().y();
 }
 
-void Scrollbar::setNeedsPaintInvalidation()
-{
-    if (m_scrollableArea)
-        m_scrollableArea->setScrollbarNeedsPaintInvalidation(this);
-}
-
 } // namespace blink