Rename AncestorDependentProperties to CompositingInputs

Source/core/rendering/RenderLayer.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>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 104 matching lines @@
     , m_hasVisibleContent(false)
     , m_visibleDescendantStatusDirty(false)
     , m_hasVisibleDescendant(false)
     , m_hasVisibleNonLayerContent(false)
     , m_isPaginated(false)
     , m_3DTransformedDescendantStatusDirty(true)
     , m_has3DTransformedDescendant(false)
     , m_containsDirtyOverlayScrollbars(false)
     , m_canSkipRepaintRectsUpdateOnScroll(renderer->isTableCell())
     , m_hasFilterInfo(false)
-    , m_needsToUpdateAncestorDependentProperties(true)
-    , m_childNeedsToUpdateAncestorDependantProperties(true)
+    , m_needsCompositingInputsUpdate(true)
+    , m_childNeedsCompositingInputsUpdate(true)
     , m_hasCompositingDescendant(false)
     , m_hasNonCompositedChild(false)
     , m_shouldIsolateCompositedDescendants(false)
     , m_lostGroupedMapping(false)
     , m_viewportConstrainedNotCompositedReason(NoNotCompositedReason)
     , m_renderer(renderer)
     , m_parent(0)
     , m_previous(0)
     , m_next(0)
     , m_first(0)
@@ skipping 601 matching lines @@
 void RenderLayer::setHasVisibleContent()
 {
     if (m_hasVisibleContent && !m_visibleContentStatusDirty) {
         ASSERT(!parent() || parent()->hasVisibleDescendant());
         return;
     }
 
     m_hasVisibleContent = true;
     m_visibleContentStatusDirty = false;
 
-    setNeedsToUpdateAncestorDependentProperties();
+    setNeedsCompositingInputsUpdate();
     repainter().computeRepaintRects();
 
     if (parent())
         parent()->setAncestorChainHasVisibleDescendant();
 }
 
 void RenderLayer::dirtyVisibleContentStatus()
 {
     m_visibleContentStatusDirty = true;
     if (parent())
@@ skipping 110 matching lines @@
                     if (r)
                         r = r->nextSibling();
                 }
             }
         }
         m_visibleContentStatusDirty = false;
 
         // FIXME: We can remove this code once we remove the recursive tree
         // walk inside updateGraphicsLayerGeometry.
         if (hasVisibleContent() != previouslyHasVisibleContent)
-            setNeedsToUpdateAncestorDependentProperties();
+            setNeedsCompositingInputsUpdate();
     }
 }
 
 void RenderLayer::dirty3DTransformedDescendantStatus()
 {
     RenderLayerStackingNode* stackingNode = m_stackingNode->ancestorStackingContextNode();
     if (!stackingNode)
         return;
 
     stackingNode->layer()->m_3DTransformedDescendantStatusDirty = true;
@@ skipping 173 matching lines @@
 {
     RenderLayer* curr = parent();
     while (curr && !curr->isRootLayer() && !curr->transform())
         curr = curr->parent();
 
     return curr;
 }
 
 LayoutPoint RenderLayer::computeOffsetFromTransformedAncestor() const
 {
-    const AncestorDependentProperties& properties = ancestorDependentProperties();
+    const CompositingInputs& properties = compositingInputs();
 
     TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
     // FIXME: add a test that checks flipped writing mode and ApplyContainerFlip are correct.
     renderer()->mapLocalToContainer(properties.transformAncestor ? properties.transformAncestor->renderer() : 0, transformState, ApplyContainerFlip);
     transformState.flatten();
     return LayoutPoint(transformState.lastPlanarPoint());
 }
 
 const RenderLayer* RenderLayer::compositingContainer() const
 {
@@ skipping 82 matching lines @@
 {
     const RenderLayer* curr = (includeSelf == IncludeSelf) ? this : parent();
     for (; curr; curr = curr->parent()) {
         if (curr->requiresFullLayerImageForFilters())
             return const_cast<RenderLayer*>(curr);
     }
 
     return 0;
 }
 
-void RenderLayer::setNeedsToUpdateAncestorDependentProperties()
+void RenderLayer::setNeedsCompositingInputsUpdate()
 {
-    m_needsToUpdateAncestorDependentProperties = true;
+    m_needsCompositingInputsUpdate = true;
 
-    for (RenderLayer* current = this; current && !current->m_childNeedsToUpdateAncestorDependantProperties; current = current->parent())
-        current->m_childNeedsToUpdateAncestorDependantProperties = true;
+    for (RenderLayer* current = this; current && !current->m_childNeedsCompositingInputsUpdate; current = current->parent())
+        current->m_childNeedsCompositingInputsUpdate = true;
 }
 
-void RenderLayer::updateAncestorDependentProperties(const AncestorDependentProperties& ancestorDependentProperties)
+void RenderLayer::updateCompositingInputs(const CompositingInputs& compositingInputs)
 {
-    m_ancestorDependentProperties = ancestorDependentProperties;
-    m_needsToUpdateAncestorDependentProperties = false;
+    m_compositingInputs = compositingInputs;
+    m_needsCompositingInputsUpdate = false;
 }
 
-void RenderLayer::clearChildNeedsToUpdateAncestorDependantProperties()
+void RenderLayer::clearChildNeedsCompositingInputsUpdate()
 {
-    ASSERT(!m_needsToUpdateAncestorDependentProperties);
-    m_childNeedsToUpdateAncestorDependantProperties = false;
+    ASSERT(!m_needsCompositingInputsUpdate);
+    m_childNeedsCompositingInputsUpdate = false;
 }
 
 void RenderLayer::setCompositingReasons(CompositingReasons reasons, CompositingReasons mask)
 {
     ASSERT(reasons == (reasons & mask));
     if ((compositingReasons() & mask) == (reasons & mask))
         return;
     m_compositingReasons = (reasons & mask) | (compositingReasons() & ~mask);
     m_clipper.setCompositingClipRectsDirty();
 }
@@ skipping 177 matching lines @@
 
     if (beforeChild) {
         beforeChild->setPreviousSibling(child);
         child->setNextSibling(beforeChild);
         ASSERT(beforeChild != child);
     } else
         setLastChild(child);
 
     child->m_parent = this;
 
-    setNeedsToUpdateAncestorDependentProperties();
+    setNeedsCompositingInputsUpdate();
 
     if (child->stackingNode()->isNormalFlowOnly())
         m_stackingNode->dirtyNormalFlowList();
 
     if (!child->stackingNode()->isNormalFlowOnly() || child->firstChild()) {
         // Dirty the z-order list in which we are contained. The ancestorStackingContextNode() can be null in the
         // case where we're building up generated content layers. This is ok, since the lists will start
         // off dirty in that case anyway.
         child->stackingNode()->dirtyStackingContextZOrderLists();
     }
@@ skipping 2319 matching lines @@
         updateTransform();
 
     {
         // https://code.google.com/p/chromium/issues/detail?id=343759
         DisableCompositingQueryAsserts disabler;
         updateFilters(oldStyle, renderer()->style());
     }
 
     compositor()->updateStyleDeterminedCompositingReasons(this);
 
-    setNeedsToUpdateAncestorDependentProperties();
+    setNeedsCompositingInputsUpdate();
 
     // FIXME: Remove incremental compositing updates after fixing the chicken/egg issues
     // https://code.google.com/p/chromium/issues/detail?id=343756
     DisableCompositingQueryAsserts disabler;
 
     compositor()->updateLayerCompositingState(this, RenderLayerCompositor::UseChickenEggHacks);
 }
 
 bool RenderLayer::scrollsOverflow() const
 {
@@ skipping 147 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif