Disable clipping on root scroller's ancestors.

third_party/WebKit/Source/core/page/scrolling/RootScrollerController.cpp

 // Copyright 2016 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 "core/page/scrolling/RootScrollerController.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/api/LayoutViewItem.h"
+#include "core/layout/compositing/PaintLayerCompositor.h"
+#include "core/paint/PaintLayer.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/scroll/ScrollableArea.h"
 
 namespace blink {
 
 class RootFrameViewport;
 
 namespace {
 
@@ skipping 58 matching lines @@
 
 void RootScrollerController::didUpdateLayout()
 {
     recomputeEffectiveRootScroller();
 }
 
 void RootScrollerController::globalRootScrollerMayHaveChanged()
 {
 }
 
+void RootScrollerController::setNeedsCompositingInputsUpdateOnAncestorChain(
+    PaintLayer* layer)
+{
+    if (layer) {
+        while (layer) {
+            layer->setNeedsCompositingInputsUpdate();

[bokan, 2016/09/09 00:19:03]

I set this on all ancestor layers since we need a GraphicsLayerUpdate on all the
ancestor CompositedLayerMappings which only happens if the associated layer has
needsCompositingInputsUpdate during CompositingInputsUpdater 
(https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/layout/co...)
but I couldn't find a way to make just setting the current layer break in
practice? Is this right or is it overkill?

[chrishtr, 2016/09/09 18:21:16]

I think it's overkill. PaintLayer::setNeedsCompositingInputsUpdate() already
updates all ancestor PaintLayers. Does it not work? See:

https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/paint/Pai...

[bokan, 2016/09/10 00:05:54]

My read of that is that it ensures we recursively descend into
CompositingInputsUpdater::updateRecursive but it doesn't ensure we
setNeedsGraphicsLayerUpdate at
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/layout/co...

It seems to be the difference between m_childNeedsCompositingInputsUpdate and
m_needsDescendantDependentCompositingInputsUpdate.

This isn't needed for any of my tests nor could I find an example where it
breaks but I'm worried that might just be because of simple cases. In the
examples I stepped through we always ended up calling
setNeedsGraphicsLayerUpdate with the Subtree scope because the root layer needed
a compositing inputs update.

I'm happy to remove the loop and see if we find any cases through usage. OTOH,
changing root scrollers should be exceedingly rare so it shouldn't be a perf hit
either. Let me know which you'd prefer.

[chrishtr, 2016/09/12 21:01:28]

Oh in that case you just need
setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree) on the root. or
setNeedsCompositingUpdate(CompositingUpdateRebuildTree).

[bokan, 2016/09/13 20:40:51]

Ok, I used setNeedsCompositingUpdate since I can't touch compositing state from
here.

+            layer = layer->parent();
+        }
+    }
+}
+
 void RootScrollerController::recomputeEffectiveRootScroller()
 {
     bool rootScrollerValid =
         m_rootScroller && isValidRootScroller(*m_rootScroller);
 
     Element* newEffectiveRootScroller = rootScrollerValid
         ? m_rootScroller.get()
         : defaultEffectiveRootScroller();
 
     if (m_effectiveRootScroller == newEffectiveRootScroller)
         return;
 
+    PaintLayer* oldRootScrollerLayer = rootScrollerPaintLayer();
+
     m_effectiveRootScroller = newEffectiveRootScroller;
 
+    setNeedsCompositingInputsUpdateOnAncestorChain(oldRootScrollerLayer);
+    setNeedsCompositingInputsUpdateOnAncestorChain(rootScrollerPaintLayer());
+
     m_document->topDocument().rootScrollerController()
         ->globalRootScrollerMayHaveChanged();
 }
 
 ScrollableArea* RootScrollerController::scrollableAreaFor(
     const Element& element) const
 {
     if (!element.layoutObject() || !element.layoutObject()->isBox())
         return nullptr;
 
@@ skipping 50 matching lines @@
     // no way to get at the ViewportScrollCallback so just return false.
     // TODO(bokan): Make document.rootScroller work in OOPIF. crbug.com/642378.
     if (!m_document->localOwner())
         return false;
 
     RootScrollerController* topDocumentController =
         m_document->topDocument().rootScrollerController();
     return topDocumentController->isViewportScrollCallback(callback);
 }
 
+PaintLayer* RootScrollerController::rootScrollerPaintLayer() const
+{
+    if (!m_effectiveRootScroller)
+        return nullptr;
+
+    LayoutBox* box = toLayoutBox(m_effectiveRootScroller->layoutObject());
+    if (!box)
+        return nullptr;
+
+    PaintLayer* layer = box->layer();
+
+    // If the root scroller is the <html> element we do a bit of a fake out because
+    // while <html> has a PaintLayer, scrolling for it is handled by the #document's
+    // PaintLayer (i.e. the PaintLayerCompositor's root layer). The reason the root
+    // scroller is the <html> layer and not #document is because the latter is a Node
+    // but not an Element.
+    if (m_effectiveRootScroller->isSameNode(m_document->documentElement()))
+        return layer->compositor()->rootLayer();
+
+    return layer;
+}
+
 Element* RootScrollerController::defaultEffectiveRootScroller()
 {
     DCHECK(m_document);
     return m_document->documentElement();
 }
 
 } // namespace blink