Changeset 162640 in webkit

Timestamp:

Jan 23, 2014, 2:03:27 PM (11 years ago)

Author:

Antti Koivisto

Message:

Don't enable speculative tiles immediately after main load stops progressing
​https://bugs.webkit.org/show_bug.cgi?id=127507

Reviewed by Andreas Kling.

It is common for timers and events to trigger more loading after the initial main frame loading
has completed. We should delay a bit before enabling speculative tiles and keep them disabled
if loading still continues.

• page/FrameView.cpp:

(WebCore::FrameView::FrameView):
(WebCore::FrameView::adjustTiledBackingCoverage):
(WebCore::shouldEnableSpeculativeTilingDuringLoading):
(WebCore::FrameView::enableSpeculativeTilingIfNeeded):

When load progression stops wait 0.5s before enabling speculative tiles.

(WebCore::FrameView::speculativeTilingEnableTimerFired):

Don't enable speculative tiles if the progression has started again. Instead restart the timer.

• page/FrameView.h:
• rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::RenderLayerBacking):
(WebCore::computeTileCoverage):

Move the FrameView level code to FrameView (so we don't need to add a timer to every RenderLayerBacking).

• rendering/RenderLayerBacking.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• page/FrameView.cpp (modified) (3 diffs)
• page/FrameView.h (modified) (3 diffs)
• rendering/RenderLayerBacking.cpp (modified) (2 diffs)
• rendering/RenderLayerBacking.h (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2014-01-23  Antti Koivisto  <antti@apple.com>
+
+        Don't enable speculative tiles immediately after main load stops progressing
+        https://bugs.webkit.org/show_bug.cgi?id=127507
+
+        Reviewed by Andreas Kling.
+
+        It is common for timers and events to trigger more loading after the initial main frame loading
+        has completed. We should delay a bit before enabling speculative tiles and keep them disabled 
+        if loading still continues.
+
+        * page/FrameView.cpp:
+        (WebCore::FrameView::FrameView):
+        (WebCore::FrameView::adjustTiledBackingCoverage):
+        (WebCore::shouldEnableSpeculativeTilingDuringLoading):
+        (WebCore::FrameView::enableSpeculativeTilingIfNeeded):
+        
+            When load progression stops wait 0.5s before enabling speculative tiles.
+
+        (WebCore::FrameView::speculativeTilingEnableTimerFired):
+        
+            Don't enable speculative tiles if the progression has started again. Instead restart the timer.
+
+        * page/FrameView.h:
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::RenderLayerBacking):
+        (WebCore::computeTileCoverage):
+        
+            Move the FrameView level code to FrameView (so we don't need to add a timer to every RenderLayerBacking).
+
+        * rendering/RenderLayerBacking.h:
+
 2014-01-23  Antti Koivisto  <antti@apple.com>
 

trunk/Source/WebCore/page/FrameView.cpp

@@ -205 +205 @@
     , m_deferSetNeedsLayouts(0)
     , m_setNeedsLayoutWasDeferred(false)
+    , m_speculativeTilingEnabled(false)
+    , m_speculativeTilingEnableTimer(this, &FrameView::speculativeTilingEnableTimerFired)
 #if PLATFORM(IOS)
     , m_useCustomFixedPositionLayoutRect(false)
@@ -2427 +2429 @@
 void FrameView::adjustTiledBackingCoverage()
 {
+    if (!m_speculativeTilingEnabled)
+        enableSpeculativeTilingIfNeeded();
+
 #if USE(ACCELERATED_COMPOSITING)
     RenderView* renderView = this->renderView();
@@ -2434 +2439 @@
 #if PLATFORM(IOS)
     if (TileCache* tileCache = this->tileCache())
-        tileCache->setSpeculativeTileCreationEnabled(!m_frame->page()->progress().isMainLoadProgressing());
-#endif
+        tileCache->setSpeculativeTileCreationEnabled(m_speculativeTilingEnabled);
+#endif
+}
+
+static bool shouldEnableSpeculativeTilingDuringLoading(const FrameView& view)
+{
+    return view.isVisuallyNonEmpty() && !view.frame().page()->progress().isMainLoadProgressing();
+}
+
+void FrameView::enableSpeculativeTilingIfNeeded()
+{
+    ASSERT(!m_speculativeTilingEnabled);
+    if (m_wasScrolledByUser) {
+        m_speculativeTilingEnabled = true;
+        return;
+    }
+    if (!shouldEnableSpeculativeTilingDuringLoading(*this))
+        return;
+    if (m_speculativeTilingEnableTimer.isActive())
+        return;
+    // Delay enabling a bit as load completion may trigger further loading from scripts.
+    static const double speculativeTilingEnableDelay = 0.5;
+    m_speculativeTilingEnableTimer.startOneShot(speculativeTilingEnableDelay);
+}
+
+void FrameView::speculativeTilingEnableTimerFired(Timer<FrameView>&)
+{
+    if (m_speculativeTilingEnabled)
+        return;
+    m_speculativeTilingEnabled = shouldEnableSpeculativeTilingDuringLoading(*this);
+    adjustTiledBackingCoverage();
 }
 

trunk/Source/WebCore/page/FrameView.h

@@ -270 +270 @@
     void updateLayerFlushThrottlingInAllFrames();
     void adjustTiledBackingCoverage();
+    bool speculativeTilingEnabled() const { return m_speculativeTilingEnabled; }
 
 #if ENABLE(DASHBOARD_SUPPORT) || ENABLE(DRAGGABLE_REGION)
@@ -558 +559 @@
     double adjustedDeferredRepaintDelay() const;
 
+    void enableSpeculativeTilingIfNeeded();
+    void speculativeTilingEnableTimerFired(Timer<FrameView>&);
+
     bool updateEmbeddedObjects();
     void updateEmbeddedObject(RenderEmbeddedObject&);
@@ -664 +668 @@
     // Renderer to hold our custom scroll corner.
     RenderPtr<RenderScrollbarPart> m_scrollCorner;
+
+    bool m_speculativeTilingEnabled;
+    Timer<FrameView> m_speculativeTilingEnableTimer;
 
 #if PLATFORM(IOS)

trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

@@ -124 +124 @@
 #endif
     , m_backgroundLayerPaintsFixedRootBackground(false)
-    , m_didSwitchToFullTileCoverageDuringLoading(false)
 {
     Page* page = renderer().frame().page();
@@ -221 +220 @@
     TiledBacking::TileCoverage tileCoverage = TiledBacking::CoverageForVisibleArea;
     bool useMinimalTilesDuringLiveResize = frameView.inLiveResize();
-    bool useMinimalTilesDuringLoading = false;
-    // Avoid churn.
-    if (!backing->didSwitchToFullTileCoverageDuringLoading()) {
-        useMinimalTilesDuringLoading = !frameView.isVisuallyNonEmpty() || (frameView.frame().page()->progress().isMainLoadProgressing() && !frameView.wasScrolledByUser());
-        if (!useMinimalTilesDuringLoading)
-            backing->setDidSwitchToFullTileCoverageDuringLoading();
-    }
-    if (!(useMinimalTilesDuringLoading || useMinimalTilesDuringLiveResize)) {
+    if (frameView.speculativeTilingEnabled() && !useMinimalTilesDuringLiveResize) {
         bool clipsToExposedRect = !frameView.exposedRect().isInfinite();
         if (frameView.horizontalScrollbarMode() != ScrollbarAlwaysOff || clipsToExposedRect)

trunk/Source/WebCore/rendering/RenderLayerBacking.h

@@ -203 +203 @@
     double backingStoreMemoryEstimate() const;
 
-    bool didSwitchToFullTileCoverageDuringLoading() const { return m_didSwitchToFullTileCoverageDuringLoading; }
-    void setDidSwitchToFullTileCoverageDuringLoading() { m_didSwitchToFullTileCoverageDuringLoading = true; }
-
 #if ENABLE(CSS_COMPOSITING)
     void setBlendMode(BlendMode);
@@ -325 +322 @@
 #endif
     bool m_backgroundLayerPaintsFixedRootBackground;
-    bool m_didSwitchToFullTileCoverageDuringLoading;
 
     static bool m_creatingPrimaryGraphicsLayer;