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 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 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 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 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 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 216 matching lines @@
   // 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 CompositorElementId createDomNodeBasedCompositorElementId(
     const LayoutObject& object) {
   return createCompositorElementId(DOMNodeIds::idForNode(object.node()),
                                    CompositorSubElementId::Primary);
 }
 
-}  // namespace
-
 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 367 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 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);
 }
@@ skipping 233 matching lines @@
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink