Split ScrollbarThemeMac into Overlay and NonOverlay subclasses

Source/core/platform/mac/ScrollbarThemeMac.mm

 /*
  * 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:
  * 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 41 matching lines @@
 
 using namespace std;
 using namespace WebCore;
 
 @interface NSColor (WebNSColorDetails)
 + (NSImage *)_linenPatternImage;
 @end
 
 namespace WebCore {
 
+typedef HashMap<ScrollbarThemeClient*, ScrollbarThemeClient*> ScrollbarMap;
+
+static ScrollbarMap* scrollbarMap()
+{
+    static ScrollbarMap* map = new ScrollbarMap;
+    return map;
+}
+
 typedef HashMap<ScrollbarThemeClient*, RetainPtr<ScrollbarPainter> > ScrollbarPainterMap;
 
-static ScrollbarPainterMap* scrollbarMap()
+static ScrollbarPainterMap* scrollbarPainterMap()
 {
     static ScrollbarPainterMap* map = new ScrollbarPainterMap;
     return map;
 }
 
 }
 
 @interface WebScrollbarPrefsObserver : NSObject
 {
 }
 
 + (void)registerAsObserver;
 + (void)appearancePrefsChanged:(NSNotification*)theNotification;
 + (void)behaviorPrefsChanged:(NSNotification*)theNotification;
 
 @end
 
 @implementation WebScrollbarPrefsObserver
 
 + (void)appearancePrefsChanged:(NSNotification*)unusedNotification
 {
     UNUSED_PARAM(unusedNotification);
 
     ScrollbarTheme* theme = ScrollbarTheme::theme();
     if (theme->isMockTheme())
         return;
 
-    static_cast<ScrollbarThemeMac*>(ScrollbarTheme::theme())->preferencesChanged();
+    static_cast<ScrollbarThemeMacCommon*>(ScrollbarTheme::theme())->preferencesChanged();
     if (scrollbarMap()->isEmpty())
         return;
-    ScrollbarPainterMap::iterator end = scrollbarMap()->end();
-    for (ScrollbarPainterMap::iterator it = scrollbarMap()->begin(); it != end; ++it) {
+    ScrollbarMap::iterator end = scrollbarMap()->end();
+    for (ScrollbarMap::iterator it = scrollbarMap()->begin(); it != end; ++it) {
         it->key->styleChanged();
         it->key->invalidate();
     }
 }
 
 + (void)behaviorPrefsChanged:(NSNotification*)unusedNotification
 {
     UNUSED_PARAM(unusedNotification);
 
     ScrollbarTheme* theme = ScrollbarTheme::theme();
     if (theme->isMockTheme())
         return;
 
-    static_cast<ScrollbarThemeMac*>(ScrollbarTheme::theme())->preferencesChanged();
+    static_cast<ScrollbarThemeMacCommon*>(ScrollbarTheme::theme())->preferencesChanged();
 }
 
 + (void)registerAsObserver
 {
     [[NSDistributedNotificationCenter defaultCenter] addObserver:self selector:@selector(appearancePrefsChanged:) name:@"AppleAquaScrollBarVariantChanged" object:nil suspensionBehavior:NSNotificationSuspensionBehaviorDeliverImmediately];
     [[NSDistributedNotificationCenter defaultCenter] addObserver:self selector:@selector(behaviorPrefsChanged:) name:@"AppleNoRedisplayAppearancePreferenceChanged" object:nil suspensionBehavior:NSNotificationSuspensionBehaviorCoalesce];
 }
 
 @end
 
@@ skipping 17 matching lines @@
 
 static ScrollbarButtonsPlacement gButtonPlacement = ScrollbarButtonsDoubleEnd;
 
 static bool supportsExpandedScrollbars()
 {
     // FIXME: This is temporary until all platforms that support ScrollbarPainter support this part of the API.
     static bool globalSupportsExpandedScrollbars = [NSClassFromString(@"NSScrollerImp") instancesRespondToSelector:@selector(setExpanded:)];
     return globalSupportsExpandedScrollbars;
 }
 
-static void updateArrowPlacement()
+void ScrollbarThemeMacNonOverlayAPI::updateButtonPlacement()
 {
-    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;
     }
 }
 
 ScrollbarTheme* ScrollbarTheme::nativeTheme()
 {
-    DEFINE_STATIC_LOCAL(ScrollbarThemeMac, theme, ());
-    return &theme;
+    if (isScrollbarOverlayAPIAvailable()) {
+        DEFINE_STATIC_LOCAL(ScrollbarThemeMacOverlayAPI, theme, ());
+        return &theme;
+    } else {
+        DEFINE_STATIC_LOCAL(ScrollbarThemeMacNonOverlayAPI, theme, ());
+        return &theme;
+    }
+    return NULL;
 }
 
 static WebKit::WebThemeEngine::State scrollbarStateToThemeState(ScrollbarThemeClient* scrollbar)
 {
     if (!scrollbar->enabled())
         return WebKit::WebThemeEngine::StateDisabled;
     if (!scrollbar->isScrollableAreaActive())
         return WebKit::WebThemeEngine::StateInactive;
     if (scrollbar->pressedPart() == ThumbPart)
         return WebKit::WebThemeEngine::StatePressed;
 
     return WebKit::WebThemeEngine::StateActive;
 }
 
-void ScrollbarThemeMac::registerScrollbar(ScrollbarThemeClient* scrollbar)
+void ScrollbarThemeMacOverlayAPI::registerScrollbar(ScrollbarThemeClient* scrollbar)
 {
-    if (isScrollbarOverlayAPIAvailable()) {
-        bool isHorizontal = scrollbar->orientation() == HorizontalScrollbar;
-        ScrollbarPainter scrollbarPainter = [NSClassFromString(@"NSScrollerImp") scrollerImpWithStyle:recommendedScrollerStyle() controlSize:(NSControlSize)scrollbar->controlSize() horizontal:isHorizontal replacingScrollerImp:nil];
-        scrollbarMap()->add(scrollbar, scrollbarPainter);
-        updateEnabledState(scrollbar);
-        updateScrollbarOverlayStyle(scrollbar);
-    } else {
-        scrollbarMap()->add(scrollbar, nil);
-    }
+    ScrollbarThemeMacCommon::registerScrollbar(scrollbar);
+
+    bool isHorizontal = scrollbar->orientation() == HorizontalScrollbar;
+    ScrollbarPainter scrollbarPainter = [NSClassFromString(@"NSScrollerImp") scrollerImpWithStyle:recommendedScrollerStyle() controlSize:(NSControlSize)scrollbar->controlSize() horizontal:isHorizontal replacingScrollerImp:nil];
+    scrollbarPainterMap()->add(scrollbar, scrollbarPainter);
+    updateEnabledState(scrollbar);
+    updateScrollbarOverlayStyle(scrollbar);
 }
 
-void ScrollbarThemeMac::unregisterScrollbar(ScrollbarThemeClient* scrollbar)
+void ScrollbarThemeMacCommon::registerScrollbar(ScrollbarThemeClient* scrollbar)
+{
+    scrollbarMap()->add(scrollbar, scrollbar);
+}
+
+void ScrollbarThemeMacOverlayAPI::unregisterScrollbar(ScrollbarThemeClient* scrollbar)
+{
+    scrollbarPainterMap()->remove(scrollbar);
+
+    ScrollbarThemeMacCommon::unregisterScrollbar(scrollbar);
+}
+
+void ScrollbarThemeMacCommon::unregisterScrollbar(ScrollbarThemeClient* scrollbar)
 {
     scrollbarMap()->remove(scrollbar);
 }
 
-void ScrollbarThemeMac::setNewPainterForScrollbar(ScrollbarThemeClient* scrollbar, ScrollbarPainter newPainter)
+void ScrollbarThemeMacOverlayAPI::setNewPainterForScrollbar(ScrollbarThemeClient* scrollbar, ScrollbarPainter newPainter)
 {
-    scrollbarMap()->set(scrollbar, newPainter);
+    scrollbarPainterMap()->set(scrollbar, newPainter);
     updateEnabledState(scrollbar);
     updateScrollbarOverlayStyle(scrollbar);
 }
 
-ScrollbarPainter ScrollbarThemeMac::painterForScrollbar(ScrollbarThemeClient* scrollbar)
+ScrollbarPainter ScrollbarThemeMacOverlayAPI::painterForScrollbar(ScrollbarThemeClient* scrollbar)
 {
-    return scrollbarMap()->get(scrollbar).get();
+    return scrollbarPainterMap()->get(scrollbar).get();
 }
 
-// Override ScrollbarThemeMac::paint() to add support for the following:
+// Override ScrollbarThemeMacCommon::paint() to add support for the following:
 //     - drawing using WebThemeEngine functions
 //     - drawing tickmarks
 //     - Skia specific changes
-bool ScrollbarThemeMac::paint(ScrollbarThemeClient* scrollbar, GraphicsContext* context, const IntRect& damageRect)
+bool ScrollbarThemeMacNonOverlayAPI::paint(ScrollbarThemeClient* scrollbar, GraphicsContext* context, const IntRect& damageRect)
 {
-    if (isScrollbarOverlayAPIAvailable())
-        return ScrollbarThemeComposite::paint(scrollbar, context, damageRect);
-
     // Get the tickmarks for the frameview.
     Vector<IntRect> tickmarks;
     scrollbar->getTickmarks(tickmarks);
 
     HIThemeTrackDrawInfo trackInfo;
     trackInfo.version = 0;
     trackInfo.kind = scrollbar->controlSize() == RegularScrollbar ? kThemeMediumScrollBar : kThemeSmallScrollBar;
     trackInfo.bounds = scrollbar->frameRect();
     trackInfo.min = 0;
     trackInfo.max = scrollbar->maximum();
@@ skipping 67 matching lines @@
             WebKit::WebRect(scrollbar->frameRect()),
             scrollbarInfo);
     }
 
     if (!canDrawDirectly)
         context->drawImageBuffer(imageBuffer.get(), scrollbar->frameRect().location());
 
     return true;
 }
 
-void ScrollbarThemeMac::paintGivenTickmarks(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& rect, const Vector<IntRect>& tickmarks)
+void ScrollbarThemeMacCommon::paintGivenTickmarks(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& rect, const Vector<IntRect>& tickmarks)
 {
     if (scrollbar->orientation() != VerticalScrollbar)
         return;
 
     if (rect.height() <= 0 || rect.width() <= 0)
         return;  // nothing to draw on.
 
     if (!tickmarks.size())
         return;
 
@@ skipping 11 matching lines @@
         // Calculate how far down (in pixels) the tick-mark should appear.
         const int yPos = rect.y() + (rect.height() * percent);
 
         // Paint.
         FloatRect tickRect(rect.x(), yPos, rect.width(), 2);
         context->fillRect(tickRect);
         context->strokeRect(tickRect, 1);
     }
 }
 
-void ScrollbarThemeMac::paintOverhangAreas(ScrollView* view, GraphicsContext* context, const IntRect& horizontalOverhangRect, const IntRect& verticalOverhangRect, const IntRect& dirtyRect)
+void ScrollbarThemeMacCommon::paintOverhangAreas(ScrollView* view, GraphicsContext* context, const IntRect& horizontalOverhangRect, const IntRect& verticalOverhangRect, const IntRect& dirtyRect)
 {
     // The extent of each shadow in pixels.
     const int kShadowSize = 4;
     // Offset of negative one pixel to make the gradient blend with the toolbar's bottom border.
     const int kToolbarShadowOffset = -1;
     const struct {
         float stop;
         Color color;
     } kShadowColors[] = {
         { 0.000, Color(0, 0, 0, 255) },
@@ skipping 101 matching lines @@
     // If both rectangles present, draw a radial gradient for the corner.
     if (hasHorizontalOverhang && hasVerticalOverhang) {
         RefPtr<Gradient> gradient = Gradient::create(shadowCornerOrigin, 0, shadowCornerOrigin, kShadowSize);
         for (unsigned i = 0; i < kNumShadowColors; i++)
             gradient->addColorStop(kShadowColors[i].stop, kShadowColors[i].color);
         context->setFillGradient(gradient);
         context->fillRect(FloatRect(shadowCornerOrigin.x() + shadowCornerOffset.x(), shadowCornerOrigin.y() + shadowCornerOffset.y(), kShadowSize, kShadowSize));
     }
 }
 
-void ScrollbarThemeMac::paintTickmarks(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& rect)
+void ScrollbarThemeMacCommon::paintTickmarks(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& rect)
 {
     // Note: This is only used for css-styled scrollbars on mac.
     if (scrollbar->orientation() != VerticalScrollbar)
         return;
 
     if (rect.height() <= 0 || rect.width() <= 0)
         return;
 
     Vector<IntRect> tickmarks;
     scrollbar->getTickmarks(tickmarks);
     if (!tickmarks.size())
         return;
 
     // Inset a bit.
     IntRect tickmarkTrackRect = rect;
     tickmarkTrackRect.setX(tickmarkTrackRect.x() + 1);
     tickmarkTrackRect.setWidth(tickmarkTrackRect.width() - 2);
     paintGivenTickmarks(context, scrollbar, tickmarkTrackRect, tickmarks);
 }
 
-void ScrollbarThemeMac::paintTrackBackground(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& rect) {
+void ScrollbarThemeMacOverlayAPI::paintTrackBackground(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& rect) {
     ASSERT(isScrollbarOverlayAPIAvailable());
 
     GraphicsContextStateSaver stateSaver(*context);
     context->translate(rect.x(), rect.y());
     LocalCurrentGraphicsContext localContext(context);
 
     CGRect frameRect = scrollbar->frameRect();
     ScrollbarPainter scrollbarPainter = painterForScrollbar(scrollbar);
     [scrollbarPainter setEnabled:scrollbar->enabled()];
     [scrollbarPainter setBoundsSize: NSSizeFromCGSize(frameRect.size)];
 
     NSRect trackRect = NSMakeRect(0, 0, frameRect.size.width, frameRect.size.height);
     [scrollbarPainter drawKnobSlotInRect:trackRect highlight:NO];
 }
 
-void ScrollbarThemeMac::paintThumb(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& rect) {
+void ScrollbarThemeMacOverlayAPI::paintThumb(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& rect) {
     ASSERT(isScrollbarOverlayAPIAvailable());
 
     GraphicsContextStateSaver stateSaver(*context);
     context->translate(rect.x(), rect.y());
     LocalCurrentGraphicsContext localContext(context);
 
     ScrollbarPainter scrollbarPainter = painterForScrollbar(scrollbar);
     CGRect frameRect = scrollbar->frameRect();
     [scrollbarPainter setEnabled:scrollbar->enabled()];
     [scrollbarPainter setBoundsSize:NSSizeFromCGSize(rect.size())];
     [scrollbarPainter setDoubleValue:0];
     [scrollbarPainter setKnobProportion:1];
     if (scrollbar->enabled())
         [scrollbarPainter drawKnob];
 
     // If this state is not set, then moving the cursor over the scrollbar area will only cause the
     // scrollbar to engorge when moved over the top of the scrollbar area.
     [scrollbarPainter setBoundsSize: NSSizeFromCGSize(scrollbar->frameRect().size())];
 }
 
-ScrollbarThemeMac::ScrollbarThemeMac()
+ScrollbarThemeMacCommon::ScrollbarThemeMacCommon()
 {
     static bool initialized;
     if (!initialized) {
         initialized = true;
-        gButtonPlacement = isScrollbarOverlayAPIAvailable() ? ScrollbarButtonsNone : ScrollbarButtonsDoubleEnd;
         [WebScrollbarPrefsObserver registerAsObserver];
         preferencesChanged();
     }
 
     // Load the linen pattern image used for overhang drawing.
     RefPtr<Image> patternImage = Image::loadPlatformResource("overhangPattern");
     m_overhangPattern = Pattern::create(patternImage, true, true);
 }
 
-ScrollbarThemeMac::~ScrollbarThemeMac()
+ScrollbarThemeMacCommon::~ScrollbarThemeMacCommon()
 {
 }
 
-void ScrollbarThemeMac::preferencesChanged()
+void ScrollbarThemeMacCommon::preferencesChanged()
 {
     NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
     [defaults synchronize];
-    updateArrowPlacement();
+    updateButtonPlacement();
     gInitialButtonDelay = [defaults floatForKey:@"NSScrollerButtonDelay"];
     gAutoscrollButtonDelay = [defaults floatForKey:@"NSScrollerButtonPeriod"];
     gJumpOnTrackClick = [defaults boolForKey:@"AppleScrollerPagingBehavior"];
 }
 
-int ScrollbarThemeMac::scrollbarThickness(ScrollbarControlSize controlSize)
+int ScrollbarThemeMacOverlayAPI::scrollbarThickness(ScrollbarControlSize controlSize)
 {
-    if (isScrollbarOverlayAPIAvailable()) {
-        ScrollbarPainter scrollbarPainter = [NSClassFromString(@"NSScrollerImp") scrollerImpWithStyle:recommendedScrollerStyle() controlSize:controlSize horizontal:NO replacingScrollerImp:nil];
-        if (supportsExpandedScrollbars())
-            [scrollbarPainter setExpanded:YES];
-        return [scrollbarPainter trackBoxWidth];
-    } else
-        return cScrollbarThickness[controlSize];
+    ScrollbarPainter scrollbarPainter = [NSClassFromString(@"NSScrollerImp") scrollerImpWithStyle:recommendedScrollerStyle() controlSize:controlSize horizontal:NO replacingScrollerImp:nil];
+    if (supportsExpandedScrollbars())
+        [scrollbarPainter setExpanded:YES];
+    return [scrollbarPainter trackBoxWidth];
 }
 
-bool ScrollbarThemeMac::usesOverlayScrollbars() const
+int ScrollbarThemeMacNonOverlayAPI::scrollbarThickness(ScrollbarControlSize controlSize)
 {
-    if (isScrollbarOverlayAPIAvailable())
-        return recommendedScrollerStyle() == NSScrollerStyleOverlay;
-    else
-        return false;
+    return cScrollbarThickness[controlSize];
 }
 
-void ScrollbarThemeMac::updateScrollbarOverlayStyle(ScrollbarThemeClient* scrollbar)
+bool ScrollbarThemeMacOverlayAPI::usesOverlayScrollbars() const
+{
+    return recommendedScrollerStyle() == NSScrollerStyleOverlay;
+}
+
+void ScrollbarThemeMacOverlayAPI::updateScrollbarOverlayStyle(ScrollbarThemeClient* scrollbar)
 {
     ScrollbarPainter painter = painterForScrollbar(scrollbar);
     switch (scrollbar->scrollbarOverlayStyle()) {
     case ScrollbarOverlayStyleDefault:
         [painter setKnobStyle:NSScrollerKnobStyleDefault];
         break;
     case ScrollbarOverlayStyleDark:
         [painter setKnobStyle:NSScrollerKnobStyleDark];
         break;
     case ScrollbarOverlayStyleLight:
         [painter setKnobStyle:NSScrollerKnobStyleLight];
         break;
     }
 }
 
-double ScrollbarThemeMac::initialAutoscrollTimerDelay()
+double ScrollbarThemeMacCommon::initialAutoscrollTimerDelay()
 {
     return gInitialButtonDelay;
 }
 
-double ScrollbarThemeMac::autoscrollTimerDelay()
+double ScrollbarThemeMacCommon::autoscrollTimerDelay()
 {
     return gAutoscrollButtonDelay;
 }
+
+ScrollbarButtonsPlacement ScrollbarThemeMacOverlayAPI::buttonsPlacement() const
+{
+    return ScrollbarButtonsNone;
+}
     
-ScrollbarButtonsPlacement ScrollbarThemeMac::buttonsPlacement() const
+ScrollbarButtonsPlacement ScrollbarThemeMacNonOverlayAPI::buttonsPlacement() const
 {
     return gButtonPlacement;
 }
 
-bool ScrollbarThemeMac::hasButtons(ScrollbarThemeClient* scrollbar)
+bool ScrollbarThemeMacNonOverlayAPI::hasButtons(ScrollbarThemeClient* scrollbar)
 {
     return scrollbar->enabled() && buttonsPlacement() != ScrollbarButtonsNone
              && (scrollbar->orientation() == HorizontalScrollbar
              ? scrollbar->width()
              : scrollbar->height()) >= 2 * (cRealButtonLength[scrollbar->controlSize()] - cButtonHitInset[scrollbar->controlSize()]);
 }
 
-bool ScrollbarThemeMac::hasThumb(ScrollbarThemeClient* scrollbar)
+bool ScrollbarThemeMacOverlayAPI::hasThumb(ScrollbarThemeClient* scrollbar)
 {
-    int minLengthForThumb;
-    if (isScrollbarOverlayAPIAvailable()) {
-        ScrollbarPainter painter = painterForScrollbar(scrollbar);
-        minLengthForThumb = [painter knobMinLength] + [painter trackOverlapEndInset] + [painter knobOverlapEndInset]
-            + 2 * ([painter trackEndInset] + [painter knobEndInset]);
-    } else
-        minLengthForThumb = 2 * cButtonInset[scrollbar->controlSize()] + cThumbMinLength[scrollbar->controlSize()] + 1;
-    return scrollbar->enabled() && (scrollbar->orientation() == HorizontalScrollbar ? 
-             scrollbar->width() : 
+    ScrollbarPainter painter = painterForScrollbar(scrollbar);
+    int minLengthForThumb = [painter knobMinLength] + [painter trackOverlapEndInset] + [painter knobOverlapEndInset]
+        + 2 * ([painter trackEndInset] + [painter knobEndInset]);
+    return scrollbar->enabled() && (scrollbar->orientation() == HorizontalScrollbar ?
+             scrollbar->width() :
              scrollbar->height()) >= minLengthForThumb;
 }
 
+bool ScrollbarThemeMacNonOverlayAPI::hasThumb(ScrollbarThemeClient* scrollbar)
+{
+    int minLengthForThumb = 2 * cButtonInset[scrollbar->controlSize()] + cThumbMinLength[scrollbar->controlSize()] + 1;
+    return scrollbar->enabled() && (scrollbar->orientation() == HorizontalScrollbar ?
+             scrollbar->width() :
+             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()));
     }
 
     return paintRect;
 }
 
-IntRect ScrollbarThemeMac::backButtonRect(ScrollbarThemeClient* scrollbar, ScrollbarPart part, bool painting)
+IntRect ScrollbarThemeMacOverlayAPI::backButtonRect(ScrollbarThemeClient* scrollbar, ScrollbarPart part, bool painting)
+{
+    ASSERT(buttonsPlacement() == ScrollbarButtonsNone);
+    return IntRect();
+}
+
+IntRect ScrollbarThemeMacNonOverlayAPI::backButtonRect(ScrollbarThemeClient* scrollbar, ScrollbarPart part, bool painting)
 {
     IntRect result;
     
     if (part == BackButtonStartPart && (buttonsPlacement() == ScrollbarButtonsNone || buttonsPlacement() == ScrollbarButtonsDoubleEnd))
         return result;
     
     if (part == BackButtonEndPart && (buttonsPlacement() == ScrollbarButtonsNone || buttonsPlacement() == ScrollbarButtonsDoubleStart || buttonsPlacement() == ScrollbarButtonsSingle))
         return result;
         
     int thickness = scrollbarThickness(scrollbar->controlSize());
@@ skipping 13 matching lines @@
     } else {
         int start = part == BackButtonStartPart ? scrollbar->y() : scrollbar->y() + scrollbar->height() - cOuterButtonLength[scrollbar->controlSize()] - cButtonLength[scrollbar->controlSize()];
         result = IntRect(scrollbar->x(), start, thickness, cButtonLength[scrollbar->controlSize()]);
     }
     
     if (painting)
         return buttonRepaintRect(result, scrollbar->orientation(), scrollbar->controlSize(), part == BackButtonStartPart);
     return result;
 }
 
-IntRect ScrollbarThemeMac::forwardButtonRect(ScrollbarThemeClient* scrollbar, ScrollbarPart part, bool painting)
+IntRect ScrollbarThemeMacOverlayAPI::forwardButtonRect(ScrollbarThemeClient* scrollbar, ScrollbarPart part, bool painting)
+{
+    ASSERT(buttonsPlacement() == ScrollbarButtonsNone);
+    return IntRect();
+}
+
+IntRect ScrollbarThemeMacNonOverlayAPI::forwardButtonRect(ScrollbarThemeClient* scrollbar, ScrollbarPart part, bool painting)
 {
     IntRect result;
     
     if (part == ForwardButtonEndPart && (buttonsPlacement() == ScrollbarButtonsNone || buttonsPlacement() == ScrollbarButtonsDoubleStart))
         return result;
     
     if (part == ForwardButtonStartPart && (buttonsPlacement() == ScrollbarButtonsNone || buttonsPlacement() == ScrollbarButtonsDoubleEnd || buttonsPlacement() == ScrollbarButtonsSingle))
         return result;
         
     int thickness = scrollbarThickness(scrollbar->controlSize());
@@ skipping 19 matching lines @@
         result = IntRect(start, scrollbar->y(), buttonLength, thickness);
     } else {
         int start = part == ForwardButtonEndPart ? scrollbar->y() + scrollbar->height() - buttonLength : scrollbar->y() + outerButtonLength;
         result = IntRect(scrollbar->x(), start, thickness, buttonLength);
     }
     if (painting)
         return buttonRepaintRect(result, scrollbar->orientation(), scrollbar->controlSize(), part == ForwardButtonStartPart);
     return result;
 }
 
-IntRect ScrollbarThemeMac::trackRect(ScrollbarThemeClient* scrollbar, bool painting)
+IntRect ScrollbarThemeMacOverlayAPI::trackRect(ScrollbarThemeClient* scrollbar, bool painting)
+{
+    ASSERT(!hasButtons(scrollbar));
+    return scrollbar->frameRect();
+}
+
+IntRect ScrollbarThemeMacNonOverlayAPI::trackRect(ScrollbarThemeClient* scrollbar, bool painting)
 {
     if (painting || !hasButtons(scrollbar))
         return scrollbar->frameRect();
     
     IntRect result;
     int thickness = scrollbarThickness(scrollbar->controlSize());
     int startWidth = 0;
     int endWidth = 0;
     int outerButtonLength = cOuterButtonLength[scrollbar->controlSize()];
     int buttonLength = cButtonLength[scrollbar->controlSize()];
@@ skipping 16 matching lines @@
         default:
             break;
     }
     
     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 ScrollbarThemeMac::minimumThumbLength(ScrollbarThemeClient* scrollbar)
+int ScrollbarThemeMacOverlayAPI::minimumThumbLength(ScrollbarThemeClient* scrollbar)
 {
-    if (isScrollbarOverlayAPIAvailable()) {
-        return [painterForScrollbar(scrollbar) knobMinLength];
-    } else {
-        return cThumbMinLength[scrollbar->controlSize()];
-    }
+    return [painterForScrollbar(scrollbar) knobMinLength];
 }
 
-bool ScrollbarThemeMac::shouldCenterOnThumb(ScrollbarThemeClient*, const PlatformMouseEvent& evt)
+int ScrollbarThemeMacNonOverlayAPI::minimumThumbLength(ScrollbarThemeClient* scrollbar)
+{
+    return cThumbMinLength[scrollbar->controlSize()];
+}
+
+bool ScrollbarThemeMacCommon::shouldCenterOnThumb(ScrollbarThemeClient*, const PlatformMouseEvent& evt)
 {
     if (evt.button() != LeftButton)
         return false;
     if (gJumpOnTrackClick)
         return !evt.altKey();
     return evt.altKey();
 }
 
-bool ScrollbarThemeMac::shouldDragDocumentInsteadOfThumb(ScrollbarThemeClient*, const PlatformMouseEvent& event)
+bool ScrollbarThemeMacCommon::shouldDragDocumentInsteadOfThumb(ScrollbarThemeClient*, const PlatformMouseEvent& event)
 {
     return event.altKey();
 }
 
-int ScrollbarThemeMac::scrollbarPartToHIPressedState(ScrollbarPart part)
+int ScrollbarThemeMacCommon::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;
     }
 }
 
-void ScrollbarThemeMac::updateEnabledState(ScrollbarThemeClient* scrollbar)
+void ScrollbarThemeMacOverlayAPI::updateEnabledState(ScrollbarThemeClient* scrollbar)
 {
-    if (isScrollbarOverlayAPIAvailable())
-        [painterForScrollbar(scrollbar) setEnabled:scrollbar->enabled()];
+    [painterForScrollbar(scrollbar) setEnabled:scrollbar->enabled()];
 }
 
 } // namespace WebCore