[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 336 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();
+  // Iframe content layers will be connected by the parent frame using
+  // attachFrameContentLayersToIframeLayer.
+  return isMainFrame() ? visualViewport().scrollLayer() : nullptr;

[bokan, 2017/03/06 15:42:30]

Is it true that !rootContentLayer implies rootLayerScrolling? If so, please add
a DCHECK.

[skobes, 2017/03/06 23:00:25]

Done.

+}
+
 void PaintLayerCompositor::updateIfNeeded() {
   CompositingUpdateType updateType = m_pendingUpdateType;
   m_pendingUpdateType = CompositingUpdateNone;
 
   if (!hasAcceleratedCompositing()) {
     updateWithoutAcceleratedCompositing(updateType);
     return;
   }
 
   if (updateType == CompositingUpdateNone)
@@ skipping 70 matching lines @@
 #endif
   }
 
   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);
+    GraphicsLayer* contentParent = parentForContentLayers();
+    if (contentParent && !childList.isEmpty()) {
+      CHECK(m_compositing);
+      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->getRootLayerAttachment() !=
           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;
 
     RootLayerAttachment attachment = m_layoutView.frame()->isLocalRoot()
                                          ? RootLayerAttachedViaChromeClient
@@ skipping 290 matching lines @@
 void PaintLayerCompositor::ensureRootLayer() {
   RootLayerAttachment expectedAttachment =
       m_layoutView.frame()->isLocalRoot() ? RootLayerAttachedViaChromeClient
                                           : RootLayerAttachedViaEnclosingFrame;
   if (expectedAttachment == m_rootLayerAttachment)
     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

[szager1, 2017/03/06 22:07:47]

Remove this comment.

[skobes, 2017/03/06 23:00:25]

Done.

     // 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()) {
@@ skipping 14 matching lines @@
   if (m_rootLayerAttachment != RootLayerUnattached) {
     detachRootLayer();
     detachCompositorTimeline();
   }
 
   attachCompositorTimeline();
   attachRootLayer(expectedAttachment);
 }
 
 void PaintLayerCompositor::destroyRootLayer() {
-  if (!m_rootContentLayer)

[bokan, 2017/03/06 15:42:30]

It seems like the existence of rootContentLayer was previously used to tell if
the PLC has been initialised. Was this just an optimisation that doesn't affect
correctness in all these cases? Does the PLC under RLS no longer maintain any
real state that we don't have to ensure it's been initialised?

[skobes, 2017/03/06 23:00:25]

PLC still tracks its state in m_rootLayerAttachment.  I think the
!m_rootContentLayer checks were unnecessary.

-    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(RootLayerAttachment attachment) {
-  if (!m_rootContentLayer)
-    return;
+  DisableCompositingQueryAsserts disabler;

[szager1, 2017/03/06 22:07:47]

Why is this now necessary?

[skobes, 2017/03/06 23:00:25]

Done.

 
   // In Slimming Paint v2, PaintArtifactCompositor is responsible for the root
   // layer.
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return;
 
   switch (attachment) {
     case RootLayerUnattached:
       ASSERT_NOT_REACHED();
       break;
     case RootLayerAttachedViaChromeClient:
       m_pendingChromeClientAttachment = true;
       break;
     case RootLayerAttachedViaEnclosingFrame: {
       HTMLFrameOwnerElement* ownerElement =
           m_layoutView.document().localOwner();
       ASSERT(ownerElement);
       // The layer will get hooked up via
       // CompositedLayerMapping::updateGraphicsLayerConfiguration() for the
       // frame's layoutObject in the parent document.
       ownerElement->setNeedsCompositingUpdate();
       break;
     }
   }
 
   m_rootLayerAttachment = attachment;
 }
 
 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
+      else if (m_rootContentLayer)

[bokan, 2017/03/06 15:42:29]

Just some questions for my own benefit: how does this work for the non-RLS case?
When is there a rootContentLayer but no overflowControlsHostLayer? If there's no
overflowControlsHostLayer, does this just disconnect the RootContentLayer from
the FrameScroll layer or is there no FrameScroll layer in that case either?

[skobes, 2017/03/06 23:00:25]

Good question.  It looks like this branch is a historical artifact - it's no
longer possible to have m_rootContentLayer without m_overflowControlsHostLayer. 
Updated.

         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();
@@ skipping 81 matching lines @@
   } else if (graphicsLayer == m_scrollLayer.get()) {
     name = "Frame Scrolling Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink