Revert of Make GeometryMapper fully static

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 31 matching lines @@
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #include "core/paint/PaintLayerClipper.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
-#include "platform/graphics/paint/GeometryMapper.h"
 
 namespace blink {
 
 static void adjustClipRectsForChildren(const LayoutBoxModelObject& layoutObject,
                                        ClipRects& clipRects) {
   EPosition position = layoutObject.styleRef().position();
   // A fixed object is essentially the root of its containing block hierarchy,
   // so when we encounter such an object, we reset our clip rects to the
   // fixedClipRect.
   if (position == EPosition::kFixed) {
@@ skipping 40 matching lines @@
     LayoutRect newClip = box.clipRect(offset);
     clipRects.setPosClipRect(intersection(newClip, clipRects.posClipRect()));
     clipRects.setOverflowClipRect(
         intersection(newClip, clipRects.overflowClipRect()));
     clipRects.setFixedClipRect(
         intersection(newClip, clipRects.fixedClipRect()));
   }
 }
 
 PaintLayerClipper::PaintLayerClipper(const PaintLayer& layer,
-                                     bool usegeometryMapper)
-    : m_layer(layer), m_useGeometryMapper(usegeometryMapper) {}
+                                     GeometryMapper* geometryMapper)
+    : m_layer(layer), m_geometryMapper(geometryMapper) {}
 
 ClipRects* PaintLayerClipper::clipRectsIfCached(
     const ClipRectsContext& context) const {
   DCHECK(context.usesCache());
   if (!m_layer.clipRectsCache())
     return nullptr;
   ClipRectsCache::Entry& entry =
       m_layer.clipRectsCache()->get(context.cacheSlot());
   // FIXME: We used to ASSERT that we always got a consistent root layer.
   // We should add a test that has an inconsistent root. See
@@ skipping 23 matching lines @@
       entry.clipRects = parentClipRects;
       return *parentClipRects;
     }
   }
   entry.clipRects = ClipRects::create(clipRects);
   return *entry.clipRects;
 }
 
 ClipRects& PaintLayerClipper::getClipRects(
     const ClipRectsContext& context) const {
-  DCHECK(!m_useGeometryMapper);
+  DCHECK(!m_geometryMapper);
   if (ClipRects* result = clipRectsIfCached(context))
     return *result;
   // Note that it's important that we call getClipRects on our parent
   // before we call calculateClipRects so that calculateClipRects will hit
   // the cache.
   ClipRects* parentClipRects = nullptr;
   if (context.rootLayer != &m_layer && m_layer.parent()) {
     parentClipRects =
-        &PaintLayerClipper(*m_layer.parent(), false).getClipRects(context);
+        &PaintLayerClipper(*m_layer.parent(), nullptr).getClipRects(context);
   }
   RefPtr<ClipRects> clipRects = ClipRects::create();
   calculateClipRects(context, *clipRects);
   return storeClipRectsInCache(context, parentClipRects, *clipRects);
 }
 
 void PaintLayerClipper::clearCache(ClipRectsCacheSlot cacheSlot) {
   if (cacheSlot == NumberOfClipRectsCacheSlots)
     m_layer.clearClipRectsCache();
   else if (ClipRectsCache* cache = m_layer.clipRectsCache())
     cache->clear(cacheSlot);
 }
 
 void PaintLayerClipper::clearClipRectsIncludingDescendants() {
   clearClipRectsIncludingDescendants(NumberOfClipRectsCacheSlots);
 }
 
 void PaintLayerClipper::clearClipRectsIncludingDescendants(
     ClipRectsCacheSlot cacheSlot) {
   std::stack<const PaintLayer*> layers;
   layers.push(&m_layer);
 
   while (!layers.empty()) {
     const PaintLayer* currentLayer = layers.top();
     layers.pop();
-    PaintLayerClipper(*currentLayer, m_useGeometryMapper).clearCache(cacheSlot);
+    PaintLayerClipper(*currentLayer, m_geometryMapper).clearCache(cacheSlot);
     for (const PaintLayer* layer = currentLayer->firstChild(); layer;
          layer = layer->nextSibling())
       layers.push(layer);
   }
 }
 
 LayoutRect PaintLayerClipper::localClipRect(
     const PaintLayer& clippingRootLayer) const {
   ClipRectsContext context(&clippingRootLayer, PaintingClipRects);
-  if (m_useGeometryMapper) {
+  if (m_geometryMapper) {
     ClipRect clipRect;
     calculateBackgroundClipRectWithGeometryMapper(context, clipRect);
     LayoutRect premappedRect = clipRect.rect();
 
     // The rect now needs to be transformed to the local space of this
     // PaintLayer.
     premappedRect.moveBy(context.rootLayer->layoutObject().paintOffset());
 
     const auto* clipRootLayerTransform = clippingRootLayer.layoutObject()
                                              .localBorderBoxProperties()
                                              ->transform();
     const auto* layerTransform =
         m_layer.layoutObject().localBorderBoxProperties()->transform();
     FloatRect clippedRectInLocalSpace(premappedRect);
-    GeometryMapper::sourceToDestinationRect(
+    m_geometryMapper->sourceToDestinationRect(
         clipRootLayerTransform, layerTransform, clippedRectInLocalSpace);
     clippedRectInLocalSpace.moveBy(
         -FloatPoint(m_layer.layoutObject().paintOffset()));
 
     return LayoutRect(clippedRectInLocalSpace);
   }
 
   LayoutRect layerBounds;
   ClipRect backgroundRect, foregroundRect;
   calculateRects(context, LayoutRect(LayoutRect::infiniteIntRect()),
@@ skipping 59 matching lines @@
 #endif
 }
 
 void PaintLayerClipper::calculateRects(
     const ClipRectsContext& context,
     const LayoutRect& paintDirtyRect,
     LayoutRect& layerBounds,
     ClipRect& backgroundRect,
     ClipRect& foregroundRect,
     const LayoutPoint* offsetFromRoot) const {
-  if (m_useGeometryMapper) {
+  if (m_geometryMapper) {
     calculateRectsWithGeometryMapper(context, paintDirtyRect, layerBounds,
                                      backgroundRect, foregroundRect,
                                      offsetFromRoot);
     return;
   }
 
   bool isClippingRoot = &m_layer == context.rootLayer;
   LayoutBoxModelObject& layoutObject = m_layer.layoutObject();
 
   if (!isClippingRoot && m_layer.parent()) {
@@ skipping 52 matching lines @@
 
   bool isClippingRoot = &m_layer == context.rootLayer;
 
   // For transformed layers, the root layer was shifted to be us, so there is no
   // need to examine the parent. We want to cache clip rects with us as the
   // root.
   PaintLayer* parentLayer = !isClippingRoot ? m_layer.parent() : nullptr;
   // Ensure that our parent's clip has been calculated so that we can examine
   // the values.
   if (parentLayer) {
-    PaintLayerClipper(*parentLayer, m_useGeometryMapper)
+    PaintLayerClipper(*parentLayer, m_geometryMapper)
         .getOrCalculateClipRects(context, clipRects);
   } else {
     clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
   }
 
   adjustClipRectsForChildren(layoutObject, clipRects);
 
   if (shouldClipOverflow(context) || layoutObject.hasClip()) {
     // This offset cannot use convertToLayerCoords, because sometimes our
     // rootLayer may be across some transformed layer boundary, for example, in
@@ skipping 13 matching lines @@
 
   if (position == EPosition::kAbsolute)
     return parentRects.posClipRect();
 
   return parentRects.overflowClipRect();
 }
 
 void PaintLayerClipper::calculateBackgroundClipRectWithGeometryMapper(
     const ClipRectsContext& context,
     ClipRect& output) const {
-  DCHECK(m_useGeometryMapper);
+  DCHECK(m_geometryMapper);
   PropertyTreeState sourcePropertyTreeState(nullptr, nullptr, nullptr);
   PropertyTreeState destinationPropertyTreeState(nullptr, nullptr, nullptr);
   initializeCommonClipRectState(context, sourcePropertyTreeState,
                                 destinationPropertyTreeState);
 
   if (&m_layer != context.rootLayer) {
     auto* ancestorProperties =
         context.rootLayer->layoutObject().paintProperties();
     const auto* ancestorOverflowClip =
         ancestorProperties ? ancestorProperties->overflowClip() : nullptr;
     // Set the clip of |destinationPropertyTreeState| to be inside the
     // ancestor's overflow clip, so that that clip is not applied.
     if (context.respectOverflowClip == IgnoreOverflowClip &&
         ancestorOverflowClip)
       destinationPropertyTreeState.setClip(ancestorOverflowClip);
   }
 
   // The background rect applies all clips *above* m_layer, but not the overflow
   // clip of m_layer. It also applies a clip to the total painting bounds
   // of m_layer, because nothing in m_layer or its children within the clip can
   // paint outside of those bounds.
   // The total painting bounds includes any visual overflow (such as shadow) and
   // filter bounds.
   if (shouldClipOverflow(context)) {
     FloatRect clipRect(localVisualRect());
     clipRect.moveBy(FloatPoint(m_layer.layoutObject().paintOffset()));
-    GeometryMapper::sourceToDestinationVisualRect(
+    m_geometryMapper->sourceToDestinationVisualRect(
         sourcePropertyTreeState, destinationPropertyTreeState, clipRect);
     output.setRect(FloatClipRect(clipRect));
   } else {
     const FloatClipRect& clippedRectInRootLayerSpace =
-        GeometryMapper::sourceToDestinationClipRect(
+        m_geometryMapper->sourceToDestinationClipRect(
             sourcePropertyTreeState, destinationPropertyTreeState);
     output.setRect(clippedRectInRootLayerSpace);
   }
 
   output.moveBy(-context.rootLayer->layoutObject().paintOffset());
 }
 
 void PaintLayerClipper::initializeCommonClipRectState(
     const ClipRectsContext& context,
     PropertyTreeState& sourcePropertyTreeState,
     PropertyTreeState& destinationPropertyTreeState) const {
-  DCHECK(m_useGeometryMapper);
+  DCHECK(m_geometryMapper);
   DCHECK(m_layer.layoutObject().localBorderBoxProperties());
 
   sourcePropertyTreeState = *m_layer.layoutObject().localBorderBoxProperties();
   DCHECK(context.rootLayer->layoutObject().localBorderBoxProperties());
   destinationPropertyTreeState =
       *context.rootLayer->layoutObject().localBorderBoxProperties();
 
   auto* ancestorProperties =
       context.rootLayer->layoutObject().paintProperties();
   const auto* ancestorCssClip =
       ancestorProperties ? ancestorProperties->cssClip() : nullptr;
   // CSS clip of the root is always applied.
   if (ancestorCssClip) {
     DCHECK(destinationPropertyTreeState.clip() ==
            ancestorProperties->cssClip());
     destinationPropertyTreeState.setClip(ancestorCssClip->parent());
   }
 }
 
 void PaintLayerClipper::calculateForegroundClipRectWithGeometryMapper(
     const ClipRectsContext& context,
     ClipRect& output) const {
-  DCHECK(m_useGeometryMapper);
+  DCHECK(m_geometryMapper);
   PropertyTreeState sourcePropertyTreeState(nullptr, nullptr, nullptr);
   PropertyTreeState destinationPropertyTreeState(nullptr, nullptr, nullptr);
   initializeCommonClipRectState(context, sourcePropertyTreeState,
                                 destinationPropertyTreeState);
   const auto* properties = m_layer.layoutObject().paintProperties();
 
   if (&m_layer == context.rootLayer) {
     // Set the overflow clip for |sourcePropertyTreeState| so that it differs
     // from |destinationPropertyTreeState| in its clip.
     if (context.respectOverflowClip == RespectOverflowClip && properties &&
         properties->overflowClip())
       sourcePropertyTreeState.setClip(properties->overflowClip());
   } else {
     const auto* ancestorProperties =
         context.rootLayer->layoutObject().paintProperties();
 
     // Set the clip of |destinationPropertyTreeState| to be inside the
     // ancestor's overflow clip, so that that clip is not applied.
     if (context.respectOverflowClip == IgnoreOverflowClip &&
         ancestorProperties && ancestorProperties->overflowClip())
       destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
 
     // Set the overflow clip for |sourcePropertyTreeState| so that it differs
     // from destinationPropertyTreeState| in its clip.
     if (properties && properties->overflowClip())
       sourcePropertyTreeState.setClip(properties->overflowClip());
   }
 
   const FloatClipRect& clippedRectInRootLayerSpace =
-      GeometryMapper::sourceToDestinationClipRect(sourcePropertyTreeState,
-                                                  destinationPropertyTreeState);
+      m_geometryMapper->sourceToDestinationClipRect(
+          sourcePropertyTreeState, destinationPropertyTreeState);
   output.setRect(clippedRectInRootLayerSpace);
 
   output.moveBy(-context.rootLayer->layoutObject().paintOffset());
 }
 
 LayoutRect PaintLayerClipper::localVisualRect() const {
   const LayoutObject& layoutObject = m_layer.layoutObject();
   // The LayoutView is special since its overflow clipping rect may be larger
   // than its box rect (crbug.com/492871).
   LayoutRect layerBoundsWithVisualOverflow =
       layoutObject.isLayoutView()
           ? toLayoutView(layoutObject).viewRect()
           : toLayoutBox(layoutObject).visualOverflowRect();
   toLayoutBox(layoutObject)
       .flipForWritingMode(
           // PaintLayer are in physical coordinates, so the overflow has to be
           // flipped.
           layerBoundsWithVisualOverflow);
   if (m_layer.paintsWithFilters()) {
     layerBoundsWithVisualOverflow =
         m_layer.mapLayoutRectForFilter(layerBoundsWithVisualOverflow);
   }
   return layerBoundsWithVisualOverflow;
 }
 
 void PaintLayerClipper::calculateBackgroundClipRect(
     const ClipRectsContext& context,
     ClipRect& output) const {
-  if (m_useGeometryMapper) {
+  if (m_geometryMapper) {
     // TODO(chrishtr): fix the underlying bug that causes this situation.
     if (!m_layer.layoutObject().paintProperties() &&
         !m_layer.layoutObject().localBorderBoxProperties()) {
       output.setRect(FloatClipRect());
       return;
     }
 
     calculateBackgroundClipRectWithGeometryMapper(context, output);
 #ifdef CHECK_CLIP_RECTS
     ClipRect testBackgroundClipRect =
         PaintLayerClipper(m_layer, nullptr).backgroundClipRect(context);
     CHECK_RECTS_EQ(testBackgroundClipRect, output);
 #endif
     return;
   }
   DCHECK(m_layer.parent());
   LayoutView* layoutView = m_layer.layoutObject().view();
   DCHECK(layoutView);
 
   RefPtr<ClipRects> parentClipRects = ClipRects::create();
   if (&m_layer == context.rootLayer) {
     parentClipRects->reset(LayoutRect(LayoutRect::infiniteIntRect()));
   } else {
-    PaintLayerClipper(*m_layer.parent(), m_useGeometryMapper)
+    PaintLayerClipper(*m_layer.parent(), m_geometryMapper)
         .getOrCalculateClipRects(context, *parentClipRects);
   }
 
   output = backgroundClipRectForPosition(
       *parentClipRects, m_layer.layoutObject().styleRef().position());
 
   // Note: infinite clipRects should not be scrolled here, otherwise they will
   // accidentally no longer be considered infinite.
   if (parentClipRects->fixed() &&
       &context.rootLayer->layoutObject() == layoutView &&
       output != LayoutRect(LayoutRect::infiniteIntRect()))
     output.move(LayoutSize(layoutView->frameView()->getScrollOffset()));
 }
 
 void PaintLayerClipper::getOrCalculateClipRects(const ClipRectsContext& context,
                                                 ClipRects& clipRects) const {
-  DCHECK(!m_useGeometryMapper);
+  DCHECK(!m_geometryMapper);
 
   if (context.usesCache())
     clipRects = getClipRects(context);
   else
     calculateClipRects(context, clipRects);
 }
 
 bool PaintLayerClipper::shouldClipOverflow(
     const ClipRectsContext& context) const {
   if (!m_layer.layoutObject().isBox())
@@ skipping 18 matching lines @@
       context.respectOverflowClipForViewport == IgnoreOverflowClip)
     return false;
 
   return true;
 }
 
 ClipRects& PaintLayerClipper::paintingClipRects(
     const PaintLayer* rootLayer,
     ShouldRespectOverflowClipType respectOverflowClip,
     const LayoutSize& subpixelAccumulation) const {
-  DCHECK(!m_useGeometryMapper);
+  DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnorePlatformOverlayScrollbarSize,
                            subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink