SPv2: Use GeometryMapper to implement PaintLayerClipper.

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

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. 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 30 matching lines @@
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #ifndef PaintLayerClipper_h
 #define PaintLayerClipper_h
 
 #include "core/CoreExport.h"
 #include "core/layout/ClipRectsCache.h"
 #include "core/layout/ScrollEnums.h"
+
+#include "platform/graphics/paint/GeometryMapper.h"
+
 #include "wtf/Allocator.h"
 
 namespace blink {
 
 class PaintLayer;
 
 enum ShouldRespectOverflowClipType { IgnoreOverflowClip, RespectOverflowClip };
 
 class ClipRectsContext {
   STACK_ALLOCATED();
@@ skipping 36 matching lines @@
 
   ClipRectsCacheSlot m_cacheSlot;
   LayoutSize subPixelAccumulation;
   ShouldRespectOverflowClipType respectOverflowClip;
   ShouldRespectOverflowClipType respectOverflowClipForViewport;
 };
 
 // PaintLayerClipper is responsible for computing and caching clip
 // rects.
 //
+// These clip rects have two types: background and foreground.
+//
+// The "background rect" for a PaintLayer is almost the same as its visual
+// rect in the space of some ancestor PaintLayer (specified by rootLayer on ClipRectsContext).
+// The only differences are that:
+//   * The unclipped rect at the start is LayoutRect::infiniteIntRect,
+// rather than the local overflow bounds of the PaintLayer.
+//   * CSS clip, the extent of visualOverflowRect(), and SVG root viewport clipping is applied.
+// Thus, for example if there are no clips then the background rect will be infinite.
+// Also, whether overflow clip of the ancestor should be applied is a parameter.
+//
+// The "foreground rect" for a PaintLayer is its "background rect", intersected
+// with any clip applied by this PaintLayer to its children.
+
+// Motivation for this class:
+//
 // The main reason for this cache is that we compute the clip rects during
 // a layout tree walk but need them during a paint tree walk (see example
 // below for some explanations).
 //
 // A lot of complexity in this class come from the difference in inheritance
 // between 'overflow' and 'clip':
 // * 'overflow' applies based on the containing blocks chain.
 //    (http://www.w3.org/TR/CSS2/visufx.html#propdef-overflow)
 // * 'clip' applies to all descendants.
 //    (http://www.w3.org/TR/CSS2/visufx.html#propdef-clip)
@@ skipping 26 matching lines @@
 // Now instead if we add "clip: rect(0px, 100px, 100px, 0px)" to #container,
 // the clip will apply to both #inflow and #fixed. That's because 'clip'
 // applies to any descendant, regardless of containing blocks. Note that
 // #container and #fixed are siblings in the paint tree but #container does
 // clip #fixed. This is the reason why we compute the painting clip rects during
 // a layout tree walk and cache them for painting.
 class CORE_EXPORT PaintLayerClipper {
   DISALLOW_NEW();
 
  public:
-  explicit PaintLayerClipper(const PaintLayer& layer) : m_layer(layer) {}
+  explicit PaintLayerClipper(const PaintLayer&, bool useGeometryMapper);
 
   void clearClipRectsIncludingDescendants();
   void clearClipRectsIncludingDescendants(ClipRectsCacheSlot);
 
   // Returns the background clip rect of the layer in the local coordinate
   // space. Only looks for clips up to the given ancestor.
   LayoutRect localClipRect(const PaintLayer* ancestorLayer) const;
 
+  // Computes the same thing as backgroundRect in calculateRects(), but sk
   ClipRect backgroundClipRect(const ClipRectsContext&) const;
 
   // This method figures out our layerBounds in coordinates relative to
   // |rootLayer|. It also computes our background and foreground clip rects
-  // for painting/event handling.
-  // Pass offsetFromRoot if known.
+  // for painting/event handling. Pass offsetFromRoot if known.
   void calculateRects(const ClipRectsContext&,
                       const LayoutRect& paintDirtyRect,
                       LayoutRect& layerBounds,
                       ClipRect& backgroundRect,
                       ClipRect& foregroundRect,
                       const LayoutPoint* offsetFromRoot = 0) const;
 
   ClipRects& paintingClipRects(const PaintLayer* rootLayer,
                                ShouldRespectOverflowClipType,
                                const LayoutSize& subpixelAccumulation) const;
 
  private:
   ClipRects& getClipRects(const ClipRectsContext&) const;
 
   void calculateClipRects(const ClipRectsContext&, ClipRects&) const;
   ClipRects* clipRectsIfCached(const ClipRectsContext&) const;
   ClipRects& storeClipRectsInCache(const ClipRectsContext&,
                                    ClipRects* parentClipRects,
                                    const ClipRects&) const;
 
   void getOrCalculateClipRects(const ClipRectsContext&, ClipRects&) const;
 
   bool shouldRespectOverflowClip(const ClipRectsContext&) const;
 
+  ClipRect clipRectWithGeometryMapper(const ClipRectsContext&,
+                                      bool isForeground) const;
+  void mapLocalToRootWithGeometryMapper(const ClipRectsContext&,
+                                        LayoutRect& localRect) const;
+  void calculateRectsWithGeometryMapper(
+      const ClipRectsContext&,
+      const LayoutRect& paintDirtyRect,
+      LayoutRect& layerBounds,
+      ClipRect& backgroundRect,
+      ClipRect& foregroundRect,
+      const LayoutPoint* offsetFromRoot = 0) const;
+
+  ClipRect applyOverflowClipToBackgroundRectWithGeometryMapper(
+      const ClipRectsContext&,
+      const ClipRect&) const;
+
   const PaintLayer& m_layer;
+  std::unique_ptr<GeometryMapper> m_geometryMapper;
 };
 
 }  // namespace blink
 
 #endif  // LayerClipper_h