Convert GraphicsLayer from ASSERT to DCHECK

third_party/WebKit/Source/platform/graphics/GraphicsLayer.cpp

 /*
  * Copyright (C) 2009 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 119 matching lines @@
 
 #if ENABLE(ASSERT)
   if (m_client)
     m_client->verifyNotPainting();
 #endif
 
   removeAllChildren();
   removeFromParent();
 
   rasterInvalidationTrackingMap().remove(this);
-  ASSERT(!m_parent);
+  DCHECK(!m_parent);
 }
 
 LayoutRect GraphicsLayer::visualRect() const {
   LayoutRect bounds = LayoutRect(FloatPoint(), size());
   bounds.move(offsetFromLayoutObjectWithSubpixelAccumulation());
   return bounds;
 }
 
 void GraphicsLayer::setHasWillChangeTransformHint(bool hasWillChangeTransform) {
   m_layer->layer()->setHasWillChangeTransformHint(hasWillChangeTransform);
 }
 
 void GraphicsLayer::setPreferredRasterBounds(const IntSize& bounds) {
   m_preferredRasterBounds = bounds;
   m_hasPreferredRasterBounds = true;
   m_layer->layer()->setPreferredRasterBounds(bounds);
 }
 
 void GraphicsLayer::clearPreferredRasterBounds() {
   m_preferredRasterBounds = IntSize();
   m_hasPreferredRasterBounds = false;
   m_layer->layer()->clearPreferredRasterBounds();
 }
 
 void GraphicsLayer::setParent(GraphicsLayer* layer) {
-  ASSERT(!layer || !layer->hasAncestor(this));
+#if DCHECK_IS_ON()
+  DCHECK(!layer || !layer->hasAncestor(this));
+#endif
   m_parent = layer;
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 
 bool GraphicsLayer::hasAncestor(GraphicsLayer* ancestor) const {
   for (GraphicsLayer* curr = parent(); curr; curr = curr->parent()) {
     if (curr == ancestor)
       return true;
   }
 
   return false;
 }
 
 #endif
 
 bool GraphicsLayer::setChildren(const GraphicsLayerVector& newChildren) {
   // If the contents of the arrays are the same, nothing to do.
   if (newChildren == m_children)
     return false;
 
   removeAllChildren();
 
   size_t listSize = newChildren.size();
   for (size_t i = 0; i < listSize; ++i)
     addChildInternal(newChildren[i]);
 
   updateChildList();
 
   return true;
 }
 
 void GraphicsLayer::addChildInternal(GraphicsLayer* childLayer) {
-  ASSERT(childLayer != this);
+  DCHECK_NE(childLayer, this);
 
   if (childLayer->parent())
     childLayer->removeFromParent();
 
   childLayer->setParent(this);
   m_children.append(childLayer);
 
   // Don't call updateChildList here, this function is used in cases where it
   // should not be called until all children are processed.
 }
 
 void GraphicsLayer::addChild(GraphicsLayer* childLayer) {
   addChildInternal(childLayer);
   updateChildList();
 }
 
 void GraphicsLayer::addChildBelow(GraphicsLayer* childLayer,
                                   GraphicsLayer* sibling) {
-  ASSERT(childLayer != this);
+  DCHECK_NE(childLayer, this);
   childLayer->removeFromParent();
 
   bool found = false;
   for (unsigned i = 0; i < m_children.size(); i++) {
     if (sibling == m_children[i]) {
       m_children.insert(i, childLayer);
       found = true;
       break;
     }
   }
 
   childLayer->setParent(this);
 
   if (!found)
     m_children.append(childLayer);
 
   updateChildList();
 }
 
 void GraphicsLayer::removeAllChildren() {
   while (!m_children.isEmpty()) {
     GraphicsLayer* curLayer = m_children.back();
-    ASSERT(curLayer->parent());
+    DCHECK(curLayer->parent());
     curLayer->removeFromParent();
   }
 }
 
 void GraphicsLayer::removeFromParent() {
   if (m_parent) {
     // We use reverseFind so that removeAllChildren() isn't n^2.
     m_parent->m_children.remove(m_parent->m_children.reverseFind(this));
     setParent(0);
   }
@@ skipping 44 matching lines @@
       tracking.lastPaintedPicture = std::move(newPicture);
       tracking.lastInterestRect = m_previousInterestRect;
       tracking.rasterInvalidationRegionSinceLastPaint = Region();
     }
   }
 }
 
 bool GraphicsLayer::paintWithoutCommit(
     const IntRect* interestRect,
     GraphicsContext::DisabledMode disabledMode) {
-  ASSERT(drawsContent());
+  DCHECK(drawsContent());
 
   if (!m_client)
     return false;
   if (firstPaintInvalidationTrackingEnabled())
     m_debugInfo.clearAnnotatedInvalidateRects();
   incrementPaintCount();
 
   IntRect newInterestRect;
   if (!interestRect) {
     newInterestRect =
@@ skipping 102 matching lines @@
 
 void GraphicsLayer::registerContentsLayer(WebLayer* layer) {
   if (!s_registeredLayerSet)
     s_registeredLayerSet = new HashSet<int>;
   if (s_registeredLayerSet->contains(layer->id()))
     CRASH();
   s_registeredLayerSet->add(layer->id());
 }
 
 void GraphicsLayer::unregisterContentsLayer(WebLayer* layer) {
-  ASSERT(s_registeredLayerSet);
+  DCHECK(s_registeredLayerSet);
   if (!s_registeredLayerSet->contains(layer->id()))
     CRASH();
   s_registeredLayerSet->remove(layer->id());
 }
 
 void GraphicsLayer::setContentsTo(WebLayer* layer) {
   bool childrenChanged = false;
   if (layer) {
-    ASSERT(s_registeredLayerSet);
+    DCHECK(s_registeredLayerSet);
     if (!s_registeredLayerSet->contains(layer->id()))
       CRASH();
     if (m_contentsLayerId != layer->id()) {
       setupContentsLayer(layer);
       childrenChanged = true;
     }
     updateContentsRect();
   } else {
     if (m_contentsLayer) {
       childrenChanged = true;
 
       // The old contents layer will be removed via updateChildList.
       m_contentsLayer = 0;
       m_contentsLayerId = 0;
     }
   }
 
   if (childrenChanged)
     updateChildList();
 }
 
 void GraphicsLayer::setupContentsLayer(WebLayer* contentsLayer) {
-  ASSERT(contentsLayer);
+  DCHECK(contentsLayer);
   m_contentsLayer = contentsLayer;
   m_contentsLayerId = m_contentsLayer->id();
 
   m_contentsLayer->setLayerClient(this);
   m_contentsLayer->setTransformOrigin(FloatPoint3D());
   m_contentsLayer->setUseParentBackfaceVisibility(true);
 
   // It is necessary to call setDrawsContent as soon as we receive the new
   // contentsLayer, for the correctness of early exit conditions in
   // setDrawsContent() and setContentsVisible().
@@ skipping 177 matching lines @@
       m_transformOrigin !=
           FloatPoint3D(m_size.width() * 0.5f, m_size.height() * 0.5f, 0))
     json->setArray("transformOrigin", pointAsJSONArray(m_transformOrigin));
 
   if (m_size != IntSize())
     json->setArray("bounds", sizeAsJSONArray(m_size));
 
   if (m_opacity != 1)
     json->setDouble("opacity", m_opacity);
 
-  if (m_blendMode != WebBlendModeNormal)
+  if (m_blendMode != WebBlendModeNormal) {
     json->setString("blendMode",
                     compositeOperatorName(CompositeSourceOver, m_blendMode));
+  }
 
   if (m_isRootForIsolatedGroup)
     json->setBoolean("isolate", m_isRootForIsolatedGroup);
 
   if (m_contentsOpaque)
     json->setBoolean("contentsOpaque", m_contentsOpaque);
 
   if (!m_shouldFlattenTransform)
     json->setBoolean("shouldFlattenTransform", m_shouldFlattenTransform);
 
   if (m_renderingContext3d) {
     RenderingContextMap::const_iterator it =
         renderingContextMap.find(m_renderingContext3d);
     int contextId = renderingContextMap.size() + 1;
     if (it == renderingContextMap.end())
       renderingContextMap.set(m_renderingContext3d, contextId);
     else
       contextId = it->value;
 
     json->setInteger("3dRenderingContext", contextId);
   }
 
   if (m_drawsContent)
     json->setBoolean("drawsContent", m_drawsContent);
 
   if (!m_contentsVisible)
     json->setBoolean("contentsVisible", m_contentsVisible);
 
-  if (!m_backfaceVisibility)
+  if (!m_backfaceVisibility) {
     json->setString("backfaceVisibility",
                     m_backfaceVisibility ? "visible" : "hidden");
+  }
 
   if (m_hasPreferredRasterBounds) {
     json->setArray("preferredRasterBounds",
                    sizeAsJSONArray(m_preferredRasterBounds));
   }
 
   if (flags & LayerTreeIncludesDebugInfo)
     json->setString("client", pointerAsString(m_client));
 
-  if (m_backgroundColor.alpha())
+  if (m_backgroundColor.alpha()) {
     json->setString("backgroundColor",
                     m_backgroundColor.nameForLayoutTreeAsText());
+  }
 
   if (!m_transform.isIdentity())
     json->setArray("transform", transformAsJSONArray(m_transform));
 
   if (flags & LayerTreeIncludesPaintInvalidations)
     rasterInvalidationTrackingMap().asJSON(this, json.get());
 
   if ((flags & LayerTreeIncludesPaintingPhases) && m_paintingPhase) {
     std::unique_ptr<JSONArray> paintingPhasesJSON = JSONArray::create();
     if (m_paintingPhase & GraphicsLayerPaintBackground)
@@ skipping 19 matching lines @@
     if (m_hasClipParent)
       json->setBoolean("hasClipParent", true);
   }
 
   if (flags &
       (LayerTreeIncludesDebugInfo | LayerTreeIncludesCompositingReasons)) {
     bool debug = flags & LayerTreeIncludesDebugInfo;
     std::unique_ptr<JSONArray> compositingReasonsJSON = JSONArray::create();
     for (size_t i = 0; i < kNumberOfCompositingReasons; ++i) {
       if (m_debugInfo.getCompositingReasons() &
-          kCompositingReasonStringMap[i].reason)
+          kCompositingReasonStringMap[i].reason) {
         compositingReasonsJSON->pushString(
             debug ? kCompositingReasonStringMap[i].description
                   : kCompositingReasonStringMap[i].shortName);
+      }
     }
     json->setArray("compositingReasons", std::move(compositingReasonsJSON));
 
     std::unique_ptr<JSONArray> squashingDisallowedReasonsJSON =
         JSONArray::create();
     for (size_t i = 0; i < kNumberOfSquashingDisallowedReasons; ++i) {
       if (m_debugInfo.getSquashingDisallowedReasons() &
-          kSquashingDisallowedReasonStringMap[i].reason)
+          kSquashingDisallowedReasonStringMap[i].reason) {
         squashingDisallowedReasonsJSON->pushString(
             debug ? kSquashingDisallowedReasonStringMap[i].description
                   : kSquashingDisallowedReasonStringMap[i].shortName);
+      }
     }
     json->setArray("squashingDisallowedReasons",
                    std::move(squashingDisallowedReasonsJSON));
   }
   return json;
 }
 
 std::unique_ptr<JSONObject> GraphicsLayer::layerTreeAsJSONInternal(
     LayerTreeFlags flags,
     RenderingContextMap& renderingContextMap) const {
   std::unique_ptr<JSONObject> json =
       layerAsJSONInternal(flags, renderingContextMap);
 
   if (m_children.size()) {
     std::unique_ptr<JSONArray> childrenJSON = JSONArray::create();
-    for (size_t i = 0; i < m_children.size(); i++)
+    for (size_t i = 0; i < m_children.size(); i++) {
       childrenJSON->pushObject(
           m_children[i]->layerTreeAsJSONInternal(flags, renderingContextMap));
+    }
     json->setArray("children", std::move(childrenJSON));
   }
 
   return json;
 }
 
 void GraphicsLayer::layersAsJSONArray(LayerTreeFlags flags,
                                       RenderingContextMap& renderingContextMap,
                                       JSONArray* jsonArray) const {
   jsonArray->pushObject(layerAsJSONInternal(flags, renderingContextMap));
@@ skipping 26 matching lines @@
     }
   }
 
   if (layer->id() == m_contentsLayerId) {
     name = "ContentsLayer for " + m_client->debugName(this);
   } else if (!highlightDebugName.isEmpty()) {
     name = highlightDebugName;
   } else if (layer == ccLayerForWebLayer(m_layer->layer())) {
     name = m_client->debugName(this);
   } else {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
   }
   return name;
 }
 
 void GraphicsLayer::setCompositingReasons(CompositingReasons reasons) {
   m_debugInfo.setCompositingReasons(reasons);
 }
 
 void GraphicsLayer::setSquashingDisallowedReasons(
     SquashingDisallowedReasons reasons) {
   m_debugInfo.setSquashingDisallowedReasons(reasons);
 }
 
 void GraphicsLayer::setOwnerNodeId(int nodeId) {
   m_debugInfo.setOwnerNodeId(nodeId);
 }
 
 void GraphicsLayer::setPosition(const FloatPoint& point) {
   m_position = point;
   platformLayer()->setPosition(m_position);
 }
 
 void GraphicsLayer::setSize(const FloatSize& size) {
   // We are receiving negative sizes here that cause assertions to fail in the
   // compositor. Clamp them to 0 to avoid those assertions.
-  // FIXME: This should be an ASSERT instead, as negative sizes should not exist
+  // FIXME: This should be an DCHECK instead, as negative sizes should not exist
   // in WebCore.
   FloatSize clampedSize = size;
   if (clampedSize.width() < 0 || clampedSize.height() < 0)
     clampedSize = FloatSize();
 
   if (clampedSize == m_size)
     return;
 
   m_size = clampedSize;
 
@@ skipping 245 matching lines @@
 }
 
 void GraphicsLayer::setPaintingPhase(GraphicsLayerPaintingPhase phase) {
   if (m_paintingPhase == phase)
     return;
   m_paintingPhase = phase;
   setNeedsDisplay();
 }
 
 void GraphicsLayer::addLinkHighlight(LinkHighlight* linkHighlight) {
-  ASSERT(linkHighlight && !m_linkHighlights.contains(linkHighlight));
+  DCHECK(linkHighlight && !m_linkHighlights.contains(linkHighlight));
   m_linkHighlights.append(linkHighlight);
   linkHighlight->layer()->setLayerClient(this);
   updateChildList();
 }
 
 void GraphicsLayer::removeLinkHighlight(LinkHighlight* linkHighlight) {
   m_linkHighlights.remove(m_linkHighlights.find(linkHighlight));
   updateChildList();
 }
 
@@ skipping 184 matching lines @@
 void showGraphicsLayerTree(const blink::GraphicsLayer* layer) {
   if (!layer) {
     LOG(INFO) << "Cannot showGraphicsLayerTree for (nil).";
     return;
   }
 
   String output = layer->layerTreeAsText(blink::LayerTreeIncludesDebugInfo);
   LOG(INFO) << output.utf8().data();
 }
 #endif