Generalize visible descendant dirty bits to prepare for more properties.

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 113 matching lines @@
       compositingReasons(CompositingReasonNone),
       squashingDisallowedReasons(SquashingDisallowedReasonsNone),
       groupedMapping(nullptr) {}
 
 PaintLayerRareData::~PaintLayerRareData() {}
 
 PaintLayer::PaintLayer(LayoutBoxModelObject* layoutObject)
     : m_hasSelfPaintingLayerDescendant(false),
       m_hasSelfPaintingLayerDescendantDirty(false),
       m_isRootLayer(layoutObject->isLayoutView()),
-      m_isVisibleContentDirty(true),
       m_hasVisibleContent(false),
-      m_isVisibleDescendantDirty(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),
@@ skipping 19 matching lines @@
       m_next(0),
       m_first(0),
       m_last(0),
       m_staticInlinePosition(0),
       m_staticBlockPosition(0),
       m_ancestorOverflowLayer(nullptr) {
   updateStackingNode();
 
   m_isSelfPaintingLayer = shouldBeSelfPaintingLayer();
 
-  if (!layoutObject->slowFirstChild() && layoutObject->style()) {
-    m_isVisibleContentDirty = false;
-    m_hasVisibleContent =
-        layoutObject->style()->visibility() == EVisibility::Visible;
-  }
-
   updateScrollableArea();
 }
 
 PaintLayer::~PaintLayer() {
   if (m_rareData && m_rareData->resourceInfo) {
     const ComputedStyle& style = layoutObject()->styleRef();
     if (style.hasFilter())
       style.filter().removeClient(m_rareData->resourceInfo);
     if (isReferenceClipPath(style.clipPath())) {
       toReferenceClipPathOperation(style.clipPath())
@@ skipping 112 matching lines @@
 
   // FIXME(400589): We would like to do this in
   // PaintLayerScrollableArea::updateAfterLayout, but it depends on the size
   // computed by updateLayerPosition.
   if (m_scrollableArea) {
     if (ScrollAnimatorBase* scrollAnimator =
             m_scrollableArea->existingScrollAnimator())
       scrollAnimator->updateAfterLayout();
   }
 
-  // FIXME: We should be able to remove this call because we don't care about
-  // any descendant-dependent flags, but code somewhere else is reading these
-  // flags and depending on us to update them.
-  updateDescendantDependentFlags();
-
   for (PaintLayer* child = firstChild(); child; child = child->nextSibling())
     child->updateLayerPositionRecursive();
 }
 
 void PaintLayer::updateHasSelfPaintingLayerDescendant() const {
   DCHECK(m_hasSelfPaintingLayerDescendantDirty);
 
   m_hasSelfPaintingLayerDescendant = false;
 
   for (PaintLayer* child = firstChild(); child; child = child->nextSibling()) {
@@ skipping 304 matching lines @@
   // FIXME: remove this special-case code that works around the paint
   // invalidation code structure.
   layoutObject.mapToVisualRectInAncestorSpace(&paintInvalidationContainer,
                                               rect);
 
   mapRectInPaintInvalidationContainerToBacking(paintInvalidationContainer,
                                                rect);
 }
 
 void PaintLayer::dirtyVisibleContentStatus() {
-  m_isVisibleContentDirty = true;
-  if (parent())
-    parent()->dirtyAncestorChainVisibleDescendantStatus();
+  markAncestorChainForDescendantDependentFlagsUpdate();
   // Non-self-painting layers paint into their ancestor layer, and count as part
   // of the "visible contents" of the parent, so we need to dirty it.
   if (!isSelfPaintingLayer())
     parent()->dirtyVisibleContentStatus();
 }
 
-void PaintLayer::potentiallyDirtyVisibleContentStatus(EVisibility visibility) {
-  if (m_isVisibleContentDirty)
-    return;
-  if (hasVisibleContent() == (visibility == EVisibility::Visible))
-    return;
-  dirtyVisibleContentStatus();
-}
-
-void PaintLayer::dirtyAncestorChainVisibleDescendantStatus() {
+void PaintLayer::markAncestorChainForDescendantDependentFlagsUpdate() {
   for (PaintLayer* layer = this; layer; layer = layer->parent()) {
-    if (layer->m_isVisibleDescendantDirty)
+    if (layer->m_needsDescendantDependentFlagsUpdate)
       break;
-    layer->m_isVisibleDescendantDirty = true;
+    layer->m_needsDescendantDependentFlagsUpdate = true;
   }
 }
 
 // FIXME: this is quite brute-force. We could be more efficient if we were to
 // track state and update it as appropriate as changes are made in the layout
 // tree.
 void PaintLayer::updateScrollingStateAfterCompositingChange() {
   TRACE_EVENT0("blink",
                "PaintLayer::updateScrollingStateAfterCompositingChange");
   m_isAllScrollingContentComposited = true;
@@ skipping 12 matching lines @@
     } else if (!child->stackingNode()->isStackingContext()) {
       // If the child is composited, but not a stacking context, it may paint
       // negative z-index descendants into an ancestor's GraphicsLayer.
       m_isAllScrollingContentComposited = false;
       return;
     }
   }
 }
 
 void PaintLayer::updateDescendantDependentFlags() {
-  if (m_isVisibleDescendantDirty) {
+  if (m_needsDescendantDependentFlagsUpdate) {
     m_hasVisibleDescendant = false;
 
     for (PaintLayer* child = firstChild(); child;
          child = child->nextSibling()) {
       child->updateDescendantDependentFlags();
 
       if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
         m_hasVisibleDescendant = true;
     }
 
-    m_isVisibleDescendantDirty = false;
+    m_needsDescendantDependentFlagsUpdate = false;
   }
 
-  if (m_isVisibleContentDirty) {
-    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
-      m_hasVisibleContent = false;
-      LayoutObject* r = layoutObject()->slowFirstChild();
-      while (r) {
-        if (r->style()->visibility() == EVisibility::Visible &&
-            (!r->hasLayer() || !r->enclosingLayer()->isSelfPaintingLayer())) {
-          m_hasVisibleContent = true;
-          break;
-        }
-        LayoutObject* layoutObjectFirstChild = r->slowFirstChild();
-        if (layoutObjectFirstChild &&
-            (!r->hasLayer() || !r->enclosingLayer()->isSelfPaintingLayer())) {
-          r = layoutObjectFirstChild;
-        } else if (r->nextSibling()) {
+  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
+    m_hasVisibleContent = false;
+    LayoutObject* r = layoutObject()->slowFirstChild();
+    while (r) {
+      if (r->style()->visibility() == EVisibility::Visible &&
+          (!r->hasLayer() || !r->enclosingLayer()->isSelfPaintingLayer())) {
+        m_hasVisibleContent = true;
+        break;
+      }
+      LayoutObject* layoutObjectFirstChild = r->slowFirstChild();
+      if (layoutObjectFirstChild &&
+          (!r->hasLayer() || !r->enclosingLayer()->isSelfPaintingLayer())) {
+        r = layoutObjectFirstChild;
+      } else if (r->nextSibling()) {
+        r = r->nextSibling();
+      } else {
+        do {
+          r = r->parent();
+          if (r == layoutObject())
+            r = 0;
+        } while (r && !r->nextSibling());
+        if (r)
           r = r->nextSibling();
-        } else {
-          do {
-            r = r->parent();
-            if (r == layoutObject())
-              r = 0;
-          } while (r && !r->nextSibling());
-          if (r)
-            r = r->nextSibling();
-        }
       }
     }
-    m_isVisibleContentDirty = false;
+  }
 
-    if (hasVisibleContent() != previouslyHasVisibleContent) {
-      setNeedsCompositingInputsUpdate();
-      // 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();
-    }
+  if (hasVisibleContent() != previouslyHasVisibleContent) {
+    setNeedsCompositingInputsUpdate();
+    // 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 =
       m_stackingNode->ancestorStackingContextNode();
   if (!stackingNode)
     return;
 
   stackingNode->layer()->m_is3DTransformedDescendantDirty = true;
@@ skipping 508 matching lines @@
     // building up generated content layers. This is ok, since the lists will
     // start off dirty in that case anyway.
     child->stackingNode()->dirtyStackingContextZOrderLists();
   }
 
   // Non-self-painting children paint into this layer, so the visible contents
   // status of this layer is affected.
   if (!child->isSelfPaintingLayer())
     dirtyVisibleContentStatus();
 
-  dirtyAncestorChainVisibleDescendantStatus();
+  markAncestorChainForDescendantDependentFlagsUpdate();
   dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 
   child->setNeedsRepaint();
-
-  child->updateDescendantDependentFlags();
 }
 
 PaintLayer* PaintLayer::removeChild(PaintLayer* oldChild) {
   if (oldChild->previousSibling())
     oldChild->previousSibling()->setNextSibling(oldChild->nextSibling());
   if (oldChild->nextSibling())
     oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling());
 
   if (m_first == oldChild)
     m_first = oldChild->nextSibling();
@@ skipping 18 matching lines @@
   oldChild->setPreviousSibling(0);
   oldChild->setNextSibling(0);
   oldChild->m_parent = 0;
 
   // Remove any ancestor overflow layers which descended into the removed child.
   if (oldChild->ancestorOverflowLayer())
     oldChild->removeAncestorOverflowLayer(oldChild->ancestorOverflowLayer());
 
   dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 
-  oldChild->updateDescendantDependentFlags();
-
   if (oldChild->m_hasVisibleContent || oldChild->m_hasVisibleDescendant)
-    dirtyAncestorChainVisibleDescendantStatus();
+    markAncestorChainForDescendantDependentFlagsUpdate();
 
   if (oldChild->enclosingPaginationLayer())
     oldChild->clearPaginationRecursive();
 
   setNeedsRepaint();
 
   return oldChild;
 }
 
 void PaintLayer::removeOnlyThisLayerAfterStyleChange() {
@@ skipping 1661 matching lines @@
 
   m_stackingNode->styleDidChange(oldStyle);
 
   if (m_scrollableArea)
     m_scrollableArea->updateAfterStyleChange(oldStyle);
 
   // Overlay scrollbars can make this layer self-painting so we need
   // to recompute the bit once scrollbars have been updated.
   updateSelfPaintingLayer();
 
-  updateDescendantDependentFlags();
-
   updateTransform(oldStyle, layoutObject()->styleRef());
   updateFilters(oldStyle, layoutObject()->styleRef());
   updateClipPath(oldStyle, layoutObject()->styleRef());
 
   setNeedsCompositingInputsUpdate();
 }
 
 bool PaintLayer::scrollsOverflow() const {
   if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea())
     return scrollableArea->scrollsOverflow();
@@ skipping 245 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif