Changed EPosition to an enum class and renamed its members

third_party/WebKit/Source/core/layout/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 107 matching lines @@
   return update;
 }
 
 SquashingDisallowedReasons
 CompositingLayerAssigner::getReasonsPreventingSquashing(
     const PaintLayer* layer,
     const CompositingLayerAssigner::SquashingState& squashingState) {
   if (!squashingState.haveAssignedBackingsToEntireSquashingLayerSubtree)
     return SquashingDisallowedReasonWouldBreakPaintOrder;
 
-  ASSERT(squashingState.hasMostRecentMapping);
+  DCHECK(squashingState.hasMostRecentMapping);
   const PaintLayer& squashingLayer =
       squashingState.mostRecentMapping->owningLayer();
 
   // FIXME: this special case for video exists only to deal with corner cases
   // where a LayoutVideo does not report that it needs to be directly
   // composited.  Video does not currently support sharing a backing, but this
   // could be generalized in the future. The following layout tests fail if we
   // permit the video to share a backing with other layers.
   //
   // compositing/video/video-controls-layer-creation.html
@@ skipping 46 matching lines @@
   if (layer->renderingContextRoot() != squashingLayer.renderingContextRoot())
     return SquashingDisallowedReasonRenderingContextMismatch;
 
   if (layer->hasFilterInducingProperty() ||
       layer->filterAncestor() != squashingLayer.filterAncestor())
     return SquashingDisallowedReasonFilterMismatch;
 
   if (layer->nearestFixedPositionLayer() !=
       squashingLayer.nearestFixedPositionLayer())
     return SquashingDisallowedReasonNearestFixedPositionMismatch;
-  ASSERT(layer->layoutObject()->style()->position() != FixedPosition);
+  DCHECK(layer->layoutObject()->style()->position() != EPosition::kFixed);
 
   if ((squashingLayer.layoutObject()->style()->subtreeWillChangeContents() &&
        squashingLayer.layoutObject()
            ->style()
            ->isRunningAnimationOnCompositor()) ||
       squashingLayer.layoutObject()
           ->style()
           ->shouldCompositeForCurrentAnimations())
     return SquashingDisallowedReasonSquashingLayerIsAnimating;
 
@@ skipping 11 matching lines @@
   // NOTE: In the future as we generalize this, the background of this layer may
   // need to be assigned to a different backing than the squashed PaintLayer's
   // own primary contents. This would happen when we have a composited negative
   // z-index element that needs to paint on top of the background, but below the
   // layer's main contents. For now, because we always composite layers when
   // they have a composited negative z-index child, such layers will never need
   // squashing so it is not yet an issue.
   if (compositedLayerUpdate == PutInSquashingLayer) {
     // A layer that is squashed with other layers cannot have its own
     // CompositedLayerMapping.
-    ASSERT(!layer->hasCompositedLayerMapping());
-    ASSERT(squashingState.hasMostRecentMapping);
+    DCHECK(!layer->hasCompositedLayerMapping());
+    DCHECK(squashingState.hasMostRecentMapping);
 
     bool changedSquashingLayer =
         squashingState.mostRecentMapping->updateSquashingLayerAssignment(
             layer, squashingState.nextSquashedLayerIndex);
     if (!changedSquashingLayer)
       return;
 
     // If we've modified the collection of squashed layers, we must update
     // the graphics layer geometry.
     squashingState.mostRecentMapping->setNeedsGraphicsLayerUpdate(
@@ skipping 86 matching lines @@
     PaintLayerStackingNodeIterator iterator(*layer->stackingNode(),
                                             NegativeZOrderChildren);
     while (PaintLayerStackingNode* curNode = iterator.next())
       assignLayersToBackingsInternal(curNode->layer(), squashingState,
                                      layersNeedingPaintInvalidation);
   }
 
   // At this point, if the layer is to be separately composited, then its
   // backing becomes the most recent in paint-order.
   if (layer->compositingState() == PaintsIntoOwnBacking) {
-    ASSERT(!requiresSquashing(layer->getCompositingReasons()));
+    DCHECK(!requiresSquashing(layer->getCompositingReasons()));
     squashingState.updateSquashingStateForNewMapping(
         layer->compositedLayerMapping(), layer->hasCompositedLayerMapping(),
         layersNeedingPaintInvalidation);
   }
 
   if (layer->scrollParent())
     layer->scrollParent()->getScrollableArea()->setTopmostScrollChild(layer);
 
   if (layer->needsCompositedScrolling())
     layer->getScrollableArea()->setTopmostScrollChild(nullptr);
 
   PaintLayerStackingNodeIterator iterator(
       *layer->stackingNode(), NormalFlowChildren | PositiveZOrderChildren);
   while (PaintLayerStackingNode* curNode = iterator.next())
     assignLayersToBackingsInternal(curNode->layer(), squashingState,
                                    layersNeedingPaintInvalidation);
 
   if (squashingState.hasMostRecentMapping &&
       &squashingState.mostRecentMapping->owningLayer() == layer)
     squashingState.haveAssignedBackingsToEntireSquashingLayerSubtree = true;
 }
 
 }  // namespace blink