cc: Switch to Chromium DCHECKs and LOGs

cc/TiledLayerChromium.cpp

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #if USE(ACCELERATED_COMPOSITING)
 
 #include "base/basictypes.h"
 #include "TiledLayerChromium.h"
@@ skipping 83 matching lines @@
 {
 }
 
 PassOwnPtr<CCLayerImpl> TiledLayerChromium::createCCLayerImpl()
 {
     return CCTiledLayerImpl::create(id());
 }
 
 void TiledLayerChromium::updateTileSizeAndTilingOption()
 {
-    ASSERT(layerTreeHost());
+    DCHECK(layerTreeHost());
 
     const IntSize& defaultTileSize = layerTreeHost()->settings().defaultTileSize;
     const IntSize& maxUntiledLayerSize = layerTreeHost()->settings().maxUntiledLayerSize;
     int layerWidth = contentBounds().width();
     int layerHeight = contentBounds().height();
 
     const IntSize tileSize(min(defaultTileSize.width(), layerWidth), min(defaultTileSize.height(), layerHeight));
 
     // Tile if both dimensions large, or any one dimension large and the other
     // extends into a second tile but the total layer area isn't larger than that
@@ skipping 205 matching lines @@
     updateBounds();
     if (m_tiler->isEmpty() || contentRect.isEmpty() || m_skipsDraw)
         return;
 
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
 #else
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
 #endif
-        ASSERT(tile);
+        DCHECK(tile);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         IntRect bound = m_tiler->tileRect(tile);
         bound.intersect(contentRect);
         tile->dirtyRect.unite(bound);
     }
 }
 
 // Returns true if tile is dirty and only part of it needs to be updated.
@@ skipping 49 matching lines @@
     // and requesting memory so those are encapsulated in this function:
     // - We only want to call requestLate on unoccluded textures (to preserve
     //   memory for other layers when near OOM).
     // - We only want to record occlusion metrics if all memory requests succeed.
 
     int occludedTileCount = 0;
     bool succeeded = true;
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
-            ASSERT(tile); // Did setTexturePriorities get skipped?
+            DCHECK(tile); // Did setTexturePriorities get skipped?
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
-            ASSERT(!tile->occluded); // Did resetUpdateState get skipped? Are we doing more than one occlusion pass?
+            DCHECK(!tile->occluded); // Did resetUpdateState get skipped? Are we doing more than one occlusion pass?
             IntRect visibleTileRect = intersection(m_tiler->tileBounds(i, j), visibleContentRect());
             if (occlusion && occlusion->occluded(this, visibleTileRect)) {
                 tile->occluded = true;
                 occludedTileCount++;
             } else {
                 succeeded &= tile->managedTexture()->requestLate();
             }
         }
     }
 
     if (!succeeded)
         return;
 
     // FIXME: Remove the loop and just pass the count!
     for (int i = 0; i < occludedTileCount; i++)
         occlusion->overdrawMetrics().didCullTileForUpload();
 }
 
 bool TiledLayerChromium::haveTexturesForTiles(int left, int top, int right, int bottom, bool ignoreOcclusions)
 {
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
-            ASSERT(tile); // Did setTexturePriorites get skipped?
+            DCHECK(tile); // Did setTexturePriorites get skipped?
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
 
             // Ensure the entire tile is dirty if we don't have the texture.
             if (!tile->managedTexture()->haveBackingTexture())
                 tile->dirtyRect = m_tiler->tileRect(tile);
 
             // If using occlusion and the visible region of the tile is occluded,
             // don't reserve a texture or update the tile.
             if (tile->occluded && !ignoreOcclusions)
                 continue;
 
             if (!tile->managedTexture()->canAcquireBackingTexture())
                 return false;
         }
     }
     return true;
 }
 
 IntRect TiledLayerChromium::markTilesForUpdate(int left, int top, int right, int bottom, bool ignoreOcclusions)
 {
     IntRect paintRect;
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
-            ASSERT(tile); // Did setTexturePriorites get skipped?
+            DCHECK(tile); // Did setTexturePriorites get skipped?
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
             if (tile->occluded && !ignoreOcclusions)
                 continue;
             paintRect.unite(tile->dirtyRect);
             tile->markForUpdate();
         }
     }
     return paintRect;
@@ skipping 11 matching lines @@
     // effect of disabling compositing, which causes our reference to the texture updater to be deleted.
     // However, we can't free the memory backing the SkCanvas until the paint finishes,
     // so we grab a local reference here to hold the updater alive until the paint completes.
     RefPtr<LayerTextureUpdater> protector(textureUpdater());
     IntRect paintedOpaqueRect;
     textureUpdater()->prepareToUpdate(paintRect, m_tiler->tileSize(), 1 / widthScale, 1 / heightScale, paintedOpaqueRect, stats);
 
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
-            ASSERT(tile); // Did setTexturePriorites get skipped?
+            DCHECK(tile); // Did setTexturePriorites get skipped?
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
 
             IntRect tileRect = m_tiler->tileBounds(i, j);
 
             // Use updateRect as the above loop copied the dirty rect for this frame to updateRect.
             const IntRect& dirtyRect = tile->updateRect;
             if (dirtyRect.isEmpty())
                 continue;
@@ skipping 193 matching lines @@
 #endif
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         tile->resetUpdateState();
     }
 }
 
 void TiledLayerChromium::update(CCTextureUpdateQueue& queue, const CCOcclusionTracker* occlusion, CCRenderingStats& stats)
 {
-    ASSERT(!m_skipsDraw && !m_failedUpdate); // Did resetUpdateState get skipped?
+    DCHECK(!m_skipsDraw && !m_failedUpdate); // Did resetUpdateState get skipped?
     updateBounds();
     if (m_tiler->hasEmptyBounds() || !drawsContent())
         return;
 
     bool didPaint = false;
 
     // Animation pre-paint. If the layer is small, try to paint it all
     // immediately whether or not it is occluded, to avoid paint/upload
     // hiccups while it is animating.
     if (isSmallAnimatedLayer(this)) {
@@ skipping 66 matching lines @@
     IntRect idlePaintContentRect = idlePaintRect();
     if (idlePaintContentRect.isEmpty())
         return false;
 
     int left, top, right, bottom;
     m_tiler->contentRectToTileIndices(idlePaintContentRect, left, top, right, bottom);
 
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
-            ASSERT(tile); // Did setTexturePriorities get skipped?
+            DCHECK(tile); // Did setTexturePriorities get skipped?
             if (!tile)
                 continue;
 
             bool updated = !tile->updateRect.isEmpty();
             bool canAcquire = tile->managedTexture()->canAcquireBackingTexture();
             bool dirty = tile->isDirty() || !tile->managedTexture()->haveBackingTexture();
             if (!updated && canAcquire && dirty)
                 return true;
         }
     }
@@ skipping 12 matching lines @@
     prepaintRect.inflateX(m_tiler->tileSize().width());
     prepaintRect.inflateY(m_tiler->tileSize().height() * 2);
     IntRect contentRect(IntPoint::zero(), contentBounds());
     prepaintRect.intersect(contentRect);
 
     return prepaintRect;
 }
 
 }
 #endif // USE(ACCELERATED_COMPOSITING)