Minor typo/whitespace cleanup in compositing code.

third_party/WebKit/Source/core/layout/compositing/CompositingRequirementsUpdater.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Google 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
@@ skipping 187 matching lines @@
     // FIXME: we could maybe do this and the hierarchy update in one pass, but the parenting logic would be more complex.
     RecursionData recursionData(root);
     OverlapMap overlapTestRequestMap;
     bool saw3DTransform = false;
 
     // FIXME: Passing these unclippedDescendants down and keeping track
     // of them dynamically, we are requiring a full tree walk. This
     // should be removed as soon as proper overlap testing based on
     // scrolling and animation bounds is implemented (crbug.com/252472).
     Vector<PaintLayer*> unclippedDescendants;
-    IntRect absoluteDecendantBoundingBox;
-    updateRecursive(0, root, overlapTestRequestMap, recursionData, saw3DTransform, unclippedDescendants, absoluteDecendantBoundingBox);
+    IntRect absoluteDescendantBoundingBox;
+    updateRecursive(0, root, overlapTestRequestMap, recursionData, saw3DTransform, unclippedDescendants, absoluteDescendantBoundingBox);
 }
 
-void CompositingRequirementsUpdater::updateRecursive(PaintLayer* ancestorLayer, PaintLayer* layer, OverlapMap& overlapMap, RecursionData& currentRecursionData, bool& descendantHas3DTransform, Vector<PaintLayer*>& unclippedDescendants, IntRect& absoluteDecendantBoundingBox)
+void CompositingRequirementsUpdater::updateRecursive(PaintLayer* ancestorLayer, PaintLayer* layer, OverlapMap& overlapMap, RecursionData& currentRecursionData,
+    bool& descendantHas3DTransform, Vector<PaintLayer*>& unclippedDescendants, IntRect& absoluteDescendantBoundingBox)
 {
     PaintLayerCompositor* compositor = m_layoutView.compositor();
 
     layer->stackingNode()->updateLayerListsIfNeeded();
 
     CompositingReasons reasonsToComposite = CompositingReasonNone;
     CompositingReasons directReasons = m_compositingReasonFinder.directReasons(layer);
 
     // Video is special. It's the only PaintLayer type that can both have
     // PaintLayer children and whose children can't use its backing to render
@@ skipping 57 matching lines @@
         // Remove irrelevant unclipped descendants in reverse order so our stored
         // indices remain valid.
         for (size_t i = 0; i < unclippedDescendantsToRemove.size(); i++)
             unclippedDescendants.remove(unclippedDescendantsToRemove.at(unclippedDescendantsToRemove.size() - i - 1));
 
         if (reasonsToComposite & CompositingReasonOutOfFlowClipping)
             unclippedDescendants.append(layer);
     }
 
     const IntRect& absBounds = layer->clippedAbsoluteBoundingBox();
-    absoluteDecendantBoundingBox = absBounds;
+    absoluteDescendantBoundingBox = absBounds;
 
     if (currentRecursionData.m_testingOverlap && !requiresCompositingOrSquashing(directReasons))
         overlapCompositingReason = overlapMap.overlapsLayers(absBounds) ? CompositingReasonOverlap : CompositingReasonNone;
 
     reasonsToComposite |= overlapCompositingReason;
 
     // The children of this layer don't need to composite, unless there is
     // a compositing layer among them, so start by inheriting the compositing
     // ancestor with m_subtreeIsCompositing set to false.
     RecursionData childRecursionData = currentRecursionData;
@@ skipping 16 matching lines @@
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(layer->stackingNode());
 #endif
 
     bool anyDescendantHas3DTransform = false;
     bool willHaveForegroundLayer = false;
 
     if (layer->stackingNode()->isStackingContext()) {
         PaintLayerStackingNodeIterator iterator(*layer->stackingNode(), NegativeZOrderChildren);
         while (PaintLayerStackingNode* curNode = iterator.next()) {
-            IntRect absoluteChildDecendantBoundingBox;
-            updateRecursive(layer, curNode->layer(), overlapMap, childRecursionData, anyDescendantHas3DTransform, unclippedDescendants, absoluteChildDecendantBoundingBox);
-            absoluteDecendantBoundingBox.unite(absoluteChildDecendantBoundingBox);
+            IntRect absoluteChildDescendantBoundingBox;
+            updateRecursive(layer, curNode->layer(), overlapMap, childRecursionData, anyDescendantHas3DTransform, unclippedDescendants, absoluteChildDescendantBoundingBox);
+            absoluteDescendantBoundingBox.unite(absoluteChildDescendantBoundingBox);
 
             // If we have to make a layer for this child, make one now so we can have a contents layer
             // (since we need to ensure that the -ve z-order child renders underneath our contents).
             if (childRecursionData.m_subtreeIsCompositing) {
                 reasonsToComposite |= CompositingReasonNegativeZIndexChildren;
 
                 if (!willBeCompositedOrSquashed) {
                     // make layer compositing
                     childRecursionData.m_compositingAncestor = layer;
                     overlapMap.beginNewOverlapTestingContext();
@@ skipping 19 matching lines @@
         // children, and start with a fresh new empty context.
         overlapMap.finishCurrentOverlapTestingContext();
         overlapMap.beginNewOverlapTestingContext();
         // This layer is going to be composited, so children can safely ignore the fact that there's an
         // animation running behind this layer, meaning they can rely on the overlap map testing again
         childRecursionData.m_testingOverlap = true;
     }
 
     PaintLayerStackingNodeIterator iterator(*layer->stackingNode(), NormalFlowChildren | PositiveZOrderChildren);
     while (PaintLayerStackingNode* curNode = iterator.next()) {
-        IntRect absoluteChildDecendantBoundingBox;
-        updateRecursive(layer, curNode->layer(), overlapMap, childRecursionData, anyDescendantHas3DTransform, unclippedDescendants, absoluteChildDecendantBoundingBox);
-        absoluteDecendantBoundingBox.unite(absoluteChildDecendantBoundingBox);
+        IntRect absoluteChildDescendantBoundingBox;
+        updateRecursive(layer, curNode->layer(), overlapMap, childRecursionData, anyDescendantHas3DTransform, unclippedDescendants, absoluteChildDescendantBoundingBox);
+        absoluteDescendantBoundingBox.unite(absoluteChildDescendantBoundingBox);
     }
 
     // Now that the subtree has been traversed, we can check for compositing reasons that depended on the state of the subtree.
 
     if (layer->stackingNode()->isStackingContext()) {
         layer->setShouldIsolateCompositedDescendants(childRecursionData.m_hasUnisolatedCompositedBlendingDescendant);
     } else {
         layer->setShouldIsolateCompositedDescendants(false);
         currentRecursionData.m_hasUnisolatedCompositedBlendingDescendant = childRecursionData.m_hasUnisolatedCompositedBlendingDescendant;
     }
@@ skipping 24 matching lines @@
 
         // Now check for reasons to become composited that depend on the state of descendant layers.
         CompositingReasons subtreeCompositingReasons = subtreeReasonsForCompositing(layer, childRecursionData.m_subtreeIsCompositing, anyDescendantHas3DTransform);
         reasonsToComposite |= subtreeCompositingReasons;
         if (!willBeCompositedOrSquashed && canBeComposited && requiresCompositingOrSquashing(subtreeCompositingReasons)) {
             childRecursionData.m_compositingAncestor = layer;
             // FIXME: this context push is effectively a no-op but needs to exist for
             // now, because the code is designed to push overlap information to the
             // second-from-top context of the stack.
             overlapMap.beginNewOverlapTestingContext();
-            overlapMap.add(layer, absoluteDecendantBoundingBox);
+            overlapMap.add(layer, absoluteDescendantBoundingBox);
             willBeCompositedOrSquashed = true;
         }
 
         if (willBeCompositedOrSquashed)
             reasonsToComposite |= layer->potentialCompositingReasonsFromStyle() & CompositingReasonInlineTransform;
 
         // If the original layer is composited, the reflection needs to be, too.
         if (layer->reflectionInfo()) {
             // FIXME: Shouldn't we call computeCompositingRequirements to handle a reflection overlapping with another layoutObject?
             PaintLayer* reflectionLayer = layer->reflectionInfo()->reflectionLayer();
@@ skipping 17 matching lines @@
             currentRecursionData.m_testingOverlap = false;
 
         if (childRecursionData.m_compositingAncestor == layer)
             overlapMap.finishCurrentOverlapTestingContext();
 
         descendantHas3DTransform |= anyDescendantHas3DTransform || layer->has3DTransform();
     }
 
     // At this point we have finished collecting all reasons to composite this layer.
     layer->setCompositingReasons(reasonsToComposite);
-
 }
 
 } // namespace blink