Avoid compositing fixed-position elements if they cannot scroll

Source/core/rendering/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 1916 matching lines @@
     }
 
     // Don't promote fixed position elements that are descendants of a non-view container, e.g. transformed elements.
     // They will stay fixed wrt the container rather than the enclosing frame.
     if (container != m_renderView) {
         if (viewportConstrainedNotCompositedReason)
             *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForNonViewContainer;
         return false;
     }
     
+    // If the fixed-position element does not have any scrollable ancestor between it and
+    // its container, then we do not need to spend compositor resources for it. Start by
+    // assuming we can opt-out (i.e. no scrollable ancestor), and refine the answer below.
+    bool noScrollableAncestor = true;
+
+    // The FrameView has the scrollbars associated with the top level viewport, so we have to
+    // check the FrameView in addition to the hierarchy of ancestors.
+    if (m_renderView->frameView() && (m_renderView->frameView()->isScrollable()))
+        noScrollableAncestor = false;
+
+    RenderLayer* ancestor = layer->parent();
+    while (ancestor && noScrollableAncestor) {

[jamesr, 2013/04/20 01:24:10]

this seems too slow.  This function is called from RenderLayer::styleChanged ->
RenderLayerCompositor::updateCompositingState ->
RenderLayerCompositor::updateBacking ->
RenderLayerCompositor::needsToBeComposited ->
RenderLayerCompositor::requiresCompositingLayer

In other words, it's called for every RenderObject that has a RenderLayer
whenever the style changes.  For a full document style recalc, this means that
on every element we're going to do a walk potentially back up to the root of the
render layer tree for every render layer making the operation O(N * depth).  Is
there no better way to figure this out?  Could this be done at a later step
instead of on every style change?

I'm working on trying to defer this work more in general but that's not in place
yet.

[shawnsingh, 2013/04/21 00:22:21]

This only occurs for fixed-position elements. The assumption is that (1) there
will be relatively few fixed-pos elements on a page, and (2) They are unlikely
to be too deep in the RenderObject / RenderLayer hierarchy.

Does that change your opinion about slowness?  Do you want me to get some
numbers?

The more general comment you're making is that computeCompositingRequirements is
itself fairly slow, and likely called far more often than needed (whenever style
changes).  In addition to the work you're proposing to call it fewer times per
update, we also have a bug to look at how to improve its performance each time
its called.

+        if (ancestor->hasScrollbars())
+            noScrollableAncestor = false;
+        if (ancestor->renderer() == container)

[jamesr, 2013/04/20 01:24:10]

since we've checked explicitly for transformed containers on line 1929, can this
check ever return for something other than the RenderView?

[shawnsingh, 2013/04/21 00:22:21]

No, it can't.  You're right that container is the renderView at this point in
code.  Did you want me to use isRenderView() instead?  I felt this is more
general.

+            break;
+        ancestor = ancestor->parent();
+    }
+
+    if (noScrollableAncestor) {
+        if (viewportConstrainedNotCompositedReason)
+            *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForUnscrollableAncestors;
+        return false;
+    }
+
     // Subsequent tests depend on layout. If we can't tell now, just keep things the way they are until layout is done.
     if (!m_inPostLayoutUpdate) {
         m_reevaluateCompositingAfterLayout = true;
         return layer->isComposited();
     }
 
     bool paintsContent = layer->isVisuallyNonEmpty() || layer->hasVisibleDescendant();
     if (!paintsContent) {
         if (viewportConstrainedNotCompositedReason)
             *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForNoVisibleContent;
@@ skipping 833 matching lines @@
     info.addMember(m_layerForOverhangAreas, "layerForOverhangAreas");
     info.addMember(m_contentShadowLayer, "contentShadowLayer");
     info.addMember(m_layerForTopOverhangArea, "layerForTopOverhangArea");
     info.addMember(m_layerForBottomOverhangArea, "layerForBottomOverhangArea");
     info.addMember(m_layerForHeader, "layerForHeader");
     info.addMember(m_layerForFooter, "layerForFooter");
 #endif
 }
 
 } // namespace WebCore