cc: Switch to Chromium DCHECKs LOGs

cc/layer_tree_host_impl.cc

 // 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"
 
 #include "CCLayerTreeHostImpl.h"
 
 #include "CCAppendQuadsData.h"
 #include "CCDamageTracker.h"
@@ skipping 65 matching lines @@
         delta = m_maxPageScaleFactor / m_pageScaleFactor;
 
     if (delta == m_pageScaleDelta)
         return;
 
     m_pageScaleDelta = delta;
 }
 
 bool CCPinchZoomViewport::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
 {
-    ASSERT(pageScaleFactor);
+    DCHECK(pageScaleFactor);
 
     if (m_sentPageScaleDelta == 1 && pageScaleFactor == m_pageScaleFactor && minPageScaleFactor == m_minPageScaleFactor && maxPageScaleFactor == m_maxPageScaleFactor)
         return false;
 
     m_minPageScaleFactor = minPageScaleFactor;
     m_maxPageScaleFactor = maxPageScaleFactor;
 
     m_pageScaleFactor = pageScaleFactor;
     return true;
 }
@@ skipping 129 matching lines @@
     , m_memoryAllocationLimitBytes(CCPrioritizedTextureManager::defaultMemoryAllocationLimit())
     , m_backgroundColor(0)
     , m_hasTransparentBackground(false)
     , m_needsAnimateLayers(false)
     , m_pinchGestureActive(false)
     , m_fpsCounter(CCFrameRateCounter::create())
     , m_debugRectHistory(CCDebugRectHistory::create())
     , m_numImplThreadScrolls(0)
     , m_numMainThreadScrolls(0)
 {
-    ASSERT(CCProxy::isImplThread());
+    DCHECK(CCProxy::isImplThread());
     didVisibilityChange(this, m_visible);
 }
 
 CCLayerTreeHostImpl::~CCLayerTreeHostImpl()
 {
-    ASSERT(CCProxy::isImplThread());
+    DCHECK(CCProxy::isImplThread());
     TRACE_EVENT0("cc", "CCLayerTreeHostImpl::~CCLayerTreeHostImpl()");
 
     if (m_rootLayerImpl)
         clearRenderSurfaces();
 }
 
 void CCLayerTreeHostImpl::beginCommit()
 {
 }
 
@@ skipping 74 matching lines @@
 
 void CCLayerTreeHostImpl::trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList)
 {
     // For now, we use damage tracking to compute a global scissor. To do this, we must
     // compute all damage tracking before drawing anything, so that we know the root
     // damage rect. The root damage rect is then used to scissor each surface.
 
     for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex];
         CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface();
-        ASSERT(renderSurface);
+        DCHECK(renderSurface);
         renderSurface->damageTracker()->updateDamageTrackingState(renderSurface->layerList(), renderSurfaceLayer->id(), renderSurface->surfacePropertyChangedOnlyFromDescendant(), renderSurface->contentRect(), renderSurfaceLayer->maskLayer(), renderSurfaceLayer->filters());
     }
 }
 
 void CCLayerTreeHostImpl::updateRootScrollLayerImplTransform()
 {
     if (m_rootScrollLayerImpl) {
         m_rootScrollLayerImpl->setImplTransform(implTransform());
     }
 }
 
 void CCLayerTreeHostImpl::calculateRenderSurfaceLayerList(CCLayerList& renderSurfaceLayerList)
 {
-    ASSERT(renderSurfaceLayerList.empty());
-    ASSERT(m_rootLayerImpl);
-    ASSERT(m_renderer); // For maxTextureSize.
+    DCHECK(renderSurfaceLayerList.empty());
+    DCHECK(m_rootLayerImpl);
+    DCHECK(m_renderer); // For maxTextureSize.
 
     {
         updateRootScrollLayerImplTransform();
 
         TRACE_EVENT0("cc", "CCLayerTreeHostImpl::calcDrawEtc");
         CCLayerTreeHostCommon::calculateDrawTransforms(m_rootLayerImpl.get(), deviceViewportSize(), m_deviceScaleFactor, &m_layerSorter, rendererCapabilities().maxTextureSize, renderSurfaceLayerList);
 
         trackDamageForAllSurfaces(m_rootLayerImpl.get(), renderSurfaceLayerList);
     }
 }
 
 void CCLayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<CCRenderPass> renderPass)
 {
     CCRenderPass* pass = renderPass.get();
     renderPasses.push_back(pass);
     renderPassesById.set(pass->id(), renderPass.Pass());
 }
 
 bool CCLayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
 {
-    ASSERT(frame.renderPasses.empty());
+    DCHECK(frame.renderPasses.empty());
 
     calculateRenderSurfaceLayerList(*frame.renderSurfaceLayerList);
 
     TRACE_EVENT1("cc", "CCLayerTreeHostImpl::calculateRenderPasses", "renderSurfaceLayerList.size()", static_cast<long long unsigned>(frame.renderSurfaceLayerList->size()));
 
     // Create the render passes in dependency order.
     for (int surfaceIndex = frame.renderSurfaceLayerList->size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         CCLayerImpl* renderSurfaceLayer = (*frame.renderSurfaceLayerList)[surfaceIndex];
         renderSurfaceLayer->renderSurface()->appendRenderPasses(frame);
     }
@@ skipping 55 matching lines @@
 
         if (appendQuadsData.hadMissingTiles) {
             bool layerHasAnimatingTransform = it->screenSpaceTransformIsAnimating() || it->drawTransformIsAnimating();
             if (layerHasAnimatingTransform || CCSettings::jankInsteadOfCheckerboard())
                 drawFrame = false;
         }
 
         occlusionTracker.leaveLayer(it);
     }
 
-#if !ASSERT_DISABLED
+#ifndef NDEBUG
     for (size_t i = 0; i < frame.renderPasses.size(); ++i) {
-        for (size_t j = 0; j < frame.renderPasses[i]->quadList().size(); ++j)
-            ASSERT(frame.renderPasses[i]->quadList()[j]->sharedQuadStateId() >= 0);
-        ASSERT(frame.renderPassesById.contains(frame.renderPasses[i]->id()));
+      for (size_t j = 0; j < frame.renderPasses[i]->quadList().size(); ++j)
+        DCHECK(frame.renderPasses[i]->quadList()[j]->sharedQuadStateId() >= 0);
+      DCHECK(frame.renderPassesById.contains(frame.renderPasses[i]->id()));
     }
 #endif
 
     if (!m_hasTransparentBackground) {
         frame.renderPasses.back()->setHasTransparentBackground(false);
         frame.renderPasses.back()->appendQuadsToFillScreen(m_rootLayerImpl.get(), m_backgroundColor, occlusionTracker);
     }
 
     if (drawFrame)
         occlusionTracker.overdrawMetrics().recordMetrics(this);
@@ skipping 47 matching lines @@
     // TODO(aelias): Hardcoding the first child here is weird. Think of
     // a cleaner way to get the contentBounds on the Impl side.
     if (!m_rootScrollLayerImpl || m_rootScrollLayerImpl->children().isEmpty())
         return IntSize();
     return m_rootScrollLayerImpl->children()[0]->contentBounds();
 }
 
 static inline CCRenderPass* findRenderPassById(CCRenderPass::Id renderPassId, const CCLayerTreeHostImpl::FrameData& frame)
 {
     CCRenderPassIdHashMap::const_iterator it = frame.renderPassesById.find(renderPassId);
-    ASSERT(it != frame.renderPassesById.end());
+    DCHECK(it != frame.renderPassesById.end());
     return it->second;
 }
 
 static void removeRenderPassesRecursive(CCRenderPass::Id removeRenderPassId, CCLayerTreeHostImpl::FrameData& frame)
 {
     CCRenderPass* removeRenderPass = findRenderPassById(removeRenderPassId, frame);
     CCRenderPassList& renderPasses = frame.renderPasses;
     CCRenderPassList::iterator toRemove = std::find(renderPasses.begin(), renderPasses.end(), removeRenderPass);
 
     // The pass was already removed by another quad - probably the original, and we are the replica.
@@ skipping 71 matching lines @@
                 continue;
 
             // We are changing the vector in the middle of iteration. Because we
             // delete render passes that draw into the current pass, we are
             // guaranteed that any data from the iterator to the end will not
             // change. So, capture the iterator position from the end of the
             // list, and restore it after the change.
             int positionFromEnd = frame.renderPasses.size() - it;
             removeRenderPassesRecursive(renderPassQuad->renderPassId(), frame);
             it = frame.renderPasses.size() - positionFromEnd;
-            ASSERT(it >= 0);
+            DCHECK(it >= 0);
         }
     }
 }
 
 bool CCLayerTreeHostImpl::prepareToDraw(FrameData& frame)
 {
     TRACE_EVENT0("cc", "CCLayerTreeHostImpl::prepareToDraw");
-    ASSERT(canDraw());
+    DCHECK(canDraw());
 
     frame.renderSurfaceLayerList = &m_renderSurfaceLayerList;
     frame.renderPasses.clear();
     frame.renderPassesById.clear();
     frame.renderSurfaceLayerList->clear();
     frame.willDrawLayers.clear();
 
     if (!calculateRenderPasses(frame))
         return false;
 
     // If we return true, then we expect drawLayers() to be called before this function is called again.
     return true;
 }
 
 void CCLayerTreeHostImpl::reduceContentsTextureMemoryOnImplThread(size_t limitBytes)
 {
     bool evictedResources = m_client->reduceContentsTextureMemoryOnImplThread(limitBytes);
     if (evictedResources) {
         setContentsTexturesPurged();
         m_client->setNeedsCommitOnImplThread();
         m_client->onCanDrawStateChanged(canDraw());
     }
 }
 
 void CCLayerTreeHostImpl::setMemoryAllocationLimitBytes(size_t bytes)
 {
-    ASSERT(bytes);
+    DCHECK(bytes);
     if (m_memoryAllocationLimitBytes == bytes)
         return;
     m_memoryAllocationLimitBytes = bytes;
     reduceContentsTextureMemoryOnImplThread(m_visible ? m_memoryAllocationLimitBytes : 0);
     m_client->setNeedsCommitOnImplThread();
 }
 
 void CCLayerTreeHostImpl::onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds)
 {
     m_client->onVSyncParametersChanged(monotonicTimebase, intervalInSeconds);
 }
 
 void CCLayerTreeHostImpl::drawLayers(const FrameData& frame)
 {
     TRACE_EVENT0("cc", "CCLayerTreeHostImpl::drawLayers");
-    ASSERT(canDraw());
-    ASSERT(!frame.renderPasses.empty());
+    DCHECK(canDraw());
+    DCHECK(!frame.renderPasses.empty());
 
     // FIXME: use the frame begin time from the overall compositor scheduler.
     // This value is currently inaccessible because it is up in Chromium's
     // RenderWidget.
     m_fpsCounter->markBeginningOfFrame(base::TimeTicks::Now());
 
     if (m_settings.showDebugRects())
         m_debugRectHistory->saveDebugRectsForCurrentFrame(m_rootLayerImpl.get(), *frame.renderSurfaceLayerList, frame.occludingScreenSpaceRects, settings());
 
     // Because the contents of the HUD depend on everything else in the frame, the contents
@@ skipping 35 matching lines @@
     return m_renderer && m_renderer->isContextLost();
 }
 
 const RendererCapabilities& CCLayerTreeHostImpl::rendererCapabilities() const
 {
     return m_renderer->capabilities();
 }
 
 bool CCLayerTreeHostImpl::swapBuffers()
 {
-    ASSERT(m_renderer);
+    DCHECK(m_renderer);
 
     m_fpsCounter->markEndOfFrame();
     return m_renderer->swapBuffers();
 }
 
 const IntSize& CCLayerTreeHostImpl::deviceViewportSize() const
 {
     return m_deviceViewportSize;
 }
 
 const CCLayerTreeSettings& CCLayerTreeHostImpl::settings() const
 {
     return m_settings;
 }
 
 void CCLayerTreeHostImpl::didLoseContext()
 {
     m_client->didLoseContextOnImplThread();
 }
 
 void CCLayerTreeHostImpl::onSwapBuffersComplete()
 {
     m_client->onSwapBuffersCompleteOnImplThread();
 }
 
 void CCLayerTreeHostImpl::readback(void* pixels, const IntRect& rect)
 {
-    ASSERT(m_renderer);
+    DCHECK(m_renderer);
     m_renderer->getFramebufferPixels(pixels, rect);
 }
 
 static CCLayerImpl* findRootScrollLayer(CCLayerImpl* layer)
 {
     if (!layer)
         return 0;
 
     if (layer->scrollable())
         return layer;
@@ skipping 43 matching lines @@
     // Clear all data structures that have direct references to the layer tree.
     m_scrollingLayerIdFromPreviousTree = m_currentlyScrollingLayerImpl ? m_currentlyScrollingLayerImpl->id() : -1;
     m_currentlyScrollingLayerImpl = 0;
     m_renderSurfaceLayerList.clear();
 
     return m_rootLayerImpl.Pass();
 }
 
 void CCLayerTreeHostImpl::setVisible(bool visible)
 {
-    ASSERT(CCProxy::isImplThread());
+    DCHECK(CCProxy::isImplThread());
 
     if (m_visible == visible)
         return;
     m_visible = visible;
     didVisibilityChange(this, m_visible);
     reduceContentsTextureMemoryOnImplThread(m_visible ? m_memoryAllocationLimitBytes : 0);
 
     if (!m_renderer)
         return;
 
@@ skipping 185 matching lines @@
     m_renderSurfaceLayerList.clear();
     calculateRenderSurfaceLayerList(m_renderSurfaceLayerList);
 
     return m_renderSurfaceLayerList.size();
 }
 
 CCInputHandlerClient::ScrollStatus CCLayerTreeHostImpl::scrollBegin(const IntPoint& viewportPoint, CCInputHandlerClient::ScrollInputType type)
 {
     TRACE_EVENT0("cc", "CCLayerTreeHostImpl::scrollBegin");
 
-    ASSERT(!m_currentlyScrollingLayerImpl);
+    DCHECK(!m_currentlyScrollingLayerImpl);
     clearCurrentlyScrollingLayer();
 
     if (!ensureRenderSurfaceLayerList())
         return ScrollIgnored;
 
     IntPoint deviceViewportPoint = viewportPoint;
     deviceViewportPoint.scale(m_deviceScaleFactor, m_deviceScaleFactor);
 
     // First find out which layer was hit from the saved list of visible layers
     // in the most recent frame.
@@ skipping 33 matching lines @@
         m_numImplThreadScrolls++;
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
 
 static FloatSize scrollLayerWithScreenSpaceDelta(CCPinchZoomViewport* viewport, CCLayerImpl& layerImpl, const FloatPoint& screenSpacePoint, const FloatSize& screenSpaceDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
-    ASSERT(layerImpl.screenSpaceTransform().isInvertible());
+    DCHECK(layerImpl.screenSpaceTransform().isInvertible());
     WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceTransform().inverse();
 
     // First project the scroll start and end points to local layer space to find the scroll delta
     // in layer coordinates.
     bool startClipped, endClipped;
     FloatPoint screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta;
     FloatPoint localStartPoint = CCMathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, startClipped);
     FloatPoint localEndPoint = CCMathUtil::projectPoint(inverseScreenSpaceTransform, screenSpaceEndPoint, endClipped);
 
     // In general scroll point coordinates should not get clipped.
-    ASSERT(!startClipped);
-    ASSERT(!endClipped);
+    DCHECK(!startClipped);
+    DCHECK(!endClipped);
     if (startClipped || endClipped)
         return FloatSize();
 
     // Apply the scroll delta.
     FloatSize previousDelta(layerImpl.scrollDelta());
     FloatSize unscrolled = layerImpl.scrollBy(localEndPoint - localStartPoint);
 
     if (viewport)
         viewport->applyScroll(unscrolled);
 
     // Calculate the applied scroll delta in screen space coordinates.
     FloatPoint actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() - previousDelta;
     FloatPoint actualScreenSpaceEndPoint = CCMathUtil::mapPoint(layerImpl.screenSpaceTransform(), actualLocalEndPoint, endClipped);
-    ASSERT(!endClipped);
+    DCHECK(!endClipped);
     if (endClipped)
         return FloatSize();
     return actualScreenSpaceEndPoint - screenSpacePoint;
 }
 
 static FloatSize scrollLayerWithLocalDelta(CCLayerImpl& layerImpl, const FloatSize& localDelta)
 {
     FloatSize previousDelta(layerImpl.scrollDelta());
     layerImpl.scrollBy(localDelta);
     return layerImpl.scrollDelta() - previousDelta;
@@ skipping 267 matching lines @@
     setBackgroundTickingEnabled(!m_visible && m_needsAnimateLayers);
 }
 
 base::TimeDelta CCLayerTreeHostImpl::lowFrequencyAnimationInterval() const
 {
     return base::TimeDelta::FromSeconds(1);
 }
 
 void CCLayerTreeHostImpl::sendDidLoseContextRecursive(CCLayerImpl* current)
 {
-    ASSERT(current);
+    DCHECK(current);
     current->didLoseContext();
     if (current->maskLayer())
         sendDidLoseContextRecursive(current->maskLayer());
     if (current->replicaLayer())
         sendDidLoseContextRecursive(current->replicaLayer());
     for (size_t i = 0; i < current->children().size(); ++i)
         sendDidLoseContextRecursive(current->children()[i]);
 }
 
 static void clearRenderSurfacesOnCCLayerImplRecursive(CCLayerImpl* current)
 {
-    ASSERT(current);
+    DCHECK(current);
     for (size_t i = 0; i < current->children().size(); ++i)
         clearRenderSurfacesOnCCLayerImplRecursive(current->children()[i]);
     current->clearRenderSurface();
 }
 
 void CCLayerTreeHostImpl::clearRenderSurfaces()
 {
     clearRenderSurfacesOnCCLayerImplRecursive(m_rootLayerImpl.get());
     m_renderSurfaceLayerList.clear();
 }
@@ skipping 43 matching lines @@
 
     CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], monotonicTime);
 }
 
 }  // namespace cc