optimizing layout performance when only transform3d matrix changed by

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 193 matching lines @@
     , m_showRepaintCounter(false)
     , m_needsToRecomputeCompositingRequirements(false)
     , m_needsToUpdateLayerTreeGeometry(false)
     , m_pendingUpdateType(GraphicsLayerUpdater::DoNotForceUpdate)
     , m_compositing(false)
     , m_compositingLayersNeedRebuild(false)
     , m_forceCompositingMode(false)
     , m_needsUpdateCompositingRequirementsState(false)
     , m_isTrackingRepaints(false)
     , m_rootLayerAttachment(RootLayerUnattached)
+    , m_layersChanged(true)
 {
 }
 
 RenderLayerCompositor::~RenderLayerCompositor()
 {
     ASSERT(m_rootLayerAttachment == RootLayerUnattached);
 }
 
 void RenderLayerCompositor::enableCompositingMode(bool enable /* = true */)
 {
@@ skipping 152 matching lines @@
         m_pendingUpdateType = GraphicsLayerUpdater::ForceUpdate;
         break;
     case CompositingUpdateOnCompositedScroll:
         m_needsToUpdateLayerTreeGeometry = true;
         // FIXME: Ideally we'd be smarter about tracking dirtiness and wouldn't need a ForceUpdate here.
         m_pendingUpdateType = GraphicsLayerUpdater::ForceUpdate;
         break;
     case CompositingUpdateAfterCanvasContextChange:
         m_needsToUpdateLayerTreeGeometry = true;
         break;
+    case CompositingMinUpdateAfterStyleChange:
+        if (m_layersChanged)

[Ian Vollick, 2014/03/18 11:59:16]

I think this is a layering violation. If I'm understanding this correctly, this
code is saying "if the layers changed the last time we computed compositing
requirements, we need to update the compositing requirements". It seems too late
at that point.

[yaojie.yan, 2014/03/20 07:43:19]

Yes, but my REAL purpose is to add some heuristic information here, if the
composting reasons did not changes for a long time, we will not need to
recomputingCompostingReasons for just transforms3d. I think there is the
tradeoff. Since it is a much overhead to recomputingCompostingReasons with
overlap for overmuch-layers page. Is it worthy to computing a pretty accurate a
GraphicsLayers Tree for just transforms3d case?

On 2014/03/18 11:59:16, Ian Vollick wrote:

+            m_needsToRecomputeCompositingRequirements = true;
+        else
+            m_needsToUpdateLayerTreeGeometry = true;
+        break;
+
     }
 
     m_renderView.frameView()->scheduleAnimation();
 }
 
 void RenderLayerCompositor::updateCompositingLayers()
 {
     TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::updateCompositingLayers");
 
     // FIXME: We should carefully clean up the awkward early-exit semantics, balancing
@@ skipping 70 matching lines @@
 
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::updateHasVisibleNonLayerContentLoop");
             const FrameView::ScrollableAreaSet* scrollableAreas = m_renderView.frameView()->scrollableAreas();
             if (scrollableAreas) {
                 for (FrameView::ScrollableAreaSet::iterator it = scrollableAreas->begin(); it != scrollableAreas->end(); ++it)
                     (*it)->updateHasVisibleNonLayerContent();
             }
         }
 
+        m_layersChanged = layersChanged;

[Ian Vollick, 2014/03/18 11:59:16]

This value should not persist from update to update.

         if (layersChanged)
             needHierarchyAndGeometryUpdate = true;
     }
 
     if (needHierarchyAndGeometryUpdate) {
         // Update the hierarchy of the compositing layers.
         GraphicsLayerVector childList;
         {
             TRACE_EVENT0("blink_rendering", "GraphicsLayerUpdater::rebuildTree");
             GraphicsLayerUpdater(m_renderView).rebuildTree(*updateRoot, updateType, childList, 0);
         }
 
         // Host the document layer in the RenderView's root layer.
         if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled() && isMainFrame()) {
             RenderVideo* video = findFullscreenVideoRenderer(m_renderView.document());
             if (video && video->hasCompositedLayerMapping()) {
                 childList.clear();
                 childList.append(video->compositedLayerMapping()->mainGraphicsLayer());
             }
         }
 
         if (childList.isEmpty())
             destroyRootLayer();
-        else
+        else if (m_rootContentLayer)
             m_rootContentLayer->setChildren(childList);
     } else if (needGeometryUpdate) {
         // We just need to do a geometry update. This is only used for position:fixed scrolling;
         // most of the time, geometry is updated via RenderLayer::styleChanged().
         TRACE_EVENT0("blink_rendering", "GraphicsLayerUpdater::updateRecursive");
         GraphicsLayerUpdater(m_renderView).updateRecursive(*updateRoot, updateType);
     }
 
     ASSERT(updateRoot || !m_compositingLayersNeedRebuild);
 
@@ skipping 1733 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore