Renaming: distinguish ancestor, container and paintInvalidationContainer

third_party/WebKit/Source/core/layout/LayoutGeometryMap.cpp

 /*
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 36 matching lines @@
     , m_transformedStepsCount(0)
     , m_fixedStepsCount(0)
     , m_mapCoordinatesFlags(flags)
 {
 }
 
 LayoutGeometryMap::~LayoutGeometryMap()
 {
 }
 
-void LayoutGeometryMap::mapToContainer(TransformState& transformState, const LayoutBoxModelObject* container) const
+void LayoutGeometryMap::mapToAncestor(TransformState& transformState, const LayoutBoxModelObject* ancestor) const
 {
     // If the mapping includes something like columns, we have to go via layoutObjects.
     if (hasNonUniformStep()) {
-        m_mapping.last().m_layoutObject->mapLocalToContainer(container, transformState, ApplyContainerFlip | m_mapCoordinatesFlags);
+        m_mapping.last().m_layoutObject->mapLocalToAncestor(ancestor, transformState, ApplyContainerFlip | m_mapCoordinatesFlags);
         transformState.flatten();
         return;
     }
 
     bool inFixed = false;
 #if ENABLE(ASSERT)
-    bool foundContainer = !container || (m_mapping.size() && m_mapping[0].m_layoutObject == container);
+    bool foundAncestor = !ancestor || (m_mapping.size() && m_mapping[0].m_layoutObject == ancestor);
 #endif
 
     for (int i = m_mapping.size() - 1; i >= 0; --i) {
         const LayoutGeometryMapStep& currentStep = m_mapping[i];
 
         // If container is the root LayoutView (step 0) we want to apply its fixed position offset.
-        if (i > 0 && currentStep.m_layoutObject == container) {
+        if (i > 0 && currentStep.m_layoutObject == ancestor) {
 #if ENABLE(ASSERT)
-            foundContainer = true;
+            foundAncestor = true;
 #endif
             break;
         }
 
         // If this box has a transform, it acts as a fixed position container
         // for fixed descendants, which prevents the propagation of 'fixed'
         // unless the layer itself is also fixed position.
         if (i && currentStep.m_hasTransform && !currentStep.m_isFixedPosition)
             inFixed = false;
         else if (currentStep.m_isFixedPosition)
             inFixed = true;
 
         ASSERT(!i == isTopmostLayoutView(currentStep.m_layoutObject));
 
         if (!i) {
             // A null container indicates mapping through the root LayoutView, so including its transform (the page scale).
-            if (!container && currentStep.m_transform)
+            if (!ancestor && currentStep.m_transform)
                 transformState.applyTransform(*currentStep.m_transform.get());
         } else {
             TransformState::TransformAccumulation accumulate = currentStep.m_accumulatingTransform ? TransformState::AccumulateTransform : TransformState::FlattenTransform;
             if (currentStep.m_transform)
                 transformState.applyTransform(*currentStep.m_transform.get(), accumulate);
             else
                 transformState.move(currentStep.m_offset.width(), currentStep.m_offset.height(), accumulate);
         }
 
         if (inFixed && !currentStep.m_offsetForFixedPosition.isZero()) {
             ASSERT(currentStep.m_layoutObject->isLayoutView());
             transformState.move(currentStep.m_offsetForFixedPosition);
         }
     }
 
-    ASSERT(foundContainer);
+    ASSERT(foundAncestor);
     transformState.flatten();
 }
 
 #ifndef NDEBUG
 // Handy function to call from gdb while debugging mismatched point/rect errors.
 void LayoutGeometryMap::dumpSteps() const
 {
     fprintf(stderr, "LayoutGeometryMap::dumpSteps accumulatedOffset=%d,%d\n", m_accumulatedOffset.width().toInt(), m_accumulatedOffset.height().toInt());
     for (int i = m_mapping.size() - 1; i >= 0; --i) {
         fprintf(stderr, " [%d] %s: offset=%d,%d", i,
             m_mapping[i].m_layoutObject->debugName().ascii().data(),
             m_mapping[i].m_offset.width().toInt(),
             m_mapping[i].m_offset.height().toInt());
         if (m_mapping[i].m_hasTransform)
             fprintf(stderr, " hasTransform");
         fprintf(stderr, "\n");
     }
 }
 #endif
 
-FloatQuad LayoutGeometryMap::mapToContainer(const FloatRect& rect, const LayoutBoxModelObject* container) const
+FloatQuad LayoutGeometryMap::mapToAncestor(const FloatRect& rect, const LayoutBoxModelObject* ancestor) const
 {
     FloatQuad result;
 
-    if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_layoutObject))) {
+    if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!ancestor || (m_mapping.size() && ancestor == m_mapping[0].m_layoutObject))) {
         result = rect;
         result.move(m_accumulatedOffset);
     } else {
         TransformState transformState(TransformState::ApplyTransformDirection, rect.center(), rect);
-        mapToContainer(transformState, container);
+        mapToAncestor(transformState, ancestor);
         result = transformState.lastPlanarQuad();
     }
 
 #if ENABLE(ASSERT)
     if (m_mapping.size() > 0) {
         const LayoutObject* lastLayoutObject = m_mapping.last().m_layoutObject;
 
-        FloatRect layoutObjectMappedResult = lastLayoutObject->localToContainerQuad(rect, container, m_mapCoordinatesFlags).boundingBox();
+        FloatRect layoutObjectMappedResult = lastLayoutObject->localToAncestorQuad(rect, ancestor, m_mapCoordinatesFlags).boundingBox();
 
         // Inspector creates layoutObjects with negative width <https://bugs.webkit.org/show_bug.cgi?id=87194>.
         // Taking FloatQuad bounds avoids spurious assertions because of that.
         ASSERT(enclosingIntRect(layoutObjectMappedResult) == enclosingIntRect(result.boundingBox())
             || layoutObjectMappedResult.mayNotHaveExactIntRectRepresentation()
             || result.boundingBox().mayNotHaveExactIntRectRepresentation());
     }
 #endif
 
     return result;
@@ skipping 154 matching lines @@
     // If we're not working with multiple LayoutViews, then any view is considered
     // "topmost" (to preserve original behavior).
     if (!(m_mapCoordinatesFlags & TraverseDocumentBoundaries))
         return true;
 
     return layoutObject->frame()->isMainFrame();
 }
 #endif
 
 } // namespace blink