[SPInvalidation] Use GeometryMapper in PaintLayerClipper for paint.

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 96 matching lines @@
         intersection(newClip, clipRects.posClipRect()).setIsClippedByClipCss());
     clipRects.setOverflowClipRect(
         intersection(newClip, clipRects.overflowClipRect())
             .setIsClippedByClipCss());
     clipRects.setFixedClipRect(intersection(newClip, clipRects.fixedClipRect())
                                    .setIsClippedByClipCss());
   }
 }
 
 PaintLayerClipper::PaintLayerClipper(const PaintLayer& layer,
-                                     bool useGeometryMapper)
-    : m_layer(layer),
-      m_geometryMapper(useGeometryMapper ? new GeometryMapper : nullptr) {}
+                                     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_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 = &m_layer.parent()->clipper().getClipRects(context);
+  if (context.rootLayer != &m_layer && m_layer.parent()) {
+    parentClipRects =
+        &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);
-
-  if (m_geometryMapper)
-    m_geometryMapper.reset(new GeometryMapper);
 }
 
 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();
-    currentLayer->clipper().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_geometryMapper) {
@@ skipping 186 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) {
-    parentLayer->clipper().getOrCalculateClipRects(context, clipRects);
+    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
     // the PaintLayerCompositor overlapMap, where clipRects are needed in view
@@ skipping 89 matching lines @@
         PaintLayerClipper(m_layer, false).backgroundClipRect(context);
     CHECK_RECTS_EQ(testBackgroundClipRect, backgroundClipRect);
 #endif
     return backgroundClipRect;
   }
   DCHECK(m_layer.parent());
   LayoutView* layoutView = m_layer.layoutObject()->view();
   DCHECK(layoutView);
 
   RefPtr<ClipRects> parentClipRects = ClipRects::create();
-  if (&m_layer == context.rootLayer)
+  if (&m_layer == context.rootLayer) {
     parentClipRects->reset(LayoutRect(LayoutRect::infiniteIntRect()));
-  else
-    m_layer.parent()->clipper().getOrCalculateClipRects(context,
-                                                        *parentClipRects);
+  } else {
+    PaintLayerClipper(*m_layer.parent(), m_geometryMapper)
+        .getOrCalculateClipRects(context, *parentClipRects);
+  }
 
   ClipRect result = 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 &&
       result != LayoutRect(LayoutRect::infiniteIntRect()))
     result.move(LayoutSize(layoutView->frameView()->getScrollOffset()));
 
   return result;
 }
 
 void PaintLayerClipper::getOrCalculateClipRects(const ClipRectsContext& context,
                                                 ClipRects& clipRects) const {
+  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())
     return false;
@@ skipping 26 matching lines @@
     const LayoutSize& subpixelAccumulation) const {
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnoreOverlayScrollbarSize, subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink