Refactor fixed layout mode

Source/core/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 31 matching lines @@
     : m_horizontalScrollbarMode(ScrollbarAuto)
     , m_verticalScrollbarMode(ScrollbarAuto)
     , m_horizontalScrollbarLock(false)
     , m_verticalScrollbarLock(false)
     , m_canBlitOnScroll(true)
     , m_scrollbarsAvoidingResizer(0)
     , m_scrollbarsSuppressed(false)
     , m_inUpdateScrollbars(false)
     , m_updateScrollbarsPass(0)
     , m_drawPanScrollIcon(false)
-    , m_useFixedLayout(false)
     , m_paintsEntireContents(false)
     , m_clipsRepaints(true)
 {
 }
 
 ScrollView::~ScrollView()
 {
 }
 
 void ScrollView::addChild(PassRefPtr<Widget> prpChild)
@@ skipping 116 matching lines @@
 void ScrollView::setPaintsEntireContents(bool paintsEntireContents)
 {
     m_paintsEntireContents = paintsEntireContents;
 }
 
 void ScrollView::setClipsRepaints(bool clipsRepaints)
 {
     m_clipsRepaints = clipsRepaints;
 }
 
-IntSize ScrollView::unscaledVisibleContentSize(VisibleContentRectIncludesScrollbars scrollbarInclusion) const
+IntSize ScrollView::unscaledVisibleContentSize(IncludeScrollbarsInRect scrollbarInclusion) const
+{
+    return scrollbarInclusion == ExcludeScrollbars ? excludeScrollbars(frameRect().size()) : frameRect().size();
+}
+
+IntSize ScrollView::excludeScrollbars(const IntSize& size) const
 {
     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;
-    }
+    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));
+    return IntSize(max(0, size.width() - verticalScrollbarWidth),
+        max(0, size.height() - horizontalScrollbarHeight));
+
 }
 
-IntRect ScrollView::visibleContentRect(VisibleContentRectIncludesScrollbars scollbarInclusion) const
+IntRect ScrollView::visibleContentRect(IncludeScrollbarsInRect scollbarInclusion) const
 {
     FloatSize visibleContentSize = unscaledVisibleContentSize(scollbarInclusion);
     visibleContentSize.scale(1 / visibleContentScaleFactor());
     return IntRect(IntPoint(m_scrollOffset), expandedIntSize(visibleContentSize));
 }
 
-IntSize ScrollView::layoutSize(VisibleContentRectIncludesScrollbars scrollbarInclusion) const
-{
-    return m_fixedLayoutSize.isZero() || !m_useFixedLayout ? unscaledVisibleContentSize(scrollbarInclusion) : m_fixedLayoutSize;
-}
-
-IntSize ScrollView::fixedLayoutSize() const
-{
-    return m_fixedLayoutSize;
-}
-
-void ScrollView::setFixedLayoutSize(const IntSize& newSize)
-{
-    if (fixedLayoutSize() == newSize)
-        return;
-    m_fixedLayoutSize = newSize;
-    updateScrollbars(scrollOffset());
-    if (m_useFixedLayout)
-        contentsResized();
-}
-
-bool ScrollView::useFixedLayout() const
-{
-    return m_useFixedLayout;
-}
-
-void ScrollView::setUseFixedLayout(bool enable)
-{
-    if (useFixedLayout() == enable)
-        return;
-    m_useFixedLayout = enable;
-    updateScrollbars(scrollOffset());
-    contentsResized();
-}
-
 IntSize ScrollView::contentsSize() const
 {
     return m_contentsSize;
 }
 
 void ScrollView::setContentsSize(const IntSize& newSize)
 {
     if (contentsSize() == newSize)
         return;
     m_contentsSize = newSize;
@@ skipping 105 matching lines @@
 void ScrollView::updateScrollbars(const IntSize& desiredOffset)
 {
     if (m_inUpdateScrollbars)
         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();
+        scrollbarExistenceDidChange();
         m_inUpdateScrollbars = false;
     }
 
     IntRect oldScrollCornerRect = scrollCornerRect();
 
     bool hasHorizontalScrollbar = m_horizontalScrollbar;
     bool hasVerticalScrollbar = m_verticalScrollbar;
 
     bool newHasHorizontalScrollbar = hasHorizontalScrollbar;
     bool newHasVerticalScrollbar = hasVerticalScrollbar;
@@ skipping 54 matching lines @@
                 ScrollableArea::setScrollOrigin(IntPoint(scrollOrigin().x() - m_verticalScrollbar->width(), scrollOrigin().y()));
             if (hasVerticalScrollbar)
                 m_verticalScrollbar->invalidate();
             setHasVerticalScrollbar(newHasVerticalScrollbar);
         }
 
         if (scrollbarExistenceChanged) {
             if (scrollbarsAreOverlay) {
                 // Synchronize status of scrollbar layers if necessary.
                 m_inUpdateScrollbars = true;
-                visibleContentsResized();
+                scrollbarExistenceDidChange();
                 m_inUpdateScrollbars = false;
             } else if (m_updateScrollbarsPass < cMaxUpdateScrollbarsPass) {
                 m_updateScrollbarsPass++;
                 contentsResized();
-                visibleContentsResized();
+                scrollbarExistenceDidChange();
                 IntSize newDocSize = contentsSize();
                 if (newDocSize == docSize) {
                     // The layout with the new scroll state had no impact on
                     // the document's overall size, so updateScrollbars didn't get called.
                     // Recur manually.
                     updateScrollbars(desiredOffset);
                 }
                 m_updateScrollbarsPass--;
             }
         }
@@ skipping 270 matching lines @@
 
 void ScrollView::setFrameRect(const IntRect& newRect)
 {
     IntRect oldRect = frameRect();
 
     if (newRect == oldRect)
         return;
 
     Widget::setFrameRect(newRect);
 
-    frameRectsChanged();
-
     updateScrollbars(scrollOffset());
 
-    if (!m_useFixedLayout && oldRect.size() != newRect.size())
-        contentsResized();
+    frameRectsChanged();
 }
 
 void ScrollView::frameRectsChanged()
 {
     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()
@@ skipping 434 matching lines @@
 int ScrollView::pageStep(ScrollbarOrientation orientation) const
 {
     int length = (orientation == HorizontalScrollbar) ? visibleWidth() : visibleHeight();
     int minPageStep = static_cast<float>(length) * minFractionToStepWhenPaging();
     int pageStep = std::max(minPageStep, length - maxOverlapBetweenPages());
 
     return std::max(pageStep, 1);
 }
 
 } // namespace WebCore