Currently we only composite fixed position elements if we are on High DPI devices. This fix allows …

Source/core/layout/compositing/CompositingReasonFinder.cpp

Index: Source/core/layout/compositing/CompositingReasonFinder.cpp
diff --git a/Source/core/layout/compositing/CompositingReasonFinder.cpp b/Source/core/layout/compositing/CompositingReasonFinder.cpp
index b67ab287deb037fe0cfac35373bbdb880c2382a1..262d5ac52e53208de5a5f4d4195d1c5092360080 100644
--- a/Source/core/layout/compositing/CompositingReasonFinder.cpp
+++ b/Source/core/layout/compositing/CompositingReasonFinder.cpp
@@ -179,11 +179,24 @@ bool CompositingReasonFinder::requiresCompositingForAnimation(const ComputedStyl
 
 bool CompositingReasonFinder::requiresCompositingForPositionFixed(const DeprecatedPaintLayer* layer) const
 {
-    if (!(m_compositingTriggers & ViewportConstrainedPositionedTrigger))
-        return false;
     // 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.
-    return layer->scrollsWithViewport() && m_layoutView.frameView()->isScrollable();
+    if (!layer->scrollsWithViewport() || !m_layoutView.frameView()->isScrollable())
+        return false;
+
+    if (m_compositingTriggers & ViewportConstrainedPositionedTrigger)
+        return true;
+
+    // If the layer is opaque we can still promote it since we will not lose LCD text
+    LayoutRect bounds = layer->physicalBoundingBox(layer);
+    const DeprecatedPaintLayer* currentChild = layer->firstChild();
+    // Include any possible overflow from children
+    for (; currentChild; currentChild = currentChild->nextSibling()) {
+        LayoutRect childBounds = currentChild->physicalBoundingBox(layer);
+        bounds.unite(childBounds);
+    }

[trchen, 2015/09/17 21:40:33]

A few problem here:
1. This only adds the overflow from direct children, but we want to take every
descendant layer into consideration.
2. Need to translate from local coordinate of the descandant to the current
layer before uniting the rects.

You may refer to
DPL::physicalBoundingBoxIncludingReflectionAndStackingChildren() to how it's
done. Perhaps adding an enum option for it to ignore compositing state then it
would be good to go.

I'm a little bit worried though, because it will increase the time complexity of
compositing decision from O(1) to O(N) per layer, where N is the number of layer
in the subtree. You may want a second opinion from a compositing expert.

[Ian Vollick, 2015/09/18 02:09:50]

Yes, this is indeed too slow. If you look at
DeprecatedPaintLayer::backgroundIsKnownToBeOpaqueInRect, there's a hidden O(N)
in there, too, if the queried rect is outside its "local" bounds (though this
shouldn't happen too often).

I think we may be able to piggyback on some existing code to get this rect.
Correct me if I'm wrong, but  what I think we're after here is the composited
bounds (see CompositedDeprecatedPaintLayerMapping::compositedBounds). We
_almost_ compute this value anyhow here:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

..except we clip it away somewhat. Perhaps we could cache the background rect we
compute here before we clip it and use it for our opaqueness test.

[davidfox, 2015/09/18 02:55:40]

Sorry for the "double" post. Initially replied to this via my mobile email haha

1. When and how often is CompositingInputsUpdater::updateRecursive invoked? Is
it only called for layers decided to be composited?

2. Are you envisioning it working something like this?:
- Add a method to DepreatedPaintLayer (or where best fit) to calculate its full
background rect and cache the result.

- Update CompositingInputsUpdater::updateRecursive to clip the result from the
above method, instead of calculating it on its own. This would be the primary
way the cache is kept up to date.

- Add a simple getter to retrieve the cached rect. To be used in
CompositingReasonFinder::requiresCompositingForPositionFixed

+
+    return layer->backgroundIsKnownToBeOpaqueInRect(bounds);
 }
 
 }