Various cleanups to compositing code

Source/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 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 246 matching lines @@
     lifecycle().advanceTo(DocumentLifecycle::InCompositingUpdate);
 
     updateIfNeeded();
 
     lifecycle().advanceTo(DocumentLifecycle::CompositingClean);
 
     DocumentAnimations::startPendingAnimations(m_renderView.document());
     // TODO: Figure out why this fails on Chrome OS login page. crbug.com/365507
     // ASSERT(lifecycle().state() == DocumentLifecycle::CompositingClean);
 
+#if ASSERT_ENABLED
     assertNoUnresolvedDirtyBits();
     for (LocalFrame* child = m_renderView.frameView()->frame().tree().firstChild(); child; child = child->tree().nextSibling())
         child->contentRenderer()->compositor()->assertNoUnresolvedDirtyBits();
+#endif
 }
 
 void RenderLayerCompositor::setNeedsCompositingUpdate(CompositingUpdateType updateType)
 {
     ASSERT(updateType != CompositingUpdateNone);
     // FIXME: Technically we only need to do this when the FrameView's isScrollable method
     // would return a different value.
     if (updateType == CompositingUpdateAfterLayout)
         m_rootShouldAlwaysCompositeDirty = true;
 
     // FIXME: This function should only set dirty bits. We shouldn't
     // enable compositing mode here.
     // We check needsLayout here because we don't know if we need to enable
     // compositing mode until layout is up-to-date because we need to know
     // if this frame scrolls.
     if (!m_renderView.needsLayout())
         enableCompositingModeIfNeeded();
 
     m_pendingUpdateType = std::max(m_pendingUpdateType, updateType);
 
     page()->animator().scheduleVisualUpdate();
     lifecycle().ensureStateAtMost(DocumentLifecycle::LayoutClean);
 }
 
+#if ASSERT_ENABLED
+
 void RenderLayerCompositor::assertNoUnresolvedDirtyBits()
 {
     ASSERT(!compositingLayersNeedRebuild());
     ASSERT(m_pendingUpdateType == CompositingUpdateNone);
     ASSERT(!m_rootShouldAlwaysCompositeDirty);
 }
 
+#endif
+
 void RenderLayerCompositor::applyOverlayFullscreenVideoAdjustment()
 {
     if (!m_rootContentLayer)
         return;
 
     bool isMainFrame = m_renderView.frame()->isMainFrame();
     RenderVideo* video = findFullscreenVideoRenderer(m_renderView.document());
     if (!video || !video->hasCompositedLayerMapping()) {
         if (isMainFrame) {
             GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer();
@@ skipping 34 matching lines @@
 
     CompositingUpdateType updateType = m_pendingUpdateType;
     bool needHierarchyAndGeometryUpdate = compositingLayersNeedRebuild();
 
     m_pendingUpdateType = CompositingUpdateNone;
     m_compositingLayersNeedRebuild = false;
 
     if (!hasAcceleratedCompositing())
         return;
 
-    bool needsToUpdateScrollingCoordinator = scrollingCoordinator() ? scrollingCoordinator()->needsToUpdateAfterCompositingChange() : false;
+    bool needsToUpdateScrollingCoordinator = scrollingCoordinator() && scrollingCoordinator()->needsToUpdateAfterCompositingChange();
     if (updateType == CompositingUpdateNone && !needHierarchyAndGeometryUpdate && !needsToUpdateScrollingCoordinator)
         return;
 
     GraphicsLayerUpdater::UpdateType graphicsLayerUpdateType = GraphicsLayerUpdater::DoNotForceUpdate;
     CompositingPropertyUpdater::UpdateType compositingPropertyUpdateType = CompositingPropertyUpdater::DoNotForceUpdate;
 
     // FIXME: Teach non-style compositing updates how to do partial tree walks.
     if (updateType >= CompositingUpdateAfterLayout) {
         graphicsLayerUpdateType = GraphicsLayerUpdater::ForceUpdate;
         compositingPropertyUpdateType = CompositingPropertyUpdater::ForceUpdate;
@@ skipping 14 matching lines @@
 
         CompositingRequirementsUpdater(m_renderView, m_compositingReasonFinder).update(updateRoot);
 
         {
             TRACE_EVENT0("blink_rendering", "CompositingLayerAssigner::assign");
             CompositingLayerAssigner(this).assign(updateRoot, layersChanged);
         }
 
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::updateAfterCompositingChange");
-            const FrameView::ScrollableAreaSet* scrollableAreas = m_renderView.frameView()->scrollableAreas();
-            if (scrollableAreas) {
+            if (const FrameView::ScrollableAreaSet* scrollableAreas = m_renderView.frameView()->scrollableAreas()) {
                 for (FrameView::ScrollableAreaSet::iterator it = scrollableAreas->begin(); it != scrollableAreas->end(); ++it)
                     (*it)->updateAfterCompositingChange();
             }
         }
 
         if (layersChanged)
             needHierarchyAndGeometryUpdate = true;
     }
 
     if (updateType != CompositingUpdateNone || needHierarchyAndGeometryUpdate) {
@@ skipping 981 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore