Move computation of 3D descendants to the descendant-dependent flags 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 120 matching lines @@
 PaintLayer::PaintLayer(LayoutBoxModelObject* layoutObject)
     : m_hasSelfPaintingLayerDescendant(false),
       m_hasSelfPaintingLayerDescendantDirty(false),
       m_isRootLayer(layoutObject->isLayoutView()),
       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_childNeedsCompositingInputsUpdate(true),
       m_hasCompositingDescendant(false),
       m_isAllScrollingContentComposited(false),
       m_shouldIsolateCompositedDescendants(false),
       m_lostGroupedMapping(false),
       m_needsRepaint(false),
       m_previousPaintResult(FullyPainted),
@@ skipping 256 matching lines @@
     // PaintLayers with transforms act as clip rects roots, so clear the cached
     // clip rects here.
     clipper().clearClipRectsIncludingDescendants();
   } else if (hasTransform) {
     clipper().clearClipRectsIncludingDescendants(AbsoluteClipRects);
   }
 
   updateTransformationMatrix();
 
   if (had3DTransform != has3DTransform())
-    dirty3DTransformedDescendantStatus();
+    markAncestorChainForDescendantDependentFlagsUpdate();
 
   if (FrameView* frameView = layoutObject()->document().view())
     frameView->setNeedsUpdateWidgetGeometries();
 }
 
 static PaintLayer* enclosingLayerForContainingBlock(PaintLayer* layer) {
   if (LayoutObject* containingBlock = layer->layoutObject()->containingBlock())
     return containingBlock->enclosingLayer();
   return 0;
 }
@@ skipping 304 matching lines @@
   }
 
   if (hasVisibleContent() != previouslyHasVisibleContent) {
     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();
   }
+
+  update3DTransformedDescendantStatus();
 }
 
-void PaintLayer::dirty3DTransformedDescendantStatus() {
-  PaintLayerStackingNode* stackingNode =
-      m_stackingNode->ancestorStackingContextNode();
-  if (!stackingNode)
-    return;
+void PaintLayer::update3DTransformedDescendantStatus() {
+  m_has3DTransformedDescendant = false;
 
-  stackingNode->layer()->m_is3DTransformedDescendantDirty = true;
+  m_stackingNode->updateZOrderLists();
 
-  // This propagates up through preserve-3d hierarchies to the enclosing
-  // flattening layer.  Note that preserves3D() creates stacking context, so we
-  // can just run up the stacking containers.
-  while (stackingNode && stackingNode->layer()->preserves3D()) {
-    stackingNode->layer()->m_is3DTransformedDescendantDirty = true;
-    stackingNode = stackingNode->ancestorStackingContextNode();
+  // Transformed or preserve-3d descendants can only be in the z-order lists,
+  // not in the normal flow list, so we only need to check those.
+  PaintLayerStackingNodeIterator iterator(
+      *m_stackingNode.get(), PositiveZOrderChildren | NegativeZOrderChildren);
+  while (PaintLayerStackingNode* node = iterator.next()) {
+    const PaintLayer& childLayer = *node->layer();
+    bool childHas3D = false;
+    // If the child lives in a 3d hierarchy, then the layer at the root of
+    // that hierarchy needs the m_has3DTransformedDescendant set.
+    if (childLayer.preserves3D() && (childLayer.has3DTransform() ||
+                                     childLayer.has3DTransformedDescendant()))
+      childHas3D = true;
+    else if (childLayer.has3DTransform())
+      childHas3D = true;
+
+    m_has3DTransformedDescendant = m_has3DTransformedDescendant || childHas3D;

[Xianzhu, 2016/12/28 18:08:11]

We should break the loop when m_has3DTransformedDescendant is set to true the
first time.

Also we seem to iterate the children twice: once in
updateDescendantDependentFlags(), once here. Can we integrate this function into
the loop in updateDescendantDependentFlags()?

[chrishtr, 2016/12/28 18:49:46]

Fixed.
This one loops over the stacking children, which may not even be direct
children.
Alternatively, I considered getting rid of the stacking children concept and
just look at children, but that would end up promoting more PaintLayers than
necessary.

   }
 }
 
-// Return true if this layer or any preserve-3d descendants have 3d.
-bool PaintLayer::update3DTransformedDescendantStatus() {
-  if (m_is3DTransformedDescendantDirty) {
-    m_has3DTransformedDescendant = false;
-
-    m_stackingNode->updateZOrderLists();
-
-    // Transformed or preserve-3d descendants can only be in the z-order lists,
-    // not in the normal flow list, so we only need to check those.
-    PaintLayerStackingNodeIterator iterator(
-        *m_stackingNode.get(), PositiveZOrderChildren | NegativeZOrderChildren);
-    while (PaintLayerStackingNode* node = iterator.next())
-      m_has3DTransformedDescendant |=
-          node->layer()->update3DTransformedDescendantStatus();
-
-    m_is3DTransformedDescendantDirty = false;
-  }
-
-  // If we live in a 3d hierarchy, then the layer at the root of that hierarchy
-  // needs the m_has3DTransformedDescendant set.
-  if (preserves3D())
-    return has3DTransform() || m_has3DTransformedDescendant;
-
-  return has3DTransform();
-}
-
 void PaintLayer::updateLayerPosition() {
   LayoutPoint localPoint;
 
   bool didResize = false;
   if (layoutObject()->isInline() && layoutObject()->isLayoutInline()) {
     LayoutInline* inlineFlow = toLayoutInline(layoutObject());
     IntRect lineBox = enclosingIntRect(inlineFlow->linesBoundingBox());
     m_size = lineBox.size();
   } else if (LayoutBox* box = layoutBox()) {
     IntSize newSize = pixelSnappedIntSize(box->size(), box->location());
@@ skipping 2456 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif