Changeset 61686 in webkit

Timestamp:

Jun 23, 2010 7:11:26 AM (14 years ago)

Author:

benjamin.poulain@nokia.com

Message:

Do not render the full frame when there is some elements with fixed positioning
​https://bugs.webkit.org/show_bug.cgi?id=33150

Reviewed by Kenneth Rohde Christiansen.

Do not render the full frame when there is some elements with fixed positioning
​https://bugs.webkit.org/show_bug.cgi?id=33150

The frame view take into acount the list of fixed object when scrolling
the view. If the number of object is lower than a certain threshold, the pixel
are blitted, and the invalidated area updated.

• page/FrameView.cpp:

(WebCore::FrameView::addFixedObject):
(WebCore::FrameView::removeFixedObject):
(WebCore::FrameView::scrollContentsFastPath):

• page/FrameView.h:
• platform/ScrollView.cpp:

(WebCore::ScrollView::scrollContents):
(WebCore::ScrollView::scrollContentsFastPath):

• platform/ScrollView.h:
• rendering/RenderLayer.cpp:

(WebCore::RenderLayer::repaintRectIncludingDescendants):

• rendering/RenderLayer.h:
• rendering/RenderObject.cpp:

(WebCore::RenderObject::styleWillChange):

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• page/FrameView.cpp (modified) (2 diffs)
• page/FrameView.h (modified) (1 diff)
• platform/ScrollView.cpp (modified) (2 diffs)
• platform/ScrollView.h (modified) (1 diff)
• rendering/RenderLayer.cpp (modified) (1 diff)
• rendering/RenderLayer.h (modified) (1 diff)
• rendering/RenderObject.cpp (modified) (2 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2010-06-23  Benjamin Poulain  <benjamin.poulain@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Do not render the full frame when there is some elements with fixed positioning
+        https://bugs.webkit.org/show_bug.cgi?id=33150
+
+        Do not render the full frame when there is some elements with fixed positioning
+        https://bugs.webkit.org/show_bug.cgi?id=33150
+
+        The frame view take into acount the list of fixed object when scrolling
+        the view. If the number of object is lower than a certain threshold, the pixel
+        are blitted, and the invalidated area updated.
+
+        * page/FrameView.cpp:
+        (WebCore::FrameView::addFixedObject):
+        (WebCore::FrameView::removeFixedObject):
+        (WebCore::FrameView::scrollContentsFastPath):
+        * page/FrameView.h:
+        * platform/ScrollView.cpp:
+        (WebCore::ScrollView::scrollContents):
+        (WebCore::ScrollView::scrollContentsFastPath):
+        * platform/ScrollView.h:
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::repaintRectIncludingDescendants):
+        * rendering/RenderLayer.h:
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::styleWillChange):
+
 2010-06-23  Mikhail Naganov  <mnaganov@chromium.org>
 

trunk/WebCore/page/FrameView.cpp

@@ -915 +915 @@
 void FrameView::addFixedObject()
 {
+    if (!m_fixedObjectCount && platformWidget())
+        setCanBlitOnScroll(false);
     ++m_fixedObjectCount;
 }
@@ -922 +924 @@
     ASSERT(m_fixedObjectCount > 0);
     --m_fixedObjectCount;
+    if (!m_fixedObjectCount)
+        setCanBlitOnScroll(!useSlowRepaints());
+}
+
+bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect)
+{
+    const size_t fixedObjectThreshold = 5;
+
+    RenderBlock::PositionedObjectsListHashSet* positionedObjects = 0;
+    if (RenderView* root = m_frame->contentRenderer())
+        positionedObjects = root->positionedObjects();
+
+    if (!positionedObjects || positionedObjects->isEmpty()) {
+        hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);
+        return true;
+    }
+
+    // Get the rects of the fixed objects visible in the rectToScroll
+    Vector<IntRect, fixedObjectThreshold> subRectToUpdate;
+    bool updateInvalidatedSubRect = true;
+    RenderBlock::PositionedObjectsListHashSet::const_iterator end = positionedObjects->end();
+    for (RenderBlock::PositionedObjectsListHashSet::const_iterator it = positionedObjects->begin(); it != end; ++it) {
+        RenderBox* renderBox = *it;
+        if (renderBox->style()->position() != FixedPosition)
+            continue;
+        IntRect updateRect = renderBox->layer()->repaintRectIncludingDescendants();
+        updateRect = contentsToWindow(updateRect);
+
+        updateRect.intersect(rectToScroll);
+        if (!updateRect.isEmpty()) {
+            if (subRectToUpdate.size() >= fixedObjectThreshold) {
+                updateInvalidatedSubRect = false;
+                break;
+            }
+            subRectToUpdate.append(updateRect);
+        }
+    }
+
+    // Scroll the view
+    if (updateInvalidatedSubRect) {
+        // 1) scroll
+        hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);
+
+        // 2) update the area of fixed objects that has been invalidated
+        size_t fixObjectsCount = subRectToUpdate.size();
+        for (size_t i = 0; i < fixObjectsCount; ++i) {
+            IntRect updateRect = subRectToUpdate[i];
+            IntRect scrolledRect = updateRect;
+            scrolledRect.move(scrollDelta);
+            updateRect.unite(scrolledRect);
+            updateRect.intersect(rectToScroll);
+            hostWindow()->invalidateContentsAndWindow(updateRect, false);
+        }
+        return true;
+    }
+
+    // the number of fixed objects exceed the threshold, we cannot use the fast path
+    return false;
 }
 

trunk/WebCore/page/FrameView.h

@@ -231 +231 @@
     // On each repaint the delay increses by this amount
     static void setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double p);
+
+protected:
+    virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect);
     
 private:

trunk/WebCore/platform/ScrollView.cpp

@@ -514 +514 @@
     if (canBlitOnScroll()) { // The main frame can just blit the WebView window
         // FIXME: Find a way to scroll subframes with this faster path
-        hostWindow()->scroll(-scrollDelta, scrollViewRect, clipRect);
+        if (!scrollContentsFastPath(-scrollDelta, scrollViewRect, clipRect))
+            hostWindow()->invalidateContentsForSlowScroll(updateRect, false);
     } else { 
        // We need to go ahead and repaint the entire backing store.  Do it now before moving the
@@ -526 +527 @@
     // Now blit the backingstore into the window which should be very fast.
     hostWindow()->invalidateWindow(IntRect(), true);
+}
+
+bool ScrollView::scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect)
+{
+    hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);
+    return true;
 }
 

trunk/WebCore/platform/ScrollView.h

@@ -259 +259 @@
     virtual void paintScrollCorner(GraphicsContext*, const IntRect& cornerRect);
 
+    // Scroll the content by blitting the pixels
+    virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect);
+
 private:
     RefPtr<Scrollbar> m_horizontalScrollbar;

trunk/WebCore/rendering/RenderLayer.cpp

@@ -377 +377 @@
 }
 
+IntRect RenderLayer::repaintRectIncludingDescendants() const
+{
+    IntRect repaintRect = m_repaintRect;
+    for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
+        repaintRect.unite(child->repaintRectIncludingDescendants());
+    return repaintRect;
+}
+
 void RenderLayer::computeRepaintRects()
 {

trunk/WebCore/rendering/RenderLayer.h

@@ -396 +396 @@
     // Return a cached repaint rect, computed relative to the layer renderer's containerForRepaint.
     IntRect repaintRect() const { return m_repaintRect; }
+    IntRect repaintRectIncludingDescendants() const;
     void computeRepaintRects();
     void updateRepaintRectsAfterScroll(bool fixed = false);

trunk/WebCore/rendering/RenderObject.cpp

@@ -1631 +1631 @@
 
     if (view()->frameView()) {
-        // FIXME: A better solution would be to only invalidate the fixed regions when scrolling.  It's overkill to
-        // prevent the entire view from blitting on a scroll.
-
         bool shouldBlitOnFixedBackgroundImage = false;
 #if ENABLE(FAST_MOBILE_SCROLLING)
@@ -1643 +1640 @@
 #endif
 
-        bool newStyleSlowScroll = newStyle && (newStyle->position() == FixedPosition
-                                                || (!shouldBlitOnFixedBackgroundImage && newStyle->hasFixedBackgroundImage()));
-        bool oldStyleSlowScroll = m_style && (m_style->position() == FixedPosition
-                                                || (!shouldBlitOnFixedBackgroundImage && m_style->hasFixedBackgroundImage()));
-
+        bool newStyleSlowScroll = newStyle && !shouldBlitOnFixedBackgroundImage && newStyle->hasFixedBackgroundImage();
+        bool oldStyleSlowScroll = m_style && !shouldBlitOnFixedBackgroundImage && m_style->hasFixedBackgroundImage();
         if (oldStyleSlowScroll != newStyleSlowScroll) {
             if (oldStyleSlowScroll)