Inline PrePaintTreeWalk private methods and static functions

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/dom/DOMNodeIds.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 20 matching lines @@
   context.currentEffect = EffectPaintPropertyNode::root();
   context.inputClipOfCurrentEffect = ClipPaintPropertyNode::root();
   context.current.transform = context.absolutePosition.transform =
       context.fixedPosition.transform = TransformPaintPropertyNode::root();
   context.current.scroll = context.absolutePosition.scroll =
       context.fixedPosition.scroll = ScrollPaintPropertyNode::root();
   return context;
 }
 
 // True if a new property was created, false if an existing one was updated.
-bool updatePreTranslation(FrameView& frameView,
-                          PassRefPtr<const TransformPaintPropertyNode> parent,
-                          const TransformationMatrix& matrix,
-                          const FloatPoint3D& origin) {
+static inline bool updatePreTranslation(
+    FrameView& frameView,
+    PassRefPtr<const TransformPaintPropertyNode> parent,
+    const TransformationMatrix& matrix,
+    const FloatPoint3D& origin) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (auto* existingPreTranslation = frameView.preTranslation()) {
     existingPreTranslation->update(std::move(parent), matrix, origin);
     return false;
   }
   frameView.setPreTranslation(
       TransformPaintPropertyNode::create(std::move(parent), matrix, origin));
   return true;
 }
 
 // True if a new property was created, false if an existing one was updated.
-bool updateContentClip(
+static inline bool updateContentClip(
     FrameView& frameView,
     PassRefPtr<const ClipPaintPropertyNode> parent,
     PassRefPtr<const TransformPaintPropertyNode> localTransformSpace,
     const FloatRoundedRect& clipRect) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (auto* existingContentClip = frameView.contentClip()) {
     existingContentClip->update(std::move(parent),
                                 std::move(localTransformSpace), clipRect);
     return false;
   }
   frameView.setContentClip(ClipPaintPropertyNode::create(
       std::move(parent), std::move(localTransformSpace), clipRect));
   return true;
 }
 
 // True if a new property was created, false if an existing one was updated.
-bool updateScrollTranslation(
+static inline bool updateScrollTranslation(
     FrameView& frameView,
     PassRefPtr<const TransformPaintPropertyNode> parent,
     const TransformationMatrix& matrix,
     const FloatPoint3D& origin) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (auto* existingScrollTranslation = frameView.scrollTranslation()) {
     existingScrollTranslation->update(std::move(parent), matrix, origin);
     return false;
   }
   frameView.setScrollTranslation(
       TransformPaintPropertyNode::create(std::move(parent), matrix, origin));
   return true;
 }
 
 // True if a new property was created or a main thread scrolling reason changed
 // (which can affect descendants), false if an existing one was updated.
-bool updateScroll(FrameView& frameView,
-                  PassRefPtr<const ScrollPaintPropertyNode> parent,
-                  PassRefPtr<const TransformPaintPropertyNode> scrollOffset,
-                  const IntSize& clip,
-                  const IntSize& bounds,
-                  bool userScrollableHorizontal,
-                  bool userScrollableVertical,
-                  MainThreadScrollingReasons mainThreadScrollingReasons) {
+static inline bool updateScroll(
+    FrameView& frameView,
+    PassRefPtr<const ScrollPaintPropertyNode> parent,
+    PassRefPtr<const TransformPaintPropertyNode> scrollOffset,
+    const IntSize& clip,
+    const IntSize& bounds,
+    bool userScrollableHorizontal,
+    bool userScrollableVertical,
+    MainThreadScrollingReasons mainThreadScrollingReasons) {
   DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   if (auto* existingScroll = frameView.scroll()) {
     auto existingReasons = existingScroll->mainThreadScrollingReasons();
     existingScroll->update(std::move(parent), std::move(scrollOffset), clip,
                            bounds, userScrollableHorizontal,
                            userScrollableVertical, mainThreadScrollingReasons);
     return existingReasons != mainThreadScrollingReasons;
   }
   frameView.setScroll(ScrollPaintPropertyNode::create(
       std::move(parent), std::move(scrollOffset), clip, bounds,
       userScrollableHorizontal, userScrollableVertical,
       mainThreadScrollingReasons));
   return true;
 }
 
-MainThreadScrollingReasons mainThreadScrollingReasons(
+static inline MainThreadScrollingReasons mainThreadScrollingReasons(
     const FrameView& frameView,
     MainThreadScrollingReasons ancestorReasons) {
   auto reasons = ancestorReasons;
   if (!frameView.frame().settings()->getThreadedScrollingEnabled())
     reasons |= MainThreadScrollingReason::kThreadedScrollingDisabled;
   if (frameView.hasBackgroundAttachmentFixedObjects())
     reasons |= MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects;
   return reasons;
 }
 
@@ skipping 88 matching lines @@
   context.fixedPosition = context.current;
   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(
+inline void PaintPropertyTreeBuilder::updatePaintOffsetTranslation(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   bool usesPaintOffsetTranslation = false;
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
       object.isLayoutView()) {
     // Root layer scrolling always creates a translation node for LayoutView to
     // ensure fixed and absolute contexts use the correct transform space.
     usesPaintOffsetTranslation = true;
   } else if (object.isBoxModelObject() &&
              context.current.paintOffset != LayoutPoint()) {
@@ skipping 38 matching lines @@
       context.absolutePosition.transform = properties->paintOffsetTranslation();
       context.fixedPosition.transform = properties->paintOffsetTranslation();
       context.absolutePosition.paintOffset = LayoutPoint();
       context.fixedPosition.paintOffset = LayoutPoint();
     }
   }
 }
 
 // SVG does not use the general transform update of |updateTransform|, instead
 // creating a transform node for SVG-specific transforms without 3D.
-void PaintPropertyTreeBuilder::updateTransformForNonRootSVG(
+inline void PaintPropertyTreeBuilder::updateTransformForNonRootSVG(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   DCHECK(object.isSVGChild());
   // SVG does not use paint offset internally, except for SVGForeignObject which
   // has different SVG and HTML coordinate spaces.
   DCHECK(object.isSVGForeignObject() ||
          context.current.paintOffset == LayoutPoint());
 
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     AffineTransform transform = object.localToSVGParentTransform();
@@ skipping 13 matching lines @@
     }
   }
 
   if (object.paintProperties() && object.paintProperties()->transform()) {
     context.current.transform = object.paintProperties()->transform();
     context.current.shouldFlattenInheritedTransform = false;
     context.current.renderingContextId = 0;
   }
 }
 
-static CompositingReasons compositingReasonsForTransform(const LayoutBox& box) {
+static inline CompositingReasons compositingReasonsForTransform(
+    const LayoutBox& box) {
   const ComputedStyle& style = box.styleRef();
   CompositingReasons compositingReasons = CompositingReasonNone;
   if (CompositingReasonFinder::requiresCompositingForTransform(box))
     compositingReasons |= CompositingReason3DTransform;
 
   if (CompositingReasonFinder::requiresCompositingForTransformAnimation(style))
     compositingReasons |= CompositingReasonActiveAnimation;
 
   if (style.hasWillChangeCompositingHint() &&
       !style.subtreeWillChangeContents())
     compositingReasons |= CompositingReasonWillChangeCompositingHint;
 
   if (box.hasLayer() && box.layer()->has3DTransformedDescendant()) {
     if (style.hasPerspective())
       compositingReasons |= CompositingReasonPerspectiveWith3DDescendants;
     if (style.usedTransformStyle3D() == TransformStyle3DPreserve3D)
       compositingReasons |= CompositingReasonPreserve3DWith3DDescendants;
   }
 
   return compositingReasons;
 }
 
-static FloatPoint3D transformOrigin(const LayoutBox& box) {
+static inline FloatPoint3D transformOrigin(const LayoutBox& box) {
   const ComputedStyle& style = box.styleRef();
   // Transform origin has no effect without a transform or motion path.
   if (!style.hasTransform())
     return FloatPoint3D();
   FloatSize borderBoxSize(box.size());
   return FloatPoint3D(
       floatValueForLength(style.transformOriginX(), borderBoxSize.width()),
       floatValueForLength(style.transformOriginY(), borderBoxSize.height()),
       style.transformOriginZ());
 }
 
-namespace {
-
-CompositorElementId createDomNodeBasedCompositorElementId(
+static inline CompositorElementId createDomNodeBasedCompositorElementId(
     const LayoutObject& object) {
   return createCompositorElementId(DOMNodeIds::idForNode(object.node()),
                                    CompositorSubElementId::Primary);
 }
 
-}  // namespace

[Xianzhu, 2017/01/18 18:37:55]

Alternately we can enclose all local static functions in namespace {}, but
'static' seems more common than namespace {}. Wdyt?

-
-void PaintPropertyTreeBuilder::updateTransform(
+inline void PaintPropertyTreeBuilder::updateTransform(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.isSVGChild()) {
     updateTransformForNonRootSVG(object, context);
     return;
   }
 
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     const ComputedStyle& style = object.styleRef();
 
@@ skipping 52 matching lines @@
       context.current.renderingContextId =
           properties->transform()->renderingContextId();
       context.current.shouldFlattenInheritedTransform = false;
     } else {
       context.current.renderingContextId = 0;
       context.current.shouldFlattenInheritedTransform = true;
     }
   }
 }
 
-void PaintPropertyTreeBuilder::updateEffect(
+inline void PaintPropertyTreeBuilder::updateEffect(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   const ComputedStyle& style = object.styleRef();
 
   const bool isCSSIsolatedGroup =
       object.isBoxModelObject() && style.isStackingContext();
   if (!isCSSIsolatedGroup && !object.isSVGChild()) {
     if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
       if (auto* properties = object.getMutableForPainting().paintProperties())
         context.forceSubtreeUpdate |= properties->clearEffect();
@@ skipping 95 matching lines @@
       // TODO(trchen): Change input clip to expansion hint once implemented.
       const ClipPaintPropertyNode* inputClip =
           properties->effect()->outputClip();
       context.inputClipOfCurrentEffect = context.current.clip =
           context.absolutePosition.clip = context.fixedPosition.clip =
               inputClip;
     }
   }
 }
 
-void PaintPropertyTreeBuilder::updateCssClip(
+inline void PaintPropertyTreeBuilder::updateCssClip(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     if (object.hasClip()) {
       // Create clip node for descendants that are not fixed position.
       // We don't have to setup context.absolutePosition.clip here because this
       // object must be a container for absolute position descendants, and will
       // copy from in-flow context later at updateOutOfFlowContext() step.
       DCHECK(object.canContainAbsolutePositionObjects());
       LayoutRect clipRect =
           toLayoutBox(object).clipRect(context.current.paintOffset);
       auto& properties = object.getMutableForPainting().ensurePaintProperties();
       context.forceSubtreeUpdate |= properties.updateCssClip(
           context.current.clip, context.current.transform,
           FloatRoundedRect(FloatRect(clipRect)));
     } else {
       if (auto* properties = object.getMutableForPainting().paintProperties())
         context.forceSubtreeUpdate |= properties->clearCssClip();
     }
   }
 
   const auto* properties = object.paintProperties();
   if (properties && properties->cssClip())
     context.current.clip = properties->cssClip();
 }
 
-void PaintPropertyTreeBuilder::updateLocalBorderBoxContext(
+inline void PaintPropertyTreeBuilder::updateLocalBorderBoxContext(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.needsPaintPropertyUpdate() && !context.forceSubtreeUpdate)
     return;
 
   // Avoid adding an ObjectPaintProperties for non-boxes to save memory, since
   // we don't need them at the moment.
   if (!object.isBox() && !object.hasLayer()) {
     if (auto* properties = object.getMutableForPainting().paintProperties())
       properties->clearLocalBorderBoxProperties();
   } else {
     auto& properties = object.getMutableForPainting().ensurePaintProperties();
     properties.updateLocalBorderBoxProperties(
         context.current.transform, context.current.clip, context.currentEffect,
         context.current.scroll);
   }
 }
 
 // TODO(trchen): Remove this once we bake the paint offset into frameRect.
-void PaintPropertyTreeBuilder::updateScrollbarPaintOffset(
+inline void PaintPropertyTreeBuilder::updateScrollbarPaintOffset(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.needsPaintPropertyUpdate() && !context.forceSubtreeUpdate)
     return;
 
   bool needsScrollbarPaintOffset = false;
   IntPoint roundedPaintOffset = roundedIntPoint(context.current.paintOffset);
   if (roundedPaintOffset != IntPoint() && object.isBoxModelObject()) {
     if (auto* area = toLayoutBoxModelObject(object).getScrollableArea()) {
       if (area->horizontalScrollbar() || area->verticalScrollbar()) {
         auto paintOffset = TransformationMatrix().translate(
             roundedPaintOffset.x(), roundedPaintOffset.y());
         auto& properties =
             object.getMutableForPainting().ensurePaintProperties();
         context.forceSubtreeUpdate |= properties.updateScrollbarPaintOffset(
             context.current.transform, paintOffset, FloatPoint3D());
         needsScrollbarPaintOffset = true;
       }
     }
   }
 
   auto* properties = object.getMutableForPainting().paintProperties();
   if (!needsScrollbarPaintOffset && properties)
     context.forceSubtreeUpdate |= properties->clearScrollbarPaintOffset();
 }
 
-void PaintPropertyTreeBuilder::updateOverflowClip(
+inline void PaintPropertyTreeBuilder::updateOverflowClip(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.isBox())
     return;
 
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     const LayoutBox& box = toLayoutBox(object);
     // The <input> elements can't have contents thus CSS overflow property
     // doesn't apply.  However for layout purposes we do generate child layout
     // objects for them, e.g. button label.  We should clip the overflow from
@@ skipping 28 matching lines @@
     context.forceSubtreeUpdate |=
         properties.updateOverflowClip(currentClip, context.current.transform,
                                       FloatRoundedRect(FloatRect(clipRect)));
   }
 
   const auto* properties = object.paintProperties();
   if (properties && properties->overflowClip())
     context.current.clip = properties->overflowClip();
 }
 
-static FloatPoint perspectiveOrigin(const LayoutBox& box) {
+static inline FloatPoint perspectiveOrigin(const LayoutBox& box) {
   const ComputedStyle& style = box.styleRef();
   // Perspective origin has no effect without perspective.
   DCHECK(style.hasPerspective());
   FloatSize borderBoxSize(box.size());
   return FloatPoint(
       floatValueForLength(style.perspectiveOriginX(), borderBoxSize.width()),
       floatValueForLength(style.perspectiveOriginY(), borderBoxSize.height()));
 }
 
-void PaintPropertyTreeBuilder::updatePerspective(
+inline void PaintPropertyTreeBuilder::updatePerspective(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     const ComputedStyle& style = object.styleRef();
     if (object.isBox() && style.hasPerspective()) {
       // The perspective node must not flatten (else nothing will get
       // perspective), but it should still extend the rendering context as
       // most transform nodes do.
       TransformationMatrix matrix =
           TransformationMatrix().applyPerspective(style.perspective());
@@ skipping 10 matching lines @@
     }
   }
 
   const auto* properties = object.paintProperties();
   if (properties && properties->perspective()) {
     context.current.transform = properties->perspective();
     context.current.shouldFlattenInheritedTransform = false;
   }
 }
 
-void PaintPropertyTreeBuilder::updateSvgLocalToBorderBoxTransform(
+inline void PaintPropertyTreeBuilder::updateSvgLocalToBorderBoxTransform(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.isSVGRoot())
     return;
 
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     AffineTransform transformToBorderBox =
         SVGRootPainter(toLayoutSVGRoot(object))
             .transformToPixelSnappedBorderBox(context.current.paintOffset);
     if (!transformToBorderBox.isIdentity()) {
@@ skipping 13 matching lines @@
   if (properties && properties->svgLocalToBorderBoxTransform()) {
     context.current.transform = properties->svgLocalToBorderBoxTransform();
     context.current.shouldFlattenInheritedTransform = false;
     context.current.renderingContextId = 0;
   }
   // The paint offset is included in |transformToBorderBox| so SVG does not need
   // to handle paint offset internally.
   context.current.paintOffset = LayoutPoint();
 }
 
-MainThreadScrollingReasons mainThreadScrollingReasons(
+static inline MainThreadScrollingReasons mainThreadScrollingReasons(
     const LayoutObject& object,
     MainThreadScrollingReasons ancestorReasons) {
   // The current main thread scrolling reasons implementation only changes
   // reasons at frame boundaries, so we can early-out when not at a LayoutView.
   // TODO(pdr): Need to find a solution to the style-related main thread
   // scrolling reasons such as opacity and transform which violate this.
   if (!object.isLayoutView())
     return ancestorReasons;
   return mainThreadScrollingReasons(*object.frameView(), ancestorReasons);
 }
 
-void PaintPropertyTreeBuilder::updateScrollAndScrollTranslation(
+inline void PaintPropertyTreeBuilder::updateScrollAndScrollTranslation(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     bool needsScrollProperties = false;
     if (object.hasOverflowClip()) {
       auto ancestorReasons =
           context.current.scroll->mainThreadScrollingReasons();
       auto reasons = mainThreadScrollingReasons(object, ancestorReasons);
       bool scrollNodeNeededForMainThreadReasons = ancestorReasons != reasons;
 
@@ skipping 42 matching lines @@
     }
   }
 
   if (object.paintProperties() && object.paintProperties()->scroll()) {
     context.current.transform = object.paintProperties()->scrollTranslation();
     context.current.scroll = object.paintProperties()->scroll();
     context.current.shouldFlattenInheritedTransform = false;
   }
 }
 
-void PaintPropertyTreeBuilder::updateOutOfFlowContext(
+inline void PaintPropertyTreeBuilder::updateOutOfFlowContext(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.isLayoutBlock())
     context.paintOffsetForFloat = context.current.paintOffset;
 
   if (object.canContainAbsolutePositionObjects()) {
     context.absolutePosition = context.current;
     context.containerForAbsolutePosition = &object;
   }
 
@@ skipping 152 matching lines @@
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink