Remove sparsity tolerance check when considering squashing layers

sky/engine/core/rendering/compositing/CompositingLayerAssigner.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 14 matching lines @@
  */
 
 #include "config.h"
 #include "core/rendering/compositing/CompositingLayerAssigner.h"
 
 #include "core/rendering/compositing/CompositedLayerMapping.h"
 #include "platform/TraceEvent.h"
 
 namespace blink {
 
-// We will only allow squashing if the bbox-area:squashed-area doesn't exceed
-// the ratio |gSquashingSparsityTolerance|:1.
-static uint64_t gSquashingSparsityTolerance = 6;
-
 CompositingLayerAssigner::CompositingLayerAssigner(RenderLayerCompositor* compositor)
     : m_compositor(compositor)
     , m_layerSquashingEnabled(compositor->layerSquashingEnabled())
     , m_layersChanged(false)
 {
 }
 
 CompositingLayerAssigner::~CompositingLayerAssigner()
 {
 }
@@ skipping 14 matching lines @@
     if (hasMostRecentMapping)
         mostRecentMapping->finishAccumulatingSquashingLayers(nextSquashedLayerIndex);
 
     nextSquashedLayerIndex = 0;
     boundingRect = IntRect();
     mostRecentMapping = newCompositedLayerMapping;
     hasMostRecentMapping = hasNewCompositedLayerMapping;
     haveAssignedBackingsToEntireSquashingLayerSubtree = false;
 }
 
-bool CompositingLayerAssigner::squashingWouldExceedSparsityTolerance(const RenderLayer* candidate, const CompositingLayerAssigner::SquashingState& squashingState)
-{
-    IntRect bounds = candidate->clippedAbsoluteBoundingBox();
-    IntRect newBoundingRect = squashingState.boundingRect;
-    newBoundingRect.unite(bounds);
-    const uint64_t newBoundingRectArea = newBoundingRect.size().area();
-    const uint64_t newSquashedArea = squashingState.totalAreaOfSquashedRects + bounds.size().area();
-    return newBoundingRectArea > gSquashingSparsityTolerance * newSquashedArea;
-}
-
 bool CompositingLayerAssigner::needsOwnBacking(const RenderLayer* layer) const
 {
     if (!m_compositor->canBeComposited(layer))
         return false;
 
     // If squashing is disabled, then layers that would have been squashed should just be separately composited.
     bool needsOwnBackingForDisabledSquashing = !m_layerSquashingEnabled && requiresSquashing(layer->compositingReasons());
 
     return requiresCompositing(layer->compositingReasons()) || needsOwnBackingForDisabledSquashing || (m_compositor->staleInCompositingMode() && layer->isRootLayer());
 }
@@ skipping 20 matching lines @@
         }
     }
     return update;
 }
 
 CompositingReasons CompositingLayerAssigner::getReasonsPreventingSquashing(const RenderLayer* layer, const CompositingLayerAssigner::SquashingState& squashingState)
 {
     if (!squashingState.haveAssignedBackingsToEntireSquashingLayerSubtree)
         return CompositingReasonSquashingWouldBreakPaintOrder;
 
-    if (squashingWouldExceedSparsityTolerance(layer, squashingState))
-        return CompositingReasonSquashingSparsityExceeded;
-
     // FIXME: this is not efficient, since it walks up the tree . We should store these values on the CompositingInputsCache.
     ASSERT(squashingState.hasMostRecentMapping);
     const RenderLayer& squashingLayer = squashingState.mostRecentMapping->owningLayer();
 
     if (layer->clippingContainer() != squashingLayer.clippingContainer() && !squashingLayer.compositedLayerMapping()->containingSquashedLayer(layer->clippingContainer()))
         return CompositingReasonSquashingClippingContainerMismatch;
 
     // Composited descendants need to be clipped by a child containment graphics layer, which would not be available if the layer is
     // squashed (and therefore has no CLM nor a child containment graphics layer).
     if (m_compositor->clipsCompositingDescendants(layer))
@@ skipping 109 matching lines @@
 
     RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), NormalFlowChildren | PositiveZOrderChildren);
     while (RenderLayerStackingNode* curNode = iterator.next())
         assignLayersToBackingsInternal(curNode->layer(), squashingState, layersNeedingPaintInvalidation);
 
     if (squashingState.hasMostRecentMapping && &squashingState.mostRecentMapping->owningLayer() == layer)
         squashingState.haveAssignedBackingsToEntireSquashingLayerSubtree = true;
 }
 
 }