Changeset 132504 in webkit

Timestamp:

Oct 25, 2012, 11:08:21 AM (12 years ago)

Author:

Simon Fraser

Message:

r132427 changed the tiling behavior of tiled layer TileCaches as well as the page tile cache
​https://bugs.webkit.org/show_bug.cgi?id=100323

Reviewed by Anders Carlsson.

r132427 assumed that TileCaches were only used for the page, and changed the tile
size behavior of all non-page TileCaches.

Fix by giving TiledBacking a new 'CoverageForSlowScrolling' flag which
affects the tile size behavior.

Consolidated the two places that set TileCoverage into one, and in the process
reduced FrameView's direct communication with TiledBacking.

No new tests because we can't test tile size via tests.

• page/FrameView.cpp:

(WebCore::FrameView::didMoveOnscreen): Rely on RenderLayerCompositor to
call setIsInWindow() on the main page tile cache.
(WebCore::FrameView::willMoveOffscreen): Ditto.
(WebCore::FrameView::performPostLayoutTasks): Rather than explicitly tell
the TiledBacking that it should do stuff, just tell the compositor that
layout happened.

• platform/graphics/TiledBacking.h: New CoverageForSlowScrolling flag.
• platform/graphics/ca/mac/TileCache.mm:

(WebCore::TileCache::tileSizeForCoverageRect): Only use one big tile
if the CoverageForSlowScrolling flag is set.

• rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::RenderLayerBacking): layer->isRootLayer()
is equivalent to renderer()->isRenderView() and clearer.
(WebCore::RenderLayerBacking::tiledBacking): Call adjustTileCacheCoverage().
It would be nice to move the rest of this TiledBacking code from here somehow.
(WebCore::RenderLayerBacking::adjustTileCacheCoverage): Update the TileCoverage
flags, taking into account horizontal and vertical scrollability independently,
and whether we're in slow scrolling mode.

• rendering/RenderLayerBacking.h:

(RenderLayerBacking):

• rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::frameViewDidLayout): Have the page
tiled backing update it's coverage flags.
(WebCore::RenderLayerCompositor::pageTiledBacking): Utility function.
(WebCore::RenderLayerCompositor::didMoveOnscreen): Moved from FrameView.
(WebCore::RenderLayerCompositor::willMoveOffscreen): Ditto.

• rendering/RenderLayerCompositor.h:

(RenderLayerCompositor):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• page/FrameView.cpp (modified) (3 diffs)
• platform/graphics/TiledBacking.h (modified) (1 diff)
• platform/graphics/ca/mac/TileCache.mm (modified) (1 diff)
• rendering/RenderLayerBacking.cpp (modified) (3 diffs)
• rendering/RenderLayerBacking.h (modified) (2 diffs)
• rendering/RenderLayerCompositor.cpp (modified) (3 diffs)
• rendering/RenderLayerCompositor.h (modified) (3 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-10-25  Simon Fraser  <simon.fraser@apple.com>
+
+        r132427 changed the tiling behavior of tiled layer TileCaches as well as the page tile cache
+        https://bugs.webkit.org/show_bug.cgi?id=100323
+
+        Reviewed by Anders Carlsson.
+
+        r132427 assumed that TileCaches were only used for the page, and changed the tile
+        size behavior of all non-page TileCaches.
+        
+        Fix by giving TiledBacking a new 'CoverageForSlowScrolling' flag which
+        affects the tile size behavior.
+        
+        Consolidated the two places that set TileCoverage into one, and in the process
+        reduced FrameView's direct communication with TiledBacking.
+
+        No new tests because we can't test tile size via tests.
+
+        * page/FrameView.cpp:
+        (WebCore::FrameView::didMoveOnscreen): Rely on RenderLayerCompositor to
+        call setIsInWindow() on the main page tile cache.
+        (WebCore::FrameView::willMoveOffscreen): Ditto.
+        (WebCore::FrameView::performPostLayoutTasks): Rather than explicitly tell
+        the TiledBacking that it should do stuff, just tell the compositor that
+        layout happened.
+        * platform/graphics/TiledBacking.h: New CoverageForSlowScrolling flag.
+        * platform/graphics/ca/mac/TileCache.mm:
+        (WebCore::TileCache::tileSizeForCoverageRect): Only use one big tile
+        if the CoverageForSlowScrolling flag is set.
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::RenderLayerBacking): layer->isRootLayer()
+        is equivalent to renderer()->isRenderView() and clearer.
+        (WebCore::RenderLayerBacking::tiledBacking): Call adjustTileCacheCoverage().
+        It would be nice to move the rest of this TiledBacking code from here somehow.
+        (WebCore::RenderLayerBacking::adjustTileCacheCoverage): Update the TileCoverage
+        flags, taking into account horizontal and vertical scrollability independently,
+        and whether we're in slow scrolling mode.
+        * rendering/RenderLayerBacking.h:
+        (RenderLayerBacking):
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::frameViewDidLayout): Have the page
+        tiled backing update it's coverage flags.
+        (WebCore::RenderLayerCompositor::pageTiledBacking): Utility function.
+        (WebCore::RenderLayerCompositor::didMoveOnscreen): Moved from FrameView.
+        (WebCore::RenderLayerCompositor::willMoveOffscreen): Ditto.
+        * rendering/RenderLayerCompositor.h:
+        (RenderLayerCompositor):
+
 2012-10-25  Elliott Sprehn  <esprehn@chromium.org>
 

trunk/Source/WebCore/page/FrameView.cpp

@@ -932 +932 @@
 void FrameView::didMoveOnscreen()
 {
-#if USE(ACCELERATED_COMPOSITING)
-    if (TiledBacking* tiledBacking = this->tiledBacking())
-        tiledBacking->setIsInWindow(true);
-#endif
-
     if (RenderView* root = rootRenderer(this))
         root->didMoveOnscreen();
@@ -944 +939 @@
 void FrameView::willMoveOffscreen()
 {
-#if USE(ACCELERATED_COMPOSITING)
-    if (TiledBacking* tiledBacking = this->tiledBacking())
-        tiledBacking->setIsInWindow(false);
-#endif
-
     if (RenderView* root = rootRenderer(this))
         root->willMoveOffscreen();
@@ -2501 +2491 @@
 
 #if USE(ACCELERATED_COMPOSITING)
-    if (TiledBacking* tiledBacking = this->tiledBacking()) {
-        if (page) {
-            if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator()) {
-                bool shouldLimitTileCoverage = !canHaveScrollbars() || scrollingCoordinator->shouldUpdateScrollLayerPositionOnMainThread();
-                tiledBacking->setTileCoverage(shouldLimitTileCoverage ? TiledBacking::CoverageForVisibleArea : TiledBacking::CoverageForScrolling);
-            }
-        }
+    if (RenderView* root = rootRenderer(this)) {
+        if (root->usesCompositing())
+            root->compositor()->frameViewDidLayout();
     }
 #endif

trunk/Source/WebCore/platform/graphics/TiledBacking.h

@@ -44 +44 @@
         CoverageForVerticalScrolling = 1 << 0,
         CoverageForHorizontalScrolling = 1 << 1,
+        CoverageForSlowScrolling = 1 << 2, // Indicates that we expect to paint a lot on scrolling.
         CoverageForScrolling = CoverageForVerticalScrolling | CoverageForHorizontalScrolling
     };

trunk/Source/WebCore/platform/graphics/ca/mac/TileCache.mm

@@ -335 +335 @@
 IntSize TileCache::tileSizeForCoverageRect(const IntRect& coverageRect) const
 {
-    if (m_tileCoverage == CoverageForVisibleArea)
+    if (m_tileCoverage & CoverageForSlowScrolling)
         return coverageRect.size();
     return IntSize(defaultTileCacheWidth, defaultTileCacheHeight);

trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

@@ -108 +108 @@
 #endif
 {
-    if (renderer()->isRenderView()) {
+    if (layer->isRootLayer()) {
         Frame* frame = toRenderView(renderer())->frameView()->frame();
         Page* page = frame ? frame->page() : 0;
@@ -125 +125 @@
 
     if (m_usingTiledCacheLayer) {
+        TiledBacking* tiledBacking = this->tiledBacking();
         if (Page* page = renderer()->frame()->page()) {
-            if (TiledBacking* tiledBacking = m_graphicsLayer->tiledBacking()) {
-                Frame* frame = renderer()->frame();
-                tiledBacking->setIsInWindow(page->isOnscreen());
-                if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator()) {
-                    bool shouldLimitTileCoverage = !frame->view()->canHaveScrollbars() || scrollingCoordinator->shouldUpdateScrollLayerPositionOnMainThread();
-                    tiledBacking->setTileCoverage(shouldLimitTileCoverage ? TiledBacking::CoverageForVisibleArea : TiledBacking::CoverageForScrolling);
-                }
-                tiledBacking->setScrollingPerformanceLoggingEnabled(frame->settings() && frame->settings()->scrollingPerformanceLoggingEnabled());
-            }
+            Frame* frame = renderer()->frame();
+            tiledBacking->setIsInWindow(page->isOnscreen());
+            tiledBacking->setScrollingPerformanceLoggingEnabled(frame->settings() && frame->settings()->scrollingPerformanceLoggingEnabled());
+            adjustTileCacheCoverage();
         }
     }
@@ -175 +171 @@
 {
     return m_usingTiledCacheLayer && m_creatingPrimaryGraphicsLayer;
+}
+
+TiledBacking* RenderLayerBacking::tiledBacking() const
+{
+    return m_graphicsLayer->tiledBacking();
+}
+
+void RenderLayerBacking::adjustTileCacheCoverage()
+{
+    if (!m_usingTiledCacheLayer)
+        return;
+
+    TiledBacking::TileCoverage tileCoverage = TiledBacking::CoverageForVisibleArea;
+
+    // FIXME: When we use TiledBacking for overflow, this should look at RenderView scrollability.
+    Frame* frame = renderer()->frame();
+    if (frame) {
+        FrameView* frameView = frame->view();
+        if (frameView->horizontalScrollbarMode() != ScrollbarAlwaysOff)
+            tileCoverage |= TiledBacking::CoverageForHorizontalScrolling;
+
+        if (frameView->verticalScrollbarMode() != ScrollbarAlwaysOff)
+            tileCoverage |= TiledBacking::CoverageForVerticalScrolling;
+
+        if (ScrollingCoordinator* scrollingCoordinator = frame->page()->scrollingCoordinator()) {
+            if (scrollingCoordinator->shouldUpdateScrollLayerPositionOnMainThread())
+                tileCoverage |= TiledBacking::CoverageForSlowScrolling;
+        }
+    }
+
+    tiledBacking()->setTileCoverage(tileCoverage);
 }
 

trunk/Source/WebCore/rendering/RenderLayerBacking.h

@@ -40 +40 @@
 class KeyframeList;
 class RenderLayerCompositor;
+class TiledBacking;
 
 enum CompositingLayerType {
@@ -138 +139 @@
 
     bool usingTileCache() const { return m_usingTiledCacheLayer; }
-
+    TiledBacking* tiledBacking() const;
+    void adjustTileCacheCoverage();
+    
     // GraphicsLayerClient interface
     virtual bool shouldUseTileCache(const GraphicsLayer*) const OVERRIDE;

trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -1120 +1120 @@
 }
 
+void RenderLayerCompositor::frameViewDidLayout()
+{
+    RenderLayerBacking* renderViewBacking = m_renderView->layer()->backing();
+    if (renderViewBacking)
+        renderViewBacking->adjustTileCacheCoverage();
+}
+
 void RenderLayerCompositor::scrollingLayerDidChange(RenderLayer* layer)
 {
@@ -1351 +1358 @@
 }
 
+TiledBacking* RenderLayerCompositor::pageTiledBacking() const
+{
+    RenderLayerBacking* renderViewBacking = m_renderView->layer()->backing();
+    return renderViewBacking ? renderViewBacking->tiledBacking() : 0;
+}
+
 void RenderLayerCompositor::didMoveOnscreen()
 {
+    if (TiledBacking* tiledBacking = pageTiledBacking())
+        tiledBacking->setIsInWindow(true);
+
     if (!inCompositingMode() || m_rootLayerAttachment != RootLayerUnattached)
         return;
@@ -1362 +1378 @@
 void RenderLayerCompositor::willMoveOffscreen()
 {
+    if (TiledBacking* tiledBacking = pageTiledBacking())
+        tiledBacking->setIsInWindow(false);
+
     if (!inCompositingMode() || m_rootLayerAttachment == RootLayerUnattached)
         return;

trunk/Source/WebCore/rendering/RenderLayerCompositor.h

@@ -43 +43 @@
 class RenderVideo;
 #endif
+class TiledBacking;
 
 enum CompositingUpdateType {
@@ -196 +197 @@
     void frameViewDidChangeSize();
     void frameViewDidScroll();
+    void frameViewDidLayout();
 
     void scrollingLayerDidChange(RenderLayer*);
@@ -294 +296 @@
     
     Page* page() const;
+    TiledBacking* pageTiledBacking() const;
 
     GraphicsLayerFactory* graphicsLayerFactory() const;