Fix descendant-dependent PaintLayer flags update to not early-out when dirty.

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 622 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() {
-  compositor()->setNeedsUpdateDescendantDependentFlags();
   m_isVisibleContentDirty = true;
   if (parent())
     parent()->dirtyAncestorChainVisibleDescendantStatus();
   // 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() {
-  compositor()->setNeedsUpdateDescendantDependentFlags();
-
   for (PaintLayer* layer = this; layer; layer = layer->parent()) {
     if (layer->m_isVisibleDescendantDirty)
       break;
     layer->m_isVisibleDescendantDirty = 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.
@@ skipping 23 matching lines @@
 }
 
 void PaintLayer::updateDescendantDependentFlags() {
   if (m_isVisibleDescendantDirty) {
     m_hasVisibleDescendant = false;
 
     for (PaintLayer* child = firstChild(); child;
          child = child->nextSibling()) {
       child->updateDescendantDependentFlags();
 
-      if (child->m_hasVisibleContent || child->m_hasVisibleDescendant) {
+      if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
         m_hasVisibleDescendant = true;
-        break;

[chrishtr, 2016/11/30 15:26:38]

Here is where it used to incorrectly early-out of the iteration over children.
There are about
10 layout tests that fail if the "whole subtree" hammer is removed but this
break remains.

-      }
     }
 
     m_isVisibleDescendantDirty = false;
   }
 
   if (m_isVisibleContentDirty) {
     bool previouslyHasVisibleContent = m_hasVisibleContent;
     if (layoutObject()->style()->visibility() == EVisibility::Visible) {
       m_hasVisibleContent = true;
     } else {
@@ skipping 2548 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif