[RLS] Don't create PaintLayerCompositor layers.

third_party/WebKit/Source/core/layout/compositing/PaintLayerCompositor.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 335 matching lines @@
   // anyway.
   layoutObject.clearPreviousVisualRects();
 
   for (LayoutObject* child = layoutObject.slowFirstChild(); child;
        child = child->nextSibling()) {
     if (!child->isPaintInvalidationContainer())
       forceRecomputeVisualRectsIncludingNonCompositingDescendants(*child);
   }
 }
 
+GraphicsLayer* PaintLayerCompositor::parentForContentLayers() const {
+  if (m_rootContentLayer)
+    return m_rootContentLayer.get();
+
+  DCHECK(RuntimeEnabledFeatures::rootLayerScrollingEnabled());
+  // Iframe content layers will be connected by the parent frame using
+  // attachFrameContentLayersToIframeLayer.
+  return isMainFrame() ? visualViewport().scrollLayer() : nullptr;
+}
+
 void PaintLayerCompositor::updateIfNeeded() {
   CompositingUpdateType updateType = m_pendingUpdateType;
   m_pendingUpdateType = CompositingUpdateNone;
 
   if (!hasAcceleratedCompositing()) {
     updateWithoutAcceleratedCompositing(updateType);
     return;
   }
 
   if (updateType == CompositingUpdateNone)
@@ skipping 71 matching lines @@
   }
 
   if (updateType >= CompositingUpdateRebuildTree) {
     GraphicsLayerVector childList;
     {
       TRACE_EVENT0("blink", "GraphicsLayerTreeBuilder::rebuild");
       GraphicsLayerTreeBuilder().rebuild(*updateRoot, childList);
     }
 
     if (!childList.isEmpty()) {
-      CHECK(m_rootContentLayer && m_compositing);
-      m_rootContentLayer->setChildren(childList);
+      CHECK(m_compositing);
+      if (GraphicsLayer* contentParent = parentForContentLayers())
+        contentParent->setChildren(childList);
     }
 
     applyOverlayFullscreenVideoAdjustmentIfNeeded();
   }
 
   if (m_needsUpdateFixedBackground) {
     rootFixedBackgroundsChanged();
     m_needsUpdateFixedBackground = false;
   }
 
@@ skipping 225 matching lines @@
                        AcceleratedFixedRootBackgroundHistogramMax));
   acceleratedBackgroundHistogram.count(ScrolledMainFrameBucket);
 }
 
 void PaintLayerCompositor::frameViewScrollbarsExistenceDidChange() {
   if (m_containerLayer)
     updateOverflowControlsLayers();
 }
 
 void PaintLayerCompositor::rootFixedBackgroundsChanged() {
-  if (!supportsFixedRootBackgroundCompositing())
+  if (!supportsFixedRootBackgroundCompositing() || !m_containerLayer)
     return;
 
   // To avoid having to make the fixed root background layer fixed positioned to
   // stay put, we position it in the layer tree as follows:
   //
   // + Overflow controls host
   //   + LocalFrame clip
   //     + (Fixed root background) <-- Here.
   //     + LocalFrame scroll
   //       + Root content layer
@@ skipping 11 matching lines @@
     return scrollingCoordinator->scrollableAreaScrollLayerDidChange(
         layer->getScrollableArea());
   return false;
 }
 
 std::unique_ptr<JSONObject> PaintLayerCompositor::layerTreeAsJSON(
     LayerTreeFlags flags) const {
   ASSERT(lifecycle().state() >= DocumentLifecycle::PaintInvalidationClean ||
          m_layoutView.frameView()->shouldThrottleRendering());
 
-  if (!m_rootContentLayer)
-    return nullptr;
-
   // We skip dumping the scroll and clip layers to keep layerTreeAsText output
   // similar between platforms (unless we explicitly request dumping from the
   // root.
   GraphicsLayer* rootLayer = m_rootContentLayer.get();
+  if (!rootLayer)
+    rootLayer = rootGraphicsLayer();
+
+  if (!rootLayer)
+    return nullptr;
+
   if (flags & LayerTreeIncludesRootLayer) {
     if (isMainFrame()) {
       while (rootLayer->parent())
         rootLayer = rootLayer->parent();
     } else {
       rootLayer = rootGraphicsLayer();
     }
   }
 
   return rootLayer->layerTreeAsJSON(flags);
@@ skipping 17 matching lines @@
   PaintLayerCompositor* innerCompositor = frameContentsCompositor(layoutObject);
   if (!innerCompositor || !innerCompositor->staleInCompositingMode() ||
       innerCompositor->m_rootLayerAttachment !=
           RootLayerAttachedViaEnclosingFrame)
     return false;
 
   PaintLayer* layer = layoutObject.layer();
   if (!layer->hasCompositedLayerMapping())
     return false;
 
+  DisableCompositingQueryAsserts disabler;
   layer->compositedLayerMapping()->setSublayers(
       GraphicsLayerVector(1, innerCompositor->rootGraphicsLayer()));
   return true;
 }
 
 static void fullyInvalidatePaintRecursive(PaintLayer* layer) {
   if (layer->compositingState() == PaintsIntoOwnBacking) {
     layer->compositedLayerMapping()->setContentsNeedDisplay();
     layer->compositedLayerMapping()->setSquashingContentsNeedDisplay();
   }
 
   for (PaintLayer* child = layer->firstChild(); child;
        child = child->nextSibling())
     fullyInvalidatePaintRecursive(child);
 }
 
 void PaintLayerCompositor::fullyInvalidatePaint() {
   // We're walking all compositing layers and invalidating them, so there's
   // no need to have up-to-date compositing state.
   DisableCompositingQueryAsserts disabler;
   fullyInvalidatePaintRecursive(rootLayer());
 }
 
 PaintLayer* PaintLayerCompositor::rootLayer() const {
   return m_layoutView.layer();
 }
 
 GraphicsLayer* PaintLayerCompositor::rootGraphicsLayer() const {
-  return m_overflowControlsHostLayer.get();
-}
-
-GraphicsLayer* PaintLayerCompositor::frameScrollLayer() const {
-  return m_scrollLayer.get();
+  if (m_overflowControlsHostLayer)
+    return m_overflowControlsHostLayer.get();
+  if (CompositedLayerMapping* clm = rootLayer()->compositedLayerMapping())
+    return clm->childForSuperlayers();
+  return nullptr;
 }
 
 GraphicsLayer* PaintLayerCompositor::scrollLayer() const {
   if (ScrollableArea* scrollableArea =
           m_layoutView.frameView()->getScrollableArea())
     return scrollableArea->layerForScrolling();
   return nullptr;
 }
 
-GraphicsLayer* PaintLayerCompositor::containerLayer() const {
-  return m_containerLayer.get();
-}
-
-GraphicsLayer* PaintLayerCompositor::rootContentLayer() const {
-  return m_rootContentLayer.get();
-}
-
 void PaintLayerCompositor::setIsInWindow(bool isInWindow) {
   if (!staleInCompositingMode())
     return;
 
   if (isInWindow) {
     if (m_rootLayerAttachment != RootLayerUnattached)
       return;
 
     attachCompositorTimeline();
     attachRootLayer();
@@ skipping 284 matching lines @@
   m_layoutView.frameView()->positionScrollbarLayers();
 }
 
 void PaintLayerCompositor::ensureRootLayer() {
   if (m_rootLayerAttachment != RootLayerUnattached)
     return;
 
   if (isMainFrame())
     visualViewport().createLayerTree();
 
-  if (!m_rootContentLayer) {
+  // When RLS is enabled, none of the PLC GraphicsLayers exist.
+  bool shouldCreateOwnLayers =
+      !RuntimeEnabledFeatures::rootLayerScrollingEnabled();
+
+  if (shouldCreateOwnLayers && !m_rootContentLayer) {
     m_rootContentLayer = GraphicsLayer::create(this);
     IntRect overflowRect = m_layoutView.pixelSnappedLayoutOverflowRect();
     m_rootContentLayer->setSize(
         FloatSize(overflowRect.maxX(), overflowRect.maxY()));
     m_rootContentLayer->setPosition(FloatPoint());
     m_rootContentLayer->setOwnerNodeId(
         DOMNodeIds::idForNode(m_layoutView.node()));
   }
 
-  if (!m_overflowControlsHostLayer) {
+  if (shouldCreateOwnLayers && !m_overflowControlsHostLayer) {
     ASSERT(!m_scrollLayer);
     ASSERT(!m_containerLayer);
 
     // Create a layer to host the clipping layer and the overflow controls
     // layers.  Whether these layers mask the content below is determined
     // in updateClippingOnCompositorLayers.
     m_overflowControlsHostLayer = GraphicsLayer::create(this);
     m_containerLayer = GraphicsLayer::create(this);
-
-    // TODO(skobes): When root layer scrolling is enabled, we should not even
-    // create m_scrollLayer or most of the layers in PLC.
     m_scrollLayer = GraphicsLayer::create(this);
     if (ScrollingCoordinator* scrollingCoordinator =
             this->scrollingCoordinator())
       scrollingCoordinator->setLayerIsContainerForFixedPositionLayers(
           m_scrollLayer.get(), true);
 
     // In RLS mode, LayoutView scrolling contents layer gets this element ID (in
     // CompositedLayerMapping::updateElementIdAndCompositorMutableProperties).
     if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       m_scrollLayer->setElementId(createCompositorElementId(
           DOMNodeIds::idForNode(&m_layoutView.document()),
           CompositorSubElementId::Scroll));
     }
 
     // Hook them up
     m_overflowControlsHostLayer->addChild(m_containerLayer.get());
     m_containerLayer->addChild(m_scrollLayer.get());
     m_scrollLayer->addChild(m_rootContentLayer.get());
 
     frameViewDidChangeSize();
   }
 
   attachCompositorTimeline();
   attachRootLayer();
 }
 
 void PaintLayerCompositor::destroyRootLayer() {
-  if (!m_rootContentLayer)
-    return;
-
   detachRootLayer();
 
   if (m_layerForHorizontalScrollbar) {
     m_layerForHorizontalScrollbar->removeFromParent();
     m_layerForHorizontalScrollbar = nullptr;
     if (ScrollingCoordinator* scrollingCoordinator =
             this->scrollingCoordinator())
       scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(
           m_layoutView.frameView(), HorizontalScrollbar);
     m_layoutView.frameView()->setScrollbarNeedsPaintInvalidation(
@@ skipping 19 matching lines @@
   if (m_overflowControlsHostLayer) {
     m_overflowControlsHostLayer = nullptr;
     m_containerLayer = nullptr;
     m_scrollLayer = nullptr;
   }
   ASSERT(!m_scrollLayer);
   m_rootContentLayer = nullptr;
 }
 
 void PaintLayerCompositor::attachRootLayer() {
-  if (!m_rootContentLayer)
-    return;
-
   // In Slimming Paint v2, PaintArtifactCompositor is responsible for the root
   // layer.
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return;
 
   if (m_layoutView.frame()->isLocalRoot()) {
     m_rootLayerAttachment = RootLayerPendingAttachViaChromeClient;
   } else {
     HTMLFrameOwnerElement* ownerElement = m_layoutView.document().localOwner();
     DCHECK(ownerElement);
     // The layer will get hooked up via
     // CompositedLayerMapping::updateGraphicsLayerConfiguration() for the
     // frame's layoutObject in the parent document.
     ownerElement->setNeedsCompositingUpdate();
     m_rootLayerAttachment = RootLayerAttachedViaEnclosingFrame;
   }
 }
 
 void PaintLayerCompositor::detachRootLayer() {
-  if (!m_rootContentLayer || m_rootLayerAttachment == RootLayerUnattached)
+  if (m_rootLayerAttachment == RootLayerUnattached)
     return;
 
   switch (m_rootLayerAttachment) {
     case RootLayerAttachedViaEnclosingFrame: {
       // The layer will get unhooked up via
       // CompositedLayerMapping::updateGraphicsLayerConfiguration() for the
       // frame's layoutObject in the parent document.
       if (m_overflowControlsHostLayer)
         m_overflowControlsHostLayer->removeFromParent();
-      else
-        m_rootContentLayer->removeFromParent();
 
       if (HTMLFrameOwnerElement* ownerElement =
               m_layoutView.document().localOwner())
         ownerElement->setNeedsCompositingUpdate();
       break;
     }
     case RootLayerAttachedViaChromeClient: {
       LocalFrame& frame = m_layoutView.frameView()->frame();
       Page* page = frame.page();
       if (!page)
@@ skipping 76 matching lines @@
   } else if (graphicsLayer == m_scrollLayer.get()) {
     name = "Frame Scrolling Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink