Move all descendant-dependent flags into the same tree walk.

third_party/WebKit/Source/core/paint/PaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 50 matching lines @@
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutTreeAsText.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutPartItem.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/layout/svg/LayoutSVGResourceClipper.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/page/Page.h"
+#include "core/page/scrolling/RootScrollerController.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/paint/BoxReflectionUtils.h"
 #include "core/paint/FilterEffectBuilder.h"
 #include "core/paint/ObjectPaintInvalidator.h"
 #include "core/paint/PaintTiming.h"
 #include "platform/LengthFunctions.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/FloatPoint3D.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/TransformState.h"
@@ skipping 53 matching lines @@
       m_hasVisibleContent(false),
       m_needsDescendantDependentFlagsUpdate(true),
       m_hasVisibleDescendant(false),
 #if DCHECK_IS_ON()
       m_needsPositionUpdate(true),
 #endif
       m_is3DTransformedDescendantDirty(true),
       m_has3DTransformedDescendant(false),
       m_containsDirtyOverlayScrollbars(false),
       m_needsAncestorDependentCompositingInputsUpdate(true),
-      m_needsDescendantDependentCompositingInputsUpdate(true),
       m_childNeedsCompositingInputsUpdate(true),
       m_hasCompositingDescendant(false),
       m_isAllScrollingContentComposited(false),
       m_shouldIsolateCompositedDescendants(false),
       m_lostGroupedMapping(false),
       m_needsRepaint(false),
       m_previousPaintResult(FullyPainted),
       m_needsPaintPhaseDescendantOutlines(false),
       m_previousPaintPhaseDescendantOutlinesWasEmpty(false),
       m_needsPaintPhaseFloat(false),
@@ skipping 512 matching lines @@
       // negative z-index descendants into an ancestor's GraphicsLayer.
       m_isAllScrollingContentComposited = false;
       return;
     }
   }
 }
 
 void PaintLayer::updateDescendantDependentFlags() {
   if (m_needsDescendantDependentFlagsUpdate) {
     m_hasVisibleDescendant = false;
+    m_hasNonIsolatedDescendantWithBlendMode = false;
+    m_hasDescendantWithClipPath = false;
+    m_hasRootScrollerAsDescendant = false;
 
     for (PaintLayer* child = firstChild(); child;
          child = child->nextSibling()) {
       child->updateDescendantDependentFlags();
 
       if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
         m_hasVisibleDescendant = true;
+
+      m_hasNonIsolatedDescendantWithBlendMode |=
+          (!child->stackingNode()->isStackingContext() &&
+           child->hasNonIsolatedDescendantWithBlendMode()) ||
+          child->layoutObject()->styleRef().hasBlendMode();
+
+      m_hasDescendantWithClipPath |= child->hasDescendantWithClipPath() ||
+                                     child->layoutObject()->hasClipPath();
+
+      m_hasRootScrollerAsDescendant |= child->hasRootScrollerAsDescendant() ||
+                                       (child ==
+                                        child->layoutObject()
+                                            ->document()
+                                            .rootScrollerController()
+                                            ->rootScrollerPaintLayer());
     }
 
     m_needsDescendantDependentFlagsUpdate = false;
   }
 
   bool previouslyHasVisibleContent = m_hasVisibleContent;
   if (layoutObject()->style()->visibility() == EVisibility::Visible) {
     m_hasVisibleContent = true;
   } else {
     // layer may be hidden but still have some visible content, check for this
@@ skipping 17 matching lines @@
           if (r == layoutObject())
             r = 0;
         } while (r && !r->nextSibling());
         if (r)
           r = r->nextSibling();
       }
     }
   }
 
   if (hasVisibleContent() != previouslyHasVisibleContent) {
-    setNeedsCompositingInputsUpdate();
+    setNeedsCompositingInputsUpdateInternal();
     // We need to tell m_layoutObject to recheck its rect because we
     // pretend that invisible LayoutObjects have 0x0 rects. Changing
     // visibility therefore changes our rect and we need to visit
     // this LayoutObject during the invalidateTreeIfNeeded walk.
     m_layoutObject->setMayNeedPaintInvalidation();
   }
 }
 
 void PaintLayer::dirty3DTransformedDescendantStatus() {
   PaintLayerStackingNode* stackingNode =
@@ skipping 251 matching lines @@
   for (PaintLayer* curr = compositingContainer(); curr;
        curr = curr->compositingContainer()) {
     if (curr->isPaintInvalidationContainer())
       return curr;
   }
 
   return nullptr;
 }
 
 void PaintLayer::setNeedsCompositingInputsUpdate() {
+  setNeedsCompositingInputsUpdateInternal();
+
+  // TODO(chrishtr): This is a bit of a heavy hammer, because not all
+  // things which require compositing inputs update require a descendant-
+  // dependent flags udpate. Reduce call sites after SPv2 launch allows
+  /// removal of CompositingInputsUpdater.
+  markAncestorChainForDescendantDependentFlagsUpdate();
+}
+
+void PaintLayer::setNeedsCompositingInputsUpdateInternal() {
   m_needsAncestorDependentCompositingInputsUpdate = true;
-  m_needsDescendantDependentCompositingInputsUpdate = true;
 
   for (PaintLayer* current = this;
        current && !current->m_childNeedsCompositingInputsUpdate;
        current = current->parent())
     current->m_childNeedsCompositingInputsUpdate = true;
 
   compositor()->setNeedsCompositingUpdate(
       CompositingUpdateAfterCompositingInputChange);
 }
 
 void PaintLayer::updateAncestorDependentCompositingInputs(
     const AncestorDependentCompositingInputs& compositingInputs,
     bool hasAncestorWithClipPath) {
   m_ancestorDependentCompositingInputs =
       makeUnique<AncestorDependentCompositingInputs>(compositingInputs);
   m_hasAncestorWithClipPath = hasAncestorWithClipPath;
   m_needsAncestorDependentCompositingInputsUpdate = false;
 }
 
-void PaintLayer::updateDescendantDependentCompositingInputs(
-    bool hasDescendantWithClipPath,
-    bool hasNonIsolatedDescendantWithBlendMode,
-    bool hasRootScrollerAsDescendant) {
-  m_hasDescendantWithClipPath = hasDescendantWithClipPath;
-  m_hasNonIsolatedDescendantWithBlendMode =
-      hasNonIsolatedDescendantWithBlendMode;
-  m_hasRootScrollerAsDescendant = hasRootScrollerAsDescendant;
-  m_needsDescendantDependentCompositingInputsUpdate = false;
-}
-
 void PaintLayer::didUpdateCompositingInputs() {
   DCHECK(!needsCompositingInputsUpdate());
   m_childNeedsCompositingInputsUpdate = false;
   if (m_scrollableArea)
     m_scrollableArea->updateNeedsCompositedScrolling();
 }
 
 bool PaintLayer::hasNonIsolatedDescendantWithBlendMode() const {
-  DCHECK(!m_needsDescendantDependentCompositingInputsUpdate);
   if (m_hasNonIsolatedDescendantWithBlendMode)
     return true;
   if (layoutObject()->isSVGRoot())
     return toLayoutSVGRoot(layoutObject())->hasNonIsolatedBlendingDescendants();
   return false;
 }
 
 void PaintLayer::setCompositingReasons(CompositingReasons reasons,
                                        CompositingReasons mask) {
   CompositingReasons oldReasons =
@@ skipping 2164 matching lines @@
 #endif
 
 DisableCompositingQueryAsserts::DisableCompositingQueryAsserts()
     : m_disabler(&gCompositingQueryMode, CompositingQueriesAreAllowed) {}
 
 }  // namespace blink
 
 #ifndef NDEBUG
 // FIXME: Rename?
 void showLayerTree(const blink::PaintLayer* layer) {
+  blink::DisableCompositingQueryAsserts disabler;
   if (!layer) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
 
   if (blink::LocalFrame* frame = layer->layoutObject()->frame()) {
     WTF::String output = externalRepresentation(
         frame,
         blink::LayoutAsTextShowAllLayers | blink::LayoutAsTextShowLayerNesting |
             blink::LayoutAsTextShowCompositedLayers |
             blink::LayoutAsTextShowAddresses |
             blink::LayoutAsTextShowIDAndClass |
             blink::LayoutAsTextDontUpdateLayout |
             blink::LayoutAsTextShowLayoutState,
         layer);
     LOG(INFO) << output.utf8().data();
   }
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif