Remove PlatformWidget references

Source/WebCore/platform/ScrollView.cpp

 /*
  * Copyright (C) 2006, 2007, 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 54 matching lines @@
 {
     platformDestroy();
 }
 
 void ScrollView::addChild(PassRefPtr<Widget> prpChild) 
 {
     Widget* child = prpChild.get();
     ASSERT(child != this && !child->parent());
     child->setParent(this);
     m_children.add(prpChild);
-    if (child->platformWidget())
-        platformAddChild(child);
 }
 
 void ScrollView::removeChild(Widget* child)
 {
     ASSERT(child->parent() == this);
     child->setParent(0);
     m_children.remove(child);
-    if (child->platformWidget())
-        platformRemoveChild(child);
 }
 
 void ScrollView::setHasHorizontalScrollbar(bool hasBar)
 {
     ASSERT(!hasBar || !avoidScrollbarCreation());
     if (hasBar && !m_horizontalScrollbar) {
         m_horizontalScrollbar = createScrollbar(HorizontalScrollbar);
         addChild(m_horizontalScrollbar.get());
         didAddHorizontalScrollbar(m_horizontalScrollbar.get());
         m_horizontalScrollbar->styleChanged();
@@ skipping 48 matching lines @@
 
     if (horizontalLock)
         setHorizontalScrollbarLock();
 
     if (verticalLock)
         setVerticalScrollbarLock();
 
     if (!needsUpdate)
         return;
 
-    if (platformWidget())
-        platformSetScrollbarModes();
-    else
-        updateScrollbars(scrollOffset());
+    updateScrollbars(scrollOffset());
 }
 #endif
 
 void ScrollView::scrollbarModes(ScrollbarMode& horizontalMode, ScrollbarMode& verticalMode) const
 {
-    if (platformWidget()) {
-        platformScrollbarModes(horizontalMode, verticalMode);
-        return;
-    }
     horizontalMode = m_horizontalScrollbarMode;
     verticalMode = m_verticalScrollbarMode;
 }
 
 void ScrollView::setCanHaveScrollbars(bool canScroll)
 {
     ScrollbarMode newHorizontalMode;
     ScrollbarMode newVerticalMode;
     
     scrollbarModes(newHorizontalMode, newVerticalMode);
     
     if (canScroll && newVerticalMode == ScrollbarAlwaysOff)
         newVerticalMode = ScrollbarAuto;
     else if (!canScroll)
         newVerticalMode = ScrollbarAlwaysOff;
     
     if (canScroll && newHorizontalMode == ScrollbarAlwaysOff)
         newHorizontalMode = ScrollbarAuto;
     else if (!canScroll)
         newHorizontalMode = ScrollbarAlwaysOff;
     
     setScrollbarModes(newHorizontalMode, newVerticalMode);
 }
 
 void ScrollView::setCanBlitOnScroll(bool b)
 {
-    if (platformWidget()) {
-        platformSetCanBlitOnScroll(b);
-        return;
-    }
-
     m_canBlitOnScroll = b;
 }
 
 bool ScrollView::canBlitOnScroll() const
 {
-    if (platformWidget())
-        return platformCanBlitOnScroll();
-
     return m_canBlitOnScroll;
 }
 
 void ScrollView::setPaintsEntireContents(bool paintsEntireContents)
 {
     m_paintsEntireContents = paintsEntireContents;
 }
 
 void ScrollView::setClipsRepaints(bool clipsRepaints)
 {
     m_clipsRepaints = clipsRepaints;
 }
 
 void ScrollView::setDelegatesScrolling(bool delegatesScrolling)
 {
     if (m_delegatesScrolling == delegatesScrolling)
         return;
 
     m_delegatesScrolling = delegatesScrolling;
     delegatesScrollingDidChange();
 }
 
 IntSize ScrollView::unscaledVisibleContentSize(VisibleContentRectIncludesScrollbars scrollbarInclusion) const
 {
-    if (platformWidget())
-        return platformVisibleContentRect(scrollbarInclusion == IncludeScrollbars).size();
-
     if (!m_fixedVisibleContentRect.isEmpty())
         return m_fixedVisibleContentRect.size();
 
     int verticalScrollbarWidth = 0;
     int horizontalScrollbarHeight = 0;
 
     if (scrollbarInclusion == ExcludeScrollbars) {
         if (Scrollbar* verticalBar = verticalScrollbar())
             verticalScrollbarWidth = !verticalBar->isOverlayScrollbar() ? verticalBar->width() : 0;
         if (Scrollbar* horizontalBar = horizontalScrollbar())
             horizontalScrollbarHeight = !horizontalBar->isOverlayScrollbar() ? horizontalBar->height() : 0;
     }
 
     return IntSize(max(0, width() - verticalScrollbarWidth),
                    max(0, height() - horizontalScrollbarHeight));
 }
 
 #if !PLATFORM(GTK)
 IntRect ScrollView::visibleContentRect(VisibleContentRectIncludesScrollbars scollbarInclusion) const
 {
-    if (platformWidget())
-        return platformVisibleContentRect(scollbarInclusion == IncludeScrollbars);
-
     if (!m_fixedVisibleContentRect.isEmpty())
         return m_fixedVisibleContentRect;
 
     FloatSize visibleContentSize = unscaledVisibleContentSize(scollbarInclusion);
     visibleContentSize.scale(1 / visibleContentScaleFactor());
     return IntRect(IntPoint(m_scrollOffset), expandedIntSize(visibleContentSize));
 }
 #endif
 
 IntSize ScrollView::layoutSize() const
@@ skipping 33 matching lines @@
 IntSize ScrollView::contentsSize() const
 {
     return m_contentsSize;
 }
 
 void ScrollView::setContentsSize(const IntSize& newSize)
 {
     if (contentsSize() == newSize)
         return;
     m_contentsSize = newSize;
-    if (platformWidget())
-        platformSetContentsSize();
-    else
-        updateScrollbars(scrollOffset());
+    updateScrollbars(scrollOffset());
     updateOverhangAreas();
 }
 
 IntPoint ScrollView::maximumScrollPosition() const
 {
     IntPoint maximumOffset(contentsWidth() - visibleWidth() - scrollOrigin().x(), totalContentsSize().height() - visibleHeight() - scrollOrigin().y());
     maximumOffset.clampNegativeToZero();
     return maximumOffset;
 }
 
@@ skipping 73 matching lines @@
     if (scrollbar->orientation() == VerticalScrollbar)
         return scrollPosition().y() + scrollOrigin().y();
     return 0;
 }
 
 void ScrollView::setScrollPosition(const IntPoint& scrollPoint)
 {
     if (prohibitsScrolling())
         return;
 
-    if (platformWidget()) {
-        platformSetScrollPosition(scrollPoint);
-        return;
-    }
-
 #if USE(TILED_BACKING_STORE)
     if (delegatesScrolling()) {
         hostWindow()->delegatedScrollRequested(scrollPoint);
         return;
     }
 #endif
 
     IntPoint newScrollPosition = adjustScrollPositionWithinRange(scrollPoint);
 
     if (newScrollPosition == scrollPosition())
         return;
 
     updateScrollbars(IntSize(newScrollPosition.x(), newScrollPosition.y()));
 }
 
-bool ScrollView::scroll(ScrollDirection direction, ScrollGranularity granularity)
-{
-    if (platformWidget())
-        return platformScroll(direction, granularity);
-
-    return ScrollableArea::scroll(direction, granularity);
-}
-
 bool ScrollView::logicalScroll(ScrollLogicalDirection direction, ScrollGranularity granularity)
 {
     return scroll(logicalToPhysical(direction, isVerticalDocument(), isFlippedDocument()), granularity);
 }
 
 IntSize ScrollView::overhangAmount() const
 {
     IntSize stretch;
 
     int physicalScrollY = scrollPosition().y() + scrollOrigin().y();
     if (physicalScrollY < 0)
         stretch.setHeight(physicalScrollY);
     else if (totalContentsSize().height() && physicalScrollY > totalContentsSize().height() - visibleHeight())
         stretch.setHeight(physicalScrollY - (totalContentsSize().height() - visibleHeight()));
 
     int physicalScrollX = scrollPosition().x() + scrollOrigin().x();
     if (physicalScrollX < 0)
         stretch.setWidth(physicalScrollX);
     else if (contentsWidth() && physicalScrollX > contentsWidth() - visibleWidth())
         stretch.setWidth(physicalScrollX - (contentsWidth() - visibleWidth()));
 
     return stretch;
 }
 
 void ScrollView::windowResizerRectChanged()
 {
-    if (platformWidget())
-        return;
-
     updateScrollbars(scrollOffset());
 }
 
 static const unsigned cMaxUpdateScrollbarsPass = 2;
 
 void ScrollView::updateScrollbars(const IntSize& desiredOffset)
 {
-    if (m_inUpdateScrollbars || prohibitsScrolling() || platformWidget())
+    if (m_inUpdateScrollbars || prohibitsScrolling())
         return;
 
     // If we came in here with the view already needing a layout, then go ahead and do that
     // first.  (This will be the common case, e.g., when the page changes due to window resizing for example).
     // This layout will not re-enter updateScrollbars and does not count towards our max layout pass total.
     if (!m_scrollbarsSuppressed) {
         m_inUpdateScrollbars = true;
         visibleContentsResized();
         m_inUpdateScrollbars = false;
     }
@@ skipping 285 matching lines @@
     if (delegatesScrolling())
         return convertToContainingWindow(contentsRect);
 
     IntRect viewRect = contentsRect;
     viewRect.move(-scrollOffset() + IntSize(0, headerHeight()));
     return convertToContainingWindow(viewRect);
 }
 
 IntRect ScrollView::contentsToScreen(const IntRect& rect) const
 {
-    if (platformWidget())
-        return platformContentsToScreen(rect);
     if (!hostWindow())
         return IntRect();
     return hostWindow()->rootViewToScreen(contentsToRootView(rect));
 }
 
 IntPoint ScrollView::screenToContents(const IntPoint& point) const
 {
-    if (platformWidget())
-        return platformScreenToContents(point);
     if (!hostWindow())
         return IntPoint();
     return rootViewToContents(hostWindow()->screenToRootView(point));
 }
 
 bool ScrollView::containsScrollbarsAvoidingResizer() const
 {
     return !m_scrollbarsAvoidingResizer;
 }
 
@@ skipping 27 matching lines @@
         parent()->adjustScrollbarsAvoidingResizerCount(m_scrollbarsAvoidingResizer);
 }
 
 void ScrollView::setScrollbarsSuppressed(bool suppressed, bool repaintOnUnsuppress)
 {
     if (suppressed == m_scrollbarsSuppressed)
         return;
 
     m_scrollbarsSuppressed = suppressed;
 
-    if (platformWidget())
-        platformSetScrollbarsSuppressed(repaintOnUnsuppress);
-    else if (repaintOnUnsuppress && !suppressed) {
+    if (repaintOnUnsuppress && !suppressed) {
         if (m_horizontalScrollbar)
             m_horizontalScrollbar->invalidate();
         if (m_verticalScrollbar)
             m_verticalScrollbar->invalidate();
 
         // Invalidate the scroll corner too on unsuppress.
         invalidateRect(scrollCornerRect());
     }
 }
 
 Scrollbar* ScrollView::scrollbarAtPoint(const IntPoint& windowPoint)
 {
-    if (platformWidget())
-        return 0;
-
     IntPoint viewPoint = convertFromContainingWindow(windowPoint);
     if (m_horizontalScrollbar && m_horizontalScrollbar->shouldParticipateInHitTesting() && m_horizontalScrollbar->frameRect().contains(viewPoint))
         return m_horizontalScrollbar.get();
     if (m_verticalScrollbar && m_verticalScrollbar->shouldParticipateInHitTesting() && m_verticalScrollbar->frameRect().contains(viewPoint))
         return m_verticalScrollbar.get();
     return 0;
 }
 
 void ScrollView::setScrollbarOverlayStyle(ScrollbarOverlayStyle overlayStyle)
 {
@@ skipping 13 matching lines @@
     frameRectsChanged();
 
     updateScrollbars(scrollOffset());
 
     if (!m_useFixedLayout && oldRect.size() != newRect.size())
         contentsResized();
 }
 
 void ScrollView::frameRectsChanged()
 {
-    if (platformWidget())
-        return;
-
     HashSet<RefPtr<Widget> >::const_iterator end = m_children.end();
     for (HashSet<RefPtr<Widget> >::const_iterator current = m_children.begin(); current != end; ++current)
         (*current)->frameRectsChanged();
 }
 
 void ScrollView::clipRectChanged()
 {
     HashSet<RefPtr<Widget> >::const_iterator end = m_children.end();
     for (HashSet<RefPtr<Widget> >::const_iterator current = m_children.begin(); current != end; ++current)
         (*current)->clipRectChanged();
@@ skipping 45 matching lines @@
 }
 
 void ScrollView::repaintContentRectangle(const IntRect& rect)
 {
     IntRect paintRect = rect;
     if (clipsRepaints() && !paintsEntireContents())
         paintRect.intersect(visibleContentRect());
     if (paintRect.isEmpty())
         return;
 
-    if (platformWidget()) {
-        notifyPageThatContentAreaWillPaint();
-        platformRepaintContentRectangle(paintRect);
-        return;
-    }
-
     if (hostWindow())
         hostWindow()->invalidateContentsAndRootView(contentsToWindow(paintRect));
 }
 
 IntRect ScrollView::scrollCornerRect() const
 {
     IntRect cornerRect;
 
     if (hasOverlayScrollbars())
         return cornerRect;
@@ skipping 75 matching lines @@
 {
     static Image* panScrollIcon = Image::loadPlatformResource("panIcon").leakRef();
     IntPoint iconGCPoint = m_panScrollIconPoint;
     if (parent())
         iconGCPoint = parent()->windowToContents(iconGCPoint);
     context->drawImage(panScrollIcon, ColorSpaceDeviceRGB, iconGCPoint);
 }
 
 void ScrollView::paint(GraphicsContext* context, const IntRect& rect)
 {
-    if (platformWidget()) {
-        Widget::paint(context, rect);
-        return;
-    }
-
     if (context->paintingDisabled() && !context->updatingControlTints())
         return;
 
     notifyPageThatContentAreaWillPaint();
 
     IntRect documentDirtyRect = rect;
     if (!paintsEntireContents()) {
         IntRect visibleAreaWithoutScrollbars(location(), visibleContentRect().size());
         documentDirtyRect.intersect(visibleAreaWithoutScrollbars);
     }
@@ skipping 215 matching lines @@
                 (*it)->setParentVisible(false);
         }
         setSelfVisible(false);
     }
 
     Widget::hide();
 }
 
 bool ScrollView::isOffscreen() const
 {
-    if (platformWidget())
-        return platformIsOffscreen();
-    
-    if (!isVisible())
-        return true;
-    
-    // FIXME: Add a HostWindow::isOffscreen method here.  Since only Mac implements this method
-    // currently, we can add the method when the other platforms decide to implement this concept.
-    return false;
+    return !isVisible();
 }
 
 
 void ScrollView::addPanScrollIcon(const IntPoint& iconPosition)
 {
     if (!hostWindow())
         return;
     m_drawPanScrollIcon = true;    
     m_panScrollIconPoint = IntPoint(iconPosition.x() - panIconSizeLength / 2 , iconPosition.y() - panIconSizeLength / 2) ;
     hostWindow()->invalidateContentsAndRootView(IntRect(m_panScrollIconPoint, IntSize(panIconSizeLength, panIconSizeLength)));
 }
 
 void ScrollView::removePanScrollIcon()
 {
     if (!hostWindow())
         return;
     m_drawPanScrollIcon = false; 
     hostWindow()->invalidateContentsAndRootView(IntRect(m_panScrollIconPoint, IntSize(panIconSizeLength, panIconSizeLength)));
 }
 
 void ScrollView::setScrollOrigin(const IntPoint& origin, bool updatePositionAtAll, bool updatePositionSynchronously)
 {
     if (scrollOrigin() == origin)
         return;
 
     ScrollableArea::setScrollOrigin(origin);
 
-    if (platformWidget()) {
-        platformSetScrollOrigin(origin, updatePositionAtAll, updatePositionSynchronously);
-        return;
-    }
-    
     // Update if the scroll origin changes, since our position will be different if the content size did not change.
     if (updatePositionAtAll && updatePositionSynchronously)
         updateScrollbars(scrollOffset());
 }
 
 #if !PLATFORM(WX) && !PLATFORM(EFL)
 
 void ScrollView::platformInit()
 {
 }
 
 void ScrollView::platformDestroy()
 {
 }
 
 #endif
 
-#if !PLATFORM(WX) && !PLATFORM(QT) && !PLATFORM(MAC)
-
-void ScrollView::platformAddChild(Widget*)
-{
-}
-
-void ScrollView::platformRemoveChild(Widget*)
-{
-}
-
-#endif
-
 #if !PLATFORM(MAC)
 
 void ScrollView::platformSetScrollbarsSuppressed(bool)
 {
 }
 
 void ScrollView::platformSetScrollOrigin(const IntPoint&, bool, bool)
 {
 }
 
@@ skipping 57 matching lines @@
 }
 
 bool ScrollView::platformIsOffscreen() const
 {
     return false;
 }
 
 #endif
 
 }