Merge 88396 - 2011-06-08 Sailesh Agrawal <sail@chromium.org>

Source/WebCore/platform/chromium/ScrollbarThemeChromiumMac.mm

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 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:
  * 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
@@ skipping 11 matching lines @@
  * 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 "ScrollbarThemeChromiumMac.h"
 
 #include "FrameView.h"
 #include "ImageBuffer.h"
+#include "LocalCurrentGraphicsContext.h"
 #include "PlatformBridge.h"
 #include "PlatformMouseEvent.h"
+#include "ScrollAnimatorChromiumMac.h"
 #include "ScrollView.h"
 #include <Carbon/Carbon.h>
+#include <wtf/HashMap.h>
 #include <wtf/StdLibExtras.h>
 #include <wtf/UnusedParam.h>
 
 
 // FIXME: There are repainting problems due to Aqua scroll bar buttons' visual overflow.
 
 using namespace std;
 using namespace WebCore;
 
 // This file (and its associated .h file) is a clone of ScrollbarThemeMac.mm.
 // Because we want to draw tickmarks in the scrollbar, we must maintain a fork.
 // Please maintain this file by performing parallel changes to it.
 //
 // The only changes from ScrollbarThemeMac should be:
 // - The classname change from ScrollbarThemeMac to ScrollbarThemeChromiumMac.
 // - In paint() the code to paint the track, tickmarks, and thumb separately.
 // - In paint() the thumb is drawn via ChromeBridge/WebThemeEngine.
+// - Various functions that were split using #if USE(WK_SCROLLBAR_PAINTER)
+//   have been combined using runtime checks instead.
 //
 // For all other differences, if it was introduced in this file, then the
 // maintainer forgot to include it in the list; otherwise it is an update that
 // should have been applied to this file but was not.
 
-static HashSet<Scrollbar*>* gScrollbars;
+namespace WebCore {
+
+typedef HashMap<Scrollbar*, RetainPtr<WKScrollbarPainterRef> > ScrollbarPainterMap;
+
+static ScrollbarPainterMap* scrollbarMap()
+{
+    static ScrollbarPainterMap* map = new ScrollbarPainterMap;
+    return map;
+}
+
+}
 
 @interface ScrollbarPrefsObserver : NSObject
 {
-
 }
 
 + (void)registerAsObserver;
 + (void)appearancePrefsChanged:(NSNotification*)theNotification;
 + (void)behaviorPrefsChanged:(NSNotification*)theNotification;
 
 @end
 
 @implementation ScrollbarPrefsObserver
 
 + (void)appearancePrefsChanged:(NSNotification*)unusedNotification
 {
     UNUSED_PARAM(unusedNotification);
 
     static_cast<ScrollbarThemeChromiumMac*>(ScrollbarTheme::nativeTheme())->preferencesChanged();
-    if (!gScrollbars)
+    if (scrollbarMap()->isEmpty())
         return;
-    HashSet<Scrollbar*>::iterator end = gScrollbars->end();
-    for (HashSet<Scrollbar*>::iterator it = gScrollbars->begin(); it != end; ++it) {
-        (*it)->styleChanged();
-        (*it)->invalidate();
+    ScrollbarPainterMap::iterator end = scrollbarMap()->end();
+    for (ScrollbarPainterMap::iterator it = scrollbarMap()->begin(); it != end; ++it) {
+        it->first->styleChanged();
+        it->first->invalidate();
     }
 }
 
 + (void)behaviorPrefsChanged:(NSNotification*)unusedNotification
 {
     UNUSED_PARAM(unusedNotification);
 
     static_cast<ScrollbarThemeChromiumMac*>(ScrollbarTheme::nativeTheme())->preferencesChanged();
 }
 
@@ skipping 21 matching lines @@
 // cRealButtonLength - cButtonInset
 static int cButtonLength[] = { 14, 10 };
 static int cThumbMinLength[] = { 26, 20 };
 
 static int cOuterButtonLength[] = { 16, 14 }; // The outer button in a double button pair is a bit bigger.
 static int cOuterButtonOverlap = 2;
 
 static float gInitialButtonDelay = 0.5f;
 static float gAutoscrollButtonDelay = 0.05f;
 static bool gJumpOnTrackClick = false;
-static ScrollbarButtonsPlacement gButtonPlacement = ScrollbarButtonsDoubleEnd;
+static ScrollbarButtonsPlacement gButtonPlacement = isScrollbarOverlayAPIAvailable() ? ScrollbarButtonsNone : ScrollbarButtonsDoubleEnd;
 
 static void updateArrowPlacement()
 {
+    if (isScrollbarOverlayAPIAvailable())
+        return;
+
     NSString *buttonPlacement = [[NSUserDefaults standardUserDefaults] objectForKey:@"AppleScrollBarVariant"];
     if ([buttonPlacement isEqualToString:@"Single"])
         gButtonPlacement = ScrollbarButtonsSingle;
     else if ([buttonPlacement isEqualToString:@"DoubleMin"])
         gButtonPlacement = ScrollbarButtonsDoubleStart;
     else if ([buttonPlacement isEqualToString:@"DoubleBoth"])
         gButtonPlacement = ScrollbarButtonsDoubleBoth;
     else
-        gButtonPlacement = ScrollbarButtonsDoubleEnd; // The default is ScrollbarButtonsDoubleEnd.
+        gButtonPlacement = ScrollbarButtonsDoubleEnd;
 }
 
 void ScrollbarThemeChromiumMac::registerScrollbar(Scrollbar* scrollbar)
 {
-    if (!gScrollbars)
-        gScrollbars = new HashSet<Scrollbar*>;
-    gScrollbars->add(scrollbar);
+    bool isHorizontal = scrollbar->orientation() == HorizontalScrollbar;
+    WKScrollbarPainterRef scrollbarPainter = wkMakeScrollbarPainter(scrollbar->controlSize(), isHorizontal);
+    scrollbarMap()->add(scrollbar, scrollbarPainter);
 }
 
 void ScrollbarThemeChromiumMac::unregisterScrollbar(Scrollbar* scrollbar)
 {
-    gScrollbars->remove(scrollbar);
-    if (gScrollbars->isEmpty()) {
-        delete gScrollbars;
-        gScrollbars = 0;
-    }
+    scrollbarMap()->remove(scrollbar);
+}
+
+void ScrollbarThemeChromiumMac::setNewPainterForScrollbar(Scrollbar* scrollbar, WKScrollbarPainterRef newPainter)
+{
+    scrollbarMap()->set(scrollbar, newPainter);
+}
+
+WKScrollbarPainterRef ScrollbarThemeChromiumMac::painterForScrollbar(Scrollbar* scrollbar)
+{
+    return scrollbarMap()->get(scrollbar).get();
 }
 
 ScrollbarThemeChromiumMac::ScrollbarThemeChromiumMac()
 {
     static bool initialized;
     if (!initialized) {
         initialized = true;
         [ScrollbarPrefsObserver registerAsObserver];
         preferencesChanged();
     }
 }
 
 ScrollbarThemeChromiumMac::~ScrollbarThemeChromiumMac()
 {
 }
 
 void ScrollbarThemeChromiumMac::preferencesChanged()
 {
     NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
     [defaults synchronize];
     updateArrowPlacement();
     gInitialButtonDelay = [defaults floatForKey:@"NSScrollerButtonDelay"];
     gAutoscrollButtonDelay = [defaults floatForKey:@"NSScrollerButtonPeriod"];
     gJumpOnTrackClick = [defaults boolForKey:@"AppleScrollerPagingBehavior"];
 }
 
 int ScrollbarThemeChromiumMac::scrollbarThickness(ScrollbarControlSize controlSize)
 {
-    return cScrollbarThickness[controlSize];
+    if (isScrollbarOverlayAPIAvailable())
+        return wkScrollbarThickness(controlSize);
+    else
+        return cScrollbarThickness[controlSize];
+}
+
+bool ScrollbarThemeChromiumMac::usesOverlayScrollbars() const
+{
+    if (isScrollbarOverlayAPIAvailable())
+        return wkScrollbarPainterUsesOverlayScrollers();
+    else
+        return false;
 }
 
 double ScrollbarThemeChromiumMac::initialAutoscrollTimerDelay()
 {
     return gInitialButtonDelay;
 }
 
 double ScrollbarThemeChromiumMac::autoscrollTimerDelay()
 {
     return gAutoscrollButtonDelay;
 }
 
 ScrollbarButtonsPlacement ScrollbarThemeChromiumMac::buttonsPlacement() const
 {
     return gButtonPlacement;
 }
 
 bool ScrollbarThemeChromiumMac::hasButtons(Scrollbar* scrollbar)
 {
-    return scrollbar->enabled() && (scrollbar->orientation() == HorizontalScrollbar ?
-             scrollbar->width() :
-             scrollbar->height()) >= 2 * (cRealButtonLength[scrollbar->controlSize()] - cButtonHitInset[scrollbar->controlSize()]);
+    return scrollbar->enabled() && gButtonPlacement != ScrollbarButtonsNone
+             && (scrollbar->orientation() == HorizontalScrollbar
+             ? scrollbar->width()
+             : scrollbar->height()) >= 2 * (cRealButtonLength[scrollbar->controlSize()] - cButtonHitInset[scrollbar->controlSize()]);
 }
 
 bool ScrollbarThemeChromiumMac::hasThumb(Scrollbar* scrollbar)
 {
+    int minLengthForThumb;
+    if (isScrollbarOverlayAPIAvailable())
+        minLengthForThumb = wkScrollbarMinimumTotalLengthNeededForThumb(scrollbarMap()->get(scrollbar).get());
+    else
+        minLengthForThumb = 2 * cButtonInset[scrollbar->controlSize()] + cThumbMinLength[scrollbar->controlSize()] + 1;
     return scrollbar->enabled() && (scrollbar->orientation() == HorizontalScrollbar ?
              scrollbar->width() :
-             scrollbar->height()) >= 2 * cButtonInset[scrollbar->controlSize()] + cThumbMinLength[scrollbar->controlSize()] + 1;
+             scrollbar->height()) >= minLengthForThumb;
 }
 
 static IntRect buttonRepaintRect(const IntRect& buttonRect, ScrollbarOrientation orientation, ScrollbarControlSize controlSize, bool start)
 {
+    ASSERT(gButtonPlacement != ScrollbarButtonsNone);
+
     IntRect paintRect(buttonRect);
     if (orientation == HorizontalScrollbar) {
         paintRect.setWidth(cRealButtonLength[controlSize]);
         if (!start)
             paintRect.setX(buttonRect.x() - (cRealButtonLength[controlSize] - buttonRect.width()));
     } else {
         paintRect.setHeight(cRealButtonLength[controlSize]);
         if (!start)
             paintRect.setY(buttonRect.y() - (cRealButtonLength[controlSize] - buttonRect.height()));
     }
@@ skipping 107 matching lines @@
     }
 
     int totalWidth = startWidth + endWidth;
     if (scrollbar->orientation() == HorizontalScrollbar)
         return IntRect(scrollbar->x() + startWidth, scrollbar->y(), scrollbar->width() - totalWidth, thickness);
     return IntRect(scrollbar->x(), scrollbar->y() + startWidth, thickness, scrollbar->height() - totalWidth);
 }
 
 int ScrollbarThemeChromiumMac::minimumThumbLength(Scrollbar* scrollbar)
 {
-    return cThumbMinLength[scrollbar->controlSize()];
+    if (isScrollbarOverlayAPIAvailable())
+        return wkScrollbarMinimumThumbLength(scrollbarMap()->get(scrollbar).get());
+    else
+        return cThumbMinLength[scrollbar->controlSize()];
 }
 
 bool ScrollbarThemeChromiumMac::shouldCenterOnThumb(Scrollbar*, const PlatformMouseEvent& evt)
 {
     if (evt.button() != LeftButton)
         return false;
     if (gJumpOnTrackClick)
         return !evt.altKey();
     return evt.altKey();
 }
 
+bool ScrollbarThemeChromiumMac::shouldDragDocumentInsteadOfThumb(Scrollbar*, const PlatformMouseEvent& event)
+{
+    return event.altKey();
+}
+
 static int scrollbarPartToHIPressedState(ScrollbarPart part)
 {
     switch (part) {
         case BackButtonStartPart:
             return kThemeTopOutsideArrowPressed;
         case BackButtonEndPart:
             return kThemeTopOutsideArrowPressed; // This does not make much sense.  For some reason the outside constant is required.
         case ForwardButtonStartPart:
             return kThemeTopInsideArrowPressed;
         case ForwardButtonEndPart:
             return kThemeBottomOutsideArrowPressed;
         case ThumbPart:
             return kThemeThumbPressed;
         default:
             return 0;
     }
 }
 
+static inline wkScrollerKnobStyle toScrollbarPainterKnobStyle(ScrollbarOverlayStyle style)
+{
+    switch (style) {
+    case ScrollbarOverlayStyleDark:
+        return wkScrollerKnobStyleDark;
+    case ScrollbarOverlayStyleLight:
+        return wkScrollerKnobStyleLight;
+    default:
+        return wkScrollerKnobStyleDefault;
+    }
+}
+
 static PlatformBridge::ThemePaintState scrollbarStateToThemeState(Scrollbar* scrollbar) {
     if (!scrollbar->enabled())
         return PlatformBridge::StateDisabled;
     if (!scrollbar->scrollableArea()->isActive())
         return PlatformBridge::StateInactive;
     if (scrollbar->pressedPart() == ThumbPart)
         return PlatformBridge::StatePressed;
 
     return PlatformBridge::StateActive;
 }
 
 bool ScrollbarThemeChromiumMac::paint(Scrollbar* scrollbar, GraphicsContext* context, const IntRect& damageRect)
 {
+    if (isScrollbarOverlayAPIAvailable()) {
+        float value = 0;
+        float overhang = 0;
+
+        if (scrollbar->currentPos() < 0) {
+            // Scrolled past the top.
+            value = 0;
+            overhang = -scrollbar->currentPos();
+        } else if (scrollbar->visibleSize() + scrollbar->currentPos() > scrollbar->totalSize()) {
+            // Scrolled past the bottom.
+            value = 1;
+            overhang = scrollbar->currentPos() + scrollbar->visibleSize() - scrollbar->totalSize();
+        } else {
+            // Within the bounds of the scrollable area.
+            int maximum = scrollbar->maximum();
+            if (maximum > 0)
+                value = scrollbar->currentPos() / maximum;
+            else
+                value = 0;
+        }
+
+        ScrollAnimatorChromiumMac* scrollAnimator = static_cast<ScrollAnimatorChromiumMac*>(scrollbar->scrollableArea()->scrollAnimator());
+        scrollAnimator->setIsDrawingIntoLayer(context->isCALayerContext());
+
+        wkSetScrollbarPainterKnobStyle(painterForScrollbar(scrollbar), toScrollbarPainterKnobStyle(scrollbar->scrollableArea()->recommendedScrollbarOverlayStyle()));
+
+        GraphicsContextStateSaver stateSaver(*context);
+        context->clip(damageRect);
+        context->translate(scrollbar->frameRect().x(), scrollbar->frameRect().y());
+        LocalCurrentGraphicsContext localContext(context);
+        wkScrollbarPainterPaint(scrollbarMap()->get(scrollbar).get(),
+                                scrollbar->enabled(),
+                                value,
+                                (static_cast<CGFloat>(scrollbar->visibleSize()) - overhang) / scrollbar->totalSize(),
+                                scrollbar->frameRect());
+
+        scrollAnimator->setIsDrawingIntoLayer(false);
+        return true;
+    }
+
     HIThemeTrackDrawInfo trackInfo;
     trackInfo.version = 0;
     trackInfo.kind = scrollbar->controlSize() == RegularScrollbar ? kThemeMediumScrollBar : kThemeSmallScrollBar;
     trackInfo.bounds = scrollbar->frameRect();
     trackInfo.min = 0;
     trackInfo.max = scrollbar->maximum();
     trackInfo.value = scrollbar->currentPos();
     trackInfo.trackInfo.scrollbar.viewsize = scrollbar->visibleSize();
     trackInfo.attributes = 0;
     if (scrollbar->orientation() == HorizontalScrollbar)
@@ skipping 83 matching lines @@
             scrollbarInfo);
     }
 
     if (!canDrawDirectly)
         context->drawImageBuffer(imageBuffer.get(), ColorSpaceDeviceRGB, scrollbar->frameRect().location());
 
     return true;
 }
 
 }
-