Rewind the DocumentLifecycle when dirtying state

Source/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 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 58 matching lines @@
 #include "wtf/TemporaryChange.h"
 
 #ifndef NDEBUG
 #include "core/rendering/RenderTreeAsText.h"
 #endif
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
+class DeprecatedDirtyCompositingDuringCompositingUpdate {
+    WTF_MAKE_NONCOPYABLE(DeprecatedDirtyCompositingDuringCompositingUpdate);
+public:
+    DeprecatedDirtyCompositingDuringCompositingUpdate(DocumentLifecycle& lifecycle)
+        : m_lifecycle(lifecycle)
+        , m_deprecatedTransition(lifecycle.state(), DocumentLifecycle::LayoutClean)
+        , m_originalState(lifecycle.state())
+    {
+    }
+
+    ~DeprecatedDirtyCompositingDuringCompositingUpdate()
+    {
+        if (m_originalState != DocumentLifecycle::InCompositingUpdate)
+            return;
+        if (m_lifecycle.state() != m_originalState) {
+            // FIXME: It's crazy that we can trigger a style recalc from inside
+            // the compositing update, but that happens in compositing/visibility/hidden-iframe.html.
+            ASSERT(m_lifecycle.state() == DocumentLifecycle::LayoutClean || m_lifecycle.state() == DocumentLifecycle::VisualUpdatePending);
+            m_lifecycle.advanceTo(m_originalState);
+        }
+    }
+
+private:
+    DocumentLifecycle& m_lifecycle;
+    DocumentLifecycle::DeprecatedTransition m_deprecatedTransition;
+    DocumentLifecycle::State m_originalState;
+};
+
 RenderLayerCompositor::RenderLayerCompositor(RenderView& renderView)
     : m_renderView(renderView)
     , m_compositingReasonFinder(renderView)
     , m_pendingUpdateType(CompositingUpdateNone)
     , m_hasAcceleratedCompositing(true)
     , m_showRepaintCounter(false)
     , m_needsToRecomputeCompositingRequirements(false)
     , m_compositing(false)
     , m_compositingLayersNeedRebuild(false)
     , m_forceCompositingMode(false)
@@ skipping 84 matching lines @@
 bool RenderLayerCompositor::canRender3DTransforms() const
 {
     return hasAcceleratedCompositing() && m_compositingReasonFinder.has3DTransformTrigger();
 }
 
 void RenderLayerCompositor::setCompositingLayersNeedRebuild()
 {
     // FIXME: crbug,com/332248 ideally this could be merged with setNeedsCompositingUpdate().
     if (inCompositingMode())
         m_compositingLayersNeedRebuild = true;
+    if (!lifecycle().isActive())
+        return;
     page()->animator().scheduleVisualUpdate();
+    lifecycle().ensureStateAtMost(DocumentLifecycle::LayoutClean);
 }
 
 void RenderLayerCompositor::updateCompositingRequirementsState()
 {
     if (!m_needsUpdateCompositingRequirementsState)
         return;
 
     TRACE_EVENT0("blink_rendering,comp-scroll", "RenderLayerCompositor::updateCompositingRequirementsState");
 
     m_needsUpdateCompositingRequirementsState = false;
@@ skipping 63 matching lines @@
     if (m_renderView.needsLayout())
         return;
 
     if (m_forceCompositingMode && !m_compositing)
         enableCompositingMode(true);
 
     if (!m_needsToRecomputeCompositingRequirements && !m_compositing)
         return;
 
     m_pendingUpdateType = std::max(m_pendingUpdateType, updateType);
+
     page()->animator().scheduleVisualUpdate();
+    lifecycle().ensureStateAtMost(DocumentLifecycle::LayoutClean);
 }
 
 void RenderLayerCompositor::scheduleAnimationIfNeeded()
 {
     LocalFrame* localFrame = &m_renderView.frameView()->frame();
     for (LocalFrame* currentFrame = localFrame; currentFrame; currentFrame = currentFrame->tree().traverseNext(localFrame)) {
         if (currentFrame->contentRenderer()) {
             RenderLayerCompositor* childCompositor = currentFrame->contentRenderer()->compositor();
             if (childCompositor && childCompositor->hasUnresolvedDirtyBits()) {
                 m_renderView.frameView()->scheduleAnimation();
@@ skipping 148 matching lines @@
 {
     bool compositedLayerMappingChanged = false;
     bool nonCompositedReasonChanged = updateLayerIfViewportConstrained(layer);
 
     // FIXME: It would be nice to directly use the layer's compositing reason,
     // but allocateOrClearCompositedLayerMapping also gets called without having updated compositing
     // requirements fully.
     switch (compositedLayerUpdate) {
     case AllocateOwnCompositedLayerMapping:
         ASSERT(!layer->hasCompositedLayerMapping());
-        enableCompositingMode();
+        {
+            DeprecatedDirtyCompositingDuringCompositingUpdate marker(lifecycle());
+            enableCompositingMode();
+        }
 
         // If we need to repaint, do so before allocating the compositedLayerMapping
         repaintOnCompositingChange(layer);
         layer->ensureCompositedLayerMapping();
         compositedLayerMappingChanged = true;
 
         // At this time, the ScrollingCooridnator only supports the top-level frame.
         if (layer->isRootLayer() && isMainFrame()) {
             if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
                 scrollingCoordinator->frameViewRootLayerDidChange(m_renderView.frameView());
@@ skipping 1162 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore