Make PaintInvalidatorContext::geometryMapper and treeBuilderContext private

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

 // Copyright 2016 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/PaintInvalidator.h"
 
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 31 matching lines @@
   object.mapToVisualRectInAncestorSpace(&ancestor, result);
   return result;
 }
 
 // TODO(wangxianzhu): Combine this into
 // PaintInvalidator::mapLocalRectToBacking() when removing
 // PaintInvalidationState.
 // This function is templatized to avoid FloatRect<->LayoutRect conversions
 // which affect performance.
 template <typename Rect, typename Point>
-static LayoutRect mapLocalRectToVisualRectInBacking(
+LayoutRect PaintInvalidator::mapLocalRectToVisualRectInBacking(
     const LayoutObject& object,
     const Rect& localRect,
     const PaintInvalidatorContext& context) {
   if (localRect.isEmpty())
     return LayoutRect();
 
   bool isSVGChild = object.isSVGChild();
 
   // TODO(wkorman): The flip below is required because visual rects are
   // currently in "physical coordinates with flipped block-flow direction"
@@ skipping 38 matching lines @@
   } else {
     // For non-root SVG, the input rect is in local SVG coordinates in which
     // paint offset doesn't apply.
     if (!isSVGChild)
       rect.moveBy(Point(object.paintOffset()));
 
     const auto* containerContentsProperties =
         context.paintInvalidationContainer->paintProperties()
             ->contentsProperties();
 
-    if (context.treeBuilderContext.current.transform ==
+    if (context.m_treeBuilderContext.current.transform ==
             containerContentsProperties->transform() &&
-        context.treeBuilderContext.current.clip ==
+        context.m_treeBuilderContext.current.clip ==
             containerContentsProperties->clip()) {
       result = LayoutRect(rect);
     } else {
       // Use enclosingIntRect to ensure the final visual rect will cover the
       // rect in source coordinates no matter if the painting will use pixel
       // snapping, when transforms are applied. If there is no transform,
       // enclosingIntRect is applied in the last step of paint invalidation
       // (see CompositedLayerMapping::setContentsNeedDisplayInRect()).
-      if (!isSVGChild &&
-          context.treeBuilderContext.current.transform !=
-              containerContentsProperties->transform())
+      if (!isSVGChild && context.m_treeBuilderContext.current.transform !=
+                             containerContentsProperties->transform())
         rect = Rect(enclosingIntRect(rect));
 
       PropertyTreeState currentTreeState(
-          context.treeBuilderContext.current.transform,
-          context.treeBuilderContext.current.clip, nullptr);
+          context.m_treeBuilderContext.current.transform,
+          context.m_treeBuilderContext.current.clip, nullptr);
 
       FloatRect floatRect(rect);
-      context.geometryMapper.sourceToDestinationVisualRect(
+      context.m_geometryMapper.sourceToDestinationVisualRect(
           currentTreeState, *containerContentsProperties, floatRect);
       result = LayoutRect(floatRect);
     }
 
     // Convert the result to the container's contents space.
     result.moveBy(-context.paintInvalidationContainer->paintOffset());
   }
 
   object.adjustVisualRectForRasterEffects(result);
 
   PaintLayer::mapRectInPaintInvalidationContainerToBacking(
       *context.paintInvalidationContainer, result);
 
   result.move(object.scrollAdjustmentForPaintInvalidation(
       *context.paintInvalidationContainer));
 
   return result;
 }
 
 void PaintInvalidatorContext::mapLocalRectToVisualRectInBacking(
     const LayoutObject& object,
     LayoutRect& rect) const {
-  rect = blink::mapLocalRectToVisualRectInBacking<LayoutRect, LayoutPoint>(
+  rect = PaintInvalidator::mapLocalRectToVisualRectInBacking<LayoutRect,
+                                                             LayoutPoint>(
       object, rect, *this);
 }
 
 LayoutRect PaintInvalidator::computeVisualRectInBacking(
     const LayoutObject& object,
     const PaintInvalidatorContext& context) {
   if (object.isSVGChild()) {
     FloatRect localRect = SVGLayoutSupport::localVisualRect(object);
     return mapLocalRectToVisualRectInBacking<FloatRect, FloatPoint>(
         object, localRect, context);
@@ skipping 10 matching lines @@
     return object.paintOffset();
 
   LayoutPoint point;
   if (object != context.paintInvalidationContainer) {
     point.moveBy(object.paintOffset());
 
     const auto* containerTransform =
         context.paintInvalidationContainer->paintProperties()
             ->contentsProperties()
             ->transform();
-    if (context.treeBuilderContext.current.transform != containerTransform) {
+    if (context.m_treeBuilderContext.current.transform != containerTransform) {
       FloatRect rect = FloatRect(FloatPoint(point), FloatSize());
-      context.geometryMapper.sourceToDestinationRect(
-          context.treeBuilderContext.current.transform, containerTransform,
+      context.m_geometryMapper.sourceToDestinationRect(
+          context.m_treeBuilderContext.current.transform, containerTransform,
           rect);
       point = LayoutPoint(rect.location());
     }
 
     // Convert the result to the container's contents space.
     point.moveBy(-context.paintInvalidationContainer->paintOffset());
   }
 
   if (context.paintInvalidationContainer->layer()->groupedMapping()) {
     FloatPoint floatPoint(point);
@@ skipping 48 matching lines @@
 
 namespace {
 
 // This is temporary to workaround paint invalidation issues in
 // non-rootLayerScrolls mode.
 // It undoes FrameView's content clip and scroll for paint invalidation of frame
 // scroll controls and the LayoutView to which the content clip and scroll don't
 // apply.
 class ScopedUndoFrameViewContentClipAndScroll {
  public:
-  ScopedUndoFrameViewContentClipAndScroll(const FrameView& frameView,
-                                          PaintInvalidatorContext& context)
-      : m_treeBuilderContext(const_cast<PaintPropertyTreeBuilderContext&>(
-            context.treeBuilderContext)),
+  ScopedUndoFrameViewContentClipAndScroll(
+      const FrameView& frameView,
+      const PaintPropertyTreeBuilderContext& treeBuilderContext)
+      : m_treeBuilderContext(
+            const_cast<PaintPropertyTreeBuilderContext&>(treeBuilderContext)),
         m_savedContext(m_treeBuilderContext.current) {
     DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
 
     if (frameView.contentClip() == m_savedContext.clip)
       m_treeBuilderContext.current.clip = m_savedContext.clip->parent();
     if (const auto* scrollTranslation = frameView.scrollTranslation()) {
       if (scrollTranslation->scrollNode() == m_savedContext.scroll)
         m_treeBuilderContext.current.scroll = m_savedContext.scroll->parent();
       if (scrollTranslation == m_savedContext.transform) {
         m_treeBuilderContext.current.transform =
@@ skipping 75 matching lines @@
 }
 
 void PaintInvalidator::updateVisualRect(const LayoutObject& object,
                                         PaintInvalidatorContext& context) {
   Optional<ScopedUndoFrameViewContentClipAndScroll>
       undoFrameViewContentClipAndScroll;
 
   if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
       object.isLayoutView() && !object.isPaintInvalidationContainer()) {
     undoFrameViewContentClipAndScroll.emplace(*toLayoutView(object).frameView(),
-                                              context);
+                                              context.m_treeBuilderContext);
   }
 
   // TODO(crbug.com/637313): Use GeometryMapper which now supports filter
   // geometry effects, after skia optimizes filter's mapRect operation.
   // TODO(crbug.com/648274): This is a workaround for multi-column contents.
   if (object.hasFilterInducingProperty() || object.isLayoutFlowThread()) {
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeSlowPathRect;
   }
 
@@ skipping 25 matching lines @@
     PaintInvalidatorContext& context) {
   LayoutView* layoutView = frameView.layoutView();
   CHECK(layoutView);
 
   context.paintInvalidationContainer =
       context.paintInvalidationContainerForStackedContents =
           &layoutView->containerForPaintInvalidation();
   context.paintingLayer = layoutView->layer();
 
   if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
-    ScopedUndoFrameViewContentClipAndScroll undo(frameView, context);
+    ScopedUndoFrameViewContentClipAndScroll undo(frameView,
+                                                 context.m_treeBuilderContext);
     frameView.invalidatePaintOfScrollControlsIfNeeded(context);
   }
 }
 
 void PaintInvalidator::invalidatePaintIfNeeded(
     const LayoutObject& object,
     PaintInvalidatorContext& context) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"),
                "PaintInvalidator::invalidatePaintIfNeeded()", "object",
                object.debugName().ascii());
 
   object.getMutableForPainting().ensureIsReadyForPaintInvalidation();
 
   // The paint offset should already be updated through
   // PaintPropertyTreeBuilder::updatePropertiesForSelf.
-  DCHECK(context.treeBuilderContext.current.paintOffset ==
+  DCHECK(context.m_treeBuilderContext.current.paintOffset ==
          object.paintOffset());
 
   updatePaintingLayer(object, context);
 
   if (object.document().printing() &&
       !RuntimeEnabledFeatures::printBrowserEnabled())
     return;  // Don't invalidate paints if we're printing.
 
   updatePaintInvalidationContainer(object, context);
 
@@ skipping 59 matching lines @@
   }
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations() {
   for (auto target : m_pendingDelayedPaintInvalidations)
     target->getMutableForPainting().setShouldDoFullPaintInvalidation(
         PaintInvalidationDelayedFull);
 }
 
 }  // namespace blink