Disable clipping on root scroller's ancestors.

third_party/WebKit/Source/web/tests/RootScrollerTest.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/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/TopControls.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/LayoutBox.h"
+#include "core/layout/api/LayoutViewItem.h"
+#include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/RootScrollerController.h"
+#include "core/page/scrolling/TopDocumentRootScrollerController.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
 #include "public/web/WebCache.h"
 #include "public/web/WebConsoleMessage.h"
 #include "public/web/WebRemoteFrame.h"
 #include "public/web/WebScriptSource.h"
 #include "public/web/WebSettings.h"
@@ skipping 524 matching lines @@
             mainFrameView()->layerForScrolling());
         EXPECT_TRUE(mainController->isViewportScrollCallback(
             mainFrame()->document()->documentElement()->getApplyScroll()));
     }
 
     // Set a root scroller in the iframe. Since the main document didn't set a
     // root scroller, the global root scroller shouldn't change.
     {
 
         iframe->contentDocument()->setRootScroller(container, nonThrow);
+        mainFrameView()->updateAllLifecyclePhases();
 
         EXPECT_EQ(
             mainController->rootScrollerLayer(),
             mainFrameView()->layerForScrolling());
         EXPECT_TRUE(mainController->isViewportScrollCallback(
             mainFrame()->document()->documentElement()->getApplyScroll()));
     }
 
     // Setting the iframe as the root scroller in the main frame should now
     // link the root scrollers so the container should now be the global root
     // scroller.
     {
         mainFrame()->document()->setRootScroller(iframe, nonThrow);
+        mainFrameView()->updateAllLifecyclePhases();
 
         ScrollableArea* containerScroller =
             static_cast<PaintInvalidationCapableScrollableArea*>(
                 toLayoutBox(container->layoutObject())->getScrollableArea());
 
         EXPECT_EQ(
             mainController->rootScrollerLayer(),
             containerScroller->layerForScrolling());
         EXPECT_FALSE(mainController->isViewportScrollCallback(
             mainFrame()->document()->documentElement()->getApplyScroll()));
         EXPECT_TRUE(mainController->isViewportScrollCallback(
             container->getApplyScroll()));
     }
 
     // Unsetting the root scroller in the iframe should reset its effective
     // root scroller to the iframe's documentElement and thus the iframe's
     // documentElement becomes the global root scroller.
     {
         iframe->contentDocument()->setRootScroller(nullptr, nonThrow);
+        mainFrameView()->updateAllLifecyclePhases();
         EXPECT_EQ(
             mainController->rootScrollerLayer(),
             iframe->contentDocument()->view()->layerForScrolling());
         EXPECT_FALSE(mainController->isViewportScrollCallback(
             container->getApplyScroll()));
         EXPECT_FALSE(mainController->isViewportScrollCallback(
             mainFrame()->document()->documentElement()->getApplyScroll()));
         EXPECT_TRUE(mainController->isViewportScrollCallback(
             iframe->contentDocument()->documentElement()->getApplyScroll()));
     }
 
     // Finally, unsetting the main frame's root scroller should reset it to the
     // documentElement and corresponding layer.
     {
         mainFrame()->document()->setRootScroller(nullptr, nonThrow);
+        mainFrameView()->updateAllLifecyclePhases();
         EXPECT_EQ(
             mainController->rootScrollerLayer(),
             mainFrameView()->layerForScrolling());
         EXPECT_TRUE(mainController->isViewportScrollCallback(
             mainFrame()->document()->documentElement()->getApplyScroll()));
         EXPECT_FALSE(mainController->isViewportScrollCallback(
             container->getApplyScroll()));
         EXPECT_FALSE(mainController->isViewportScrollCallback(
             iframe->contentDocument()->documentElement()->getApplyScroll()));
     }
@@ skipping 137 matching lines @@
         // ViewportScrollCallback removed.  Keep the scrolls to guard crashes
         // but the expectations on when a ViewportScrollCallback have changed
         // and should be updated.
         // EXPECT_EQ(200, container->scrollTop());
     }
 
     // Reset explicitly to prevent lifetime issues with the RemoteFrameClient.
     m_helper.reset();
 }
 
+// Tests that clipping layers belonging to any compositors in the ancestor chain
+// of the global root scroller have their masking bit removed.
+TEST_F(RootScrollerTest, RemoveClippingOnCompositorLayers)
+{
+    // TODO(bokan): Remove casts to TDRSC once follow-up patch lands separating TDRSC
+    // from RootScrollerController.
+
+    initialize("root-scroller-iframe.html");
+
+    HTMLFrameOwnerElement* iframe = toHTMLFrameOwnerElement(
+        mainFrame()->document()->getElementById("iframe"));
+    Element* container =
+        iframe->contentDocument()->getElementById("container");
+
+    RootScrollerController* mainController =
+        mainFrame()->document()->rootScrollerController();
+    RootScrollerController* childController =
+        iframe->contentDocument()->rootScrollerController();
+
+    PaintLayerCompositor* mainCompositor =
+        mainFrameView()->layoutViewItem().compositor();
+    PaintLayerCompositor* childCompositor =
+        iframe->contentDocument()->view()->layoutViewItem().compositor();
+
+    NonThrowableExceptionState nonThrow;
+
+    // No root scroller set, on the main frame the root content layer should
+    // clip. Additionally, on the child frame, the overflow controls host and
+    // container layers should also clip.
+    {
+        EXPECT_TRUE(mainCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+
+        EXPECT_TRUE(childCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_TRUE(childCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_TRUE(childCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+    }
+
+    // Now set the root scrollers such that the container in the iframe is the
+    // global root scroller. All the previously clipping layers in both paint
+    // layer compositors should no longer clip.
+    {
+        iframe->contentDocument()->setRootScroller(container, nonThrow);
+        mainFrame()->document()->setRootScroller(iframe, nonThrow);
+        mainFrameView()->updateAllLifecyclePhases();
+
+        ASSERT_EQ(iframe, mainController->effectiveRootScroller());
+        ASSERT_EQ(container, childController->effectiveRootScroller());
+
+        EXPECT_FALSE(mainCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+
+        EXPECT_FALSE(childCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(childCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(childCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+    }
+
+    // Now reset the iframe's root scroller. Since the iframe itself is now the
+    // global root scroller we want it to behave as if it were the main frame, which
+    // means it should clip only on its root content layer.
+    {
+        iframe->contentDocument()->setRootScroller(nullptr, nonThrow);
+        mainFrameView()->updateAllLifecyclePhases();
+
+        ASSERT_EQ(iframe, mainController->effectiveRootScroller());
+        ASSERT_EQ(iframe->contentDocument()->documentElement(),
+            childController->effectiveRootScroller());
+        ASSERT_EQ(iframe->contentDocument()->documentElement(),
+            ((TopDocumentRootScrollerController*)mainController)
+                ->globalRootScroller());
+
+        EXPECT_FALSE(mainCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+
+        EXPECT_TRUE(childCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(childCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(childCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+    }
+
+    // Now reset the main frame's root scroller. Its compositor should go back
+    // to clipping as well. Because the iframe is now no longer the global root
+    // scroller, it should go back to clipping its overflow host and container
+    // layers. This checks that we invalidate the compositing state even though
+    // the iframe's effective root scroller hasn't changed.
+
+    {
+        mainFrame()->document()->setRootScroller(nullptr, nonThrow);
+        mainFrameView()->updateAllLifecyclePhases();
+
+        ASSERT_EQ(mainFrame()->document()->documentElement(),
+            mainController->effectiveRootScroller());
+        ASSERT_EQ(iframe->contentDocument()->documentElement(),
+            childController->effectiveRootScroller());
+        ASSERT_EQ(mainFrame()->document()->documentElement(),
+            ((TopDocumentRootScrollerController*)mainController)
+                ->globalRootScroller());
+
+        EXPECT_TRUE(mainCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+
+        EXPECT_TRUE(childCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_TRUE(childCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_TRUE(childCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+    }
+
+    // Set the iframe back as the main frame's root scroller. Since its the
+    // global root scroller again, it should clip like the root frame. This
+    // checks that we invalidate the compositing state even though the iframe's
+    // effective root scroller hasn't changed.
+    {
+        mainFrame()->document()->setRootScroller(iframe, nonThrow);
+        mainFrameView()->updateAllLifecyclePhases();
+
+        ASSERT_EQ(iframe, mainController->effectiveRootScroller());
+        ASSERT_EQ(iframe->contentDocument()->documentElement(),
+            childController->effectiveRootScroller());
+        ASSERT_EQ(iframe->contentDocument()->documentElement(),
+            ((TopDocumentRootScrollerController*)mainController)
+                ->globalRootScroller());
+
+        EXPECT_FALSE(mainCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+
+        EXPECT_TRUE(childCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(childCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(childCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+    }
+
+    // Set just the iframe's root scroller. We should stop clipping the
+    // iframe's compositor's layers but not the main frame's.
+    {
+        mainFrame()->document()->setRootScroller(nullptr, nonThrow);
+        iframe->contentDocument()->setRootScroller(container, nonThrow);
+        mainFrameView()->updateAllLifecyclePhases();
+
+        ASSERT_EQ(mainFrame()->document()->documentElement(),
+            mainController->effectiveRootScroller());
+        ASSERT_EQ(container, childController->effectiveRootScroller());
+
+        EXPECT_TRUE(mainCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(mainCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+
+        EXPECT_FALSE(childCompositor->rootContentLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(childCompositor->rootGraphicsLayer()->platformLayer()
+            ->masksToBounds());
+        EXPECT_FALSE(childCompositor->containerLayer()->platformLayer()
+            ->masksToBounds());
+    }
+}
+
 } // namespace
 
 } // namespace blink