Fix restrictions on squashing with incompatible scroll.

Source/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 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 709 matching lines @@
 
         layer->setViewportConstrainedNotCompositedReason(viewportConstrainedNotCompositedReason);
         return true;
     }
     return false;
 }
 
 bool RenderLayerCompositor::canSquashIntoCurrentSquashingOwner(const RenderLayer* layer, const RenderLayerCompositor::SquashingState& squashingState, const RenderLayer* clippingAncestor)
 {
     ASSERT(clippingAncestor);
-    return clippingAncestor == squashingState.clippingAncestorForMostRecentMapping;
+    if (clippingAncestor != squashingState.clippingAncestorForMostRecentMapping)
+        return false;
+
+    ASSERT(squashignState.hasMostRecentMapping);

[jbroman, 2014/03/15 05:29:24]

drive-by: squashingState not squashignState

[chrishtr, 2014/03/17 16:58:52]

Done.

+    if (layer->scrollsWithRespectTo(&squashingState.mostRecentMapping->owningLayer()))
+        return false;
+
+    return true;
 }
 
 RenderLayerCompositor::CompositingStateTransitionType RenderLayerCompositor::computeCompositedLayerUpdate(RenderLayer* layer)
 {
     CompositingStateTransitionType update = NoCompositingStateChange;
     if (needsOwnBacking(layer)) {
         if (!layer->hasCompositedLayerMapping()) {
             update = AllocateOwnCompositedLayerMapping;
         }
     } else {
@@ skipping 204 matching lines @@
         if (absBounds.isEmpty())
             absBounds.setSize(IntSize(1, 1));
     }
     absoluteDecendantBoundingBox = absBounds;
 
     if (overlapMap && currentRecursionData.m_testingOverlap && !requiresCompositingOrSquashing(directReasons))
         overlapCompositingReason = overlapMap->overlapsLayers(absBounds) ? CompositingReasonOverlap : CompositingReasonNone;
 
     reasonsToComposite |= overlapCompositingReason;
 
-    // If the layer is squashable, but would scroll differently than the
-    // most recent backing that it would squash onto, then don't squash it.
-    // Note that this happens before we know all possible compositing reasons
-    // for this layer, but it's OK because we're just forcing the layer conservatively
-    // to be separately composited rather than squashed, anyway.
-    if (currentRecursionData.m_mostRecentCompositedLayer && requiresSquashing(reasonsToComposite)
-        && layer->scrollsWithRespectTo(currentRecursionData.m_mostRecentCompositedLayer))
-        reasonsToComposite |= CompositingReasonOverlapsWithoutSquashingTarget;
-
     // 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.
     CompositingRecursionData childRecursionData(currentRecursionData);
     childRecursionData.m_subtreeIsCompositing = false;
 
     bool willBeCompositedOrSquashed = canBeComposited(layer) && requiresCompositingOrSquashing(reasonsToComposite);
     if (willBeCompositedOrSquashed) {
         // Tell the parent it has compositing descendants.
         currentRecursionData.m_subtreeIsCompositing = true;
@@ skipping 203 matching lines @@
     if (reflectionLayer->hasCompositedLayerMapping())
         reflectionLayer->compositedLayerMapping()->updateGraphicsLayerConfiguration();
 }
 
 void RenderLayerCompositor::assignLayersToBackingsInternal(RenderLayer* layer, SquashingState& squashingState, bool& layersChanged, RenderLayer* clippingAncestor)
 {
     if (layer->renderer()->hasClipOrOverflowClip())
         clippingAncestor = layer;
 
     if (layerSquashingEnabled() && requiresSquashing(layer->compositingReasons()) && !canSquashIntoCurrentSquashingOwner(layer, squashingState, clippingAncestor))
-        layer->setCompositingReasons(layer->compositingReasons() | CompositingReasonOverlapsWithoutSquashingTarget);
+        layer->setCompositingReasons(layer->compositingReasons() | CompositingReasonNoSquashingTargetFound);
 
     CompositingStateTransitionType compositedLayerUpdate = computeCompositedLayerUpdate(layer);
 
     if (allocateOrClearCompositedLayerMapping(layer, compositedLayerUpdate))
         layersChanged = true;
 
     // FIXME: special-casing reflection layers here is not right.
     if (layer->reflectionInfo())
         assignLayersToBackingsForReflectionLayer(layer->reflectionInfo()->reflectionLayer(), layersChanged);
 
@@ skipping 1050 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore