Refactor FrameView property updates to work like LayouObject updates

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilder.cpp

 // Copyright 2015 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/paint/PaintPropertyTreeBuilder.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 52 matching lines @@
   context.current.scroll = context.absolutePosition.scroll =
       context.fixedPosition.scroll = rootScrollNode();
 
   // Ensure scroll tree properties are reset. They will be rebuilt during the
   // tree walk.
   rootScrollNode()->clearMainThreadScrollingReasons();
 
   return context;
 }
 
-void createOrUpdateFrameViewPreTranslation(
+const TransformPaintPropertyNode* createOrUpdateFrameViewPreTranslation(
     FrameView& frameView,
     PassRefPtr<const TransformPaintPropertyNode> parent,
     const TransformationMatrix& matrix,
     const FloatPoint3D& origin) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (TransformPaintPropertyNode* existingPreTranslation =
           frameView.preTranslation())
     existingPreTranslation->update(std::move(parent), matrix, origin);
   else
     frameView.setPreTranslation(
         TransformPaintPropertyNode::create(std::move(parent), matrix, origin));
+  return frameView.preTranslation();
 }
 
-void createOrUpdateFrameViewContentClip(
+const ClipPaintPropertyNode* createOrUpdateFrameViewContentClip(
     FrameView& frameView,
     PassRefPtr<const ClipPaintPropertyNode> parent,
     PassRefPtr<const TransformPaintPropertyNode> localTransformSpace,
     const FloatRoundedRect& clipRect) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (ClipPaintPropertyNode* existingContentClip = frameView.contentClip())
     existingContentClip->update(std::move(parent),
                                 std::move(localTransformSpace), clipRect);
   else
     frameView.setContentClip(ClipPaintPropertyNode::create(
         std::move(parent), std::move(localTransformSpace), clipRect));
+  return frameView.contentClip();
 }
 
-void createOrUpdateFrameViewScrollTranslation(
+const TransformPaintPropertyNode* createOrUpdateFrameViewScrollTranslation(
     FrameView& frameView,
     PassRefPtr<const TransformPaintPropertyNode> parent,
     const TransformationMatrix& matrix,
     const FloatPoint3D& origin) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (TransformPaintPropertyNode* existingScrollTranslation =
           frameView.scrollTranslation())
     existingScrollTranslation->update(std::move(parent), matrix, origin);
   else
     frameView.setScrollTranslation(
         TransformPaintPropertyNode::create(std::move(parent), matrix, origin));
+  return frameView.scrollTranslation();
 }
 
-void createOrUpdateFrameViewScroll(
+ScrollPaintPropertyNode* createOrUpdateFrameViewScroll(
     FrameView& frameView,
     PassRefPtr<ScrollPaintPropertyNode> parent,
     PassRefPtr<const TransformPaintPropertyNode> scrollOffset,
     const IntSize& clip,
     const IntSize& bounds,
     bool userScrollableHorizontal,
     bool userScrollableVertical) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (ScrollPaintPropertyNode* existingScroll = frameView.scroll())
     existingScroll->update(std::move(parent), std::move(scrollOffset), clip,
                            bounds, userScrollableHorizontal,
                            userScrollableVertical);
   else
     frameView.setScroll(ScrollPaintPropertyNode::create(
         std::move(parent), std::move(scrollOffset), clip, bounds,
         userScrollableHorizontal, userScrollableVertical));
+  return frameView.scroll();
 }
 
 void PaintPropertyTreeBuilder::buildTreeNodes(
     FrameView& frameView,
     PaintPropertyTreeBuilderContext& context) {
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     LayoutView* layoutView = frameView.layoutView();
     if (!layoutView)
       return;
 
@@ skipping 13 matching lines @@
     context.absolutePosition = context.current;
     context.containerForAbsolutePosition =
         nullptr;  // This will get set in updateOutOfFlowContext().
     context.fixedPosition = context.current;
     return;
   }
 
   TransformationMatrix frameTranslate;
   frameTranslate.translate(frameView.x() + context.current.paintOffset.x(),
                            frameView.y() + context.current.paintOffset.y());
-  createOrUpdateFrameViewPreTranslation(frameView, context.current.transform,
-                                        frameTranslate, FloatPoint3D());
+  context.current.transform = createOrUpdateFrameViewPreTranslation(
+      frameView, context.current.transform, frameTranslate, FloatPoint3D());
 
   FloatRoundedRect contentClip(
       IntRect(IntPoint(), frameView.visibleContentSize()));
-  createOrUpdateFrameViewContentClip(frameView, context.current.clip,
-                                     frameView.preTranslation(), contentClip);
+  context.current.clip = createOrUpdateFrameViewContentClip(
+      frameView, context.current.clip, frameView.preTranslation(), contentClip);
+
+  // Record the fixed properties before any scrolling occurs.
+  const auto* fixedTransformNode = context.current.transform;
+  auto* fixedScrollNode = context.current.scroll;
 
   ScrollOffset scrollOffset = frameView.scrollOffset();
   if (frameView.isScrollable() || !scrollOffset.isZero()) {
     TransformationMatrix frameScroll;
     frameScroll.translate(-scrollOffset.width(), -scrollOffset.height());
-    createOrUpdateFrameViewScrollTranslation(
+    context.current.transform = createOrUpdateFrameViewScrollTranslation(
         frameView, frameView.preTranslation(), frameScroll, FloatPoint3D());
 
     IntSize scrollClip = frameView.visibleContentSize();
     IntSize scrollBounds = frameView.contentsSize();
     bool userScrollableHorizontal =
         frameView.userInputScrollable(HorizontalScrollbar);
     bool userScrollableVertical =
         frameView.userInputScrollable(VerticalScrollbar);
-    createOrUpdateFrameViewScroll(frameView, context.current.scroll,
-                                  frameView.scrollTranslation(), scrollClip,
-                                  scrollBounds, userScrollableHorizontal,
-                                  userScrollableVertical);
+    context.current.scroll = createOrUpdateFrameViewScroll(
+        frameView, context.current.scroll, frameView.scrollTranslation(),
+        scrollClip, scrollBounds, userScrollableHorizontal,
+        userScrollableVertical);
   } else {
+    // Ensure pre-existing properties are cleared when there is no scrolling.
     frameView.setScrollTranslation(nullptr);
     frameView.setScroll(nullptr);
   }
 
   // Initialize the context for current, absolute and fixed position cases.
   // They are the same, except that scroll translation does not apply to
   // fixed position descendants.
-  ScrollPaintPropertyNode* initialScroll = context.current.scroll;
-  context.current.transform = frameView.scrollTranslation()
-                                  ? frameView.scrollTranslation()
-                                  : frameView.preTranslation();
   context.current.paintOffset = LayoutPoint();
-  context.current.clip = frameView.contentClip();
-  context.current.scroll =
-      frameView.scroll() ? frameView.scroll() : initialScroll;
   context.current.renderingContextID = 0;
   context.current.shouldFlattenInheritedTransform = true;
   context.absolutePosition = context.current;
   context.containerForAbsolutePosition = nullptr;
   context.fixedPosition = context.current;
-  context.fixedPosition.transform = frameView.preTranslation();
-  context.fixedPosition.scroll = initialScroll;
+  context.fixedPosition.transform = fixedTransformNode;
+  context.fixedPosition.scroll = fixedScrollNode;
 
   std::unique_ptr<PropertyTreeState> contentsState(
       new PropertyTreeState(context.current.transform, context.current.clip,
                             context.currentEffect, context.current.scroll));
   frameView.setTotalPropertyTreeStateForContents(std::move(contentsState));
 }
 
 void PaintPropertyTreeBuilder::updatePaintOffsetTranslation(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
@@ skipping 589 matching lines @@
     return;
 
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 }
 
 }  // namespace blink