Rename "paint invalidation rect" etc. to "visual rect".

third_party/WebKit/Source/core/layout/LayoutObject.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 672 matching lines @@
   // SVGLocatable::getBBox().
   // NOTE: Markers are not specifically ignored here by SVG 1.1 spec, but we
   // ignore them since stroke-width is ignored (and marker size can depend on
   // stroke-width). objectBoundingBox is returned local coordinates.
   // The name objectBoundingBox is taken from the SVG 1.1 spec.
   virtual FloatRect objectBoundingBox() const;
   virtual FloatRect strokeBoundingBox() const;
 
   // Returns the smallest rectangle enclosing all of the painted content
   // respecting clipping, masking, filters, opacity, stroke-width and markers
-  virtual FloatRect paintInvalidationRectInLocalSVGCoordinates() const;
+  virtual FloatRect visualRectInLocalSVGCoordinates() const;
 
   // This only returns the transform="" value from the SVG element.
   // Most callsites want localToParentTransform() instead.
   virtual AffineTransform localSVGTransform() const;
 
   // Returns the full transform mapping from local coordinates to local coords
   // for the parent SVG layoutObject
   // This includes any viewport transforms and x/y offsets as well as the
   // transform="" value off the element.
   virtual const AffineTransform& localToSVGParentTransform() const;
@@ skipping 640 matching lines @@
   // shouldDoFullPaintInvalidation is false, but mayNeedPaintInvalidation or
   // childShouldCheckForPaintInvalidation is true) to avoid unnecessary paint
   // invalidations of empty areas covered by such objects.
   virtual bool paintedOutputOfObjectHasNoEffectRegardlessOfSize() const {
     return false;
   }
 
   // Returns the rect that should have paint invalidated whenever this object
   // changes. The rect is in the view's coordinate space. This method deals with
   // outlines and overflow.
-  virtual LayoutRect absoluteClippedOverflowRect() const;
+  virtual LayoutRect absoluteVisualRect() const;
 
   // Returns the rect that should have paint invalidated whenever this object
   // changes. The rect is in the object's local coordinate space. This is for
-  // non-SVG objects and LayoutSVGRoot only.
-  // SVG objects (except LayoutSVGRoot) should use
-  // paintInvalidationRectInLocalSVGCoordinates() and map with SVG transforms
+  // non-SVG objects and LayoutSVGRoot only. SVG objects (except LayoutSVGRoot)
+  // should use visualRectInLocalSVGCoordinates() and map with SVG transforms
   // instead.
-  virtual LayoutRect localOverflowRectForPaintInvalidation() const;
+  virtual LayoutRect localVisualRect() const;
 
   // Given a rect in the object's coordinate space, mutates the rect into one
   // representing the size of its visual painted output as if |ancestor| was the
   // root of the page: the rect is modified by any intervening clips, transforms
   // and scrolls between |this| and |ancestor| (not inclusive of |ancestor|),
   // but not any above |ancestor|.
   // The output is in the physical, painted coordinate pixel space of
   // |ancestor|.
   // Overflow clipping, CSS clipping and scrolling is *not* applied for
   // |ancestor| itself if |ancestor| scrolls overflow.
@@ skipping 215 matching lines @@
 
   // Compute a list of hit-test rectangles per layer rooted at this
   // layoutObject.
   virtual void computeLayerHitTestRects(LayerHitTestRects&) const;
 
   static RespectImageOrientationEnum shouldRespectImageOrientation(
       const LayoutObject*);
 
   bool isRelayoutBoundaryForInspector() const;
 
-  // The previous paint invalidation rect, in the the space of the paint
-  // invalidation container (*not* the graphics layer that paints
-  // this object).
-  LayoutRect previousPaintInvalidationRectIncludingCompositedScrolling(
+  // The previous visual rect, in the the space of the paint invalidation
+  // container (*not* the graphics layer that paints this object).
+  LayoutRect previousVisualRectIncludingCompositedScrolling(
       const LayoutBoxModelObject& paintInvalidationContainer) const;
 
   // The returned rect does *not* account for composited scrolling.
-  const LayoutRect& previousPaintInvalidationRect() const {
-    return m_previousPaintInvalidationRect;
-  }
+  const LayoutRect& previousVisualRect() const { return m_previousVisualRect; }
 
-  // Called when the previous paint invalidation rect(s) is no longer valid.
-  virtual void clearPreviousPaintInvalidationRects();
+  // Called when the previous visual rect(s) is no longer valid.
+  virtual void clearPreviousVisualRects();
 
   // Only adjusts if the paint invalidation container is not a composited
   // scroller.
   void adjustPreviousPaintInvalidationForScrollIfNeeded(
       const DoubleSize& scrollDelta);
 
   // The previous position of the top-left corner of the object in its previous
   // paint backing.
   const LayoutPoint& previousPositionFromPaintInvalidationBacking() const {
     return m_previousPositionFromPaintInvalidationBacking;
@@ skipping 84 matching lines @@
     void clearPaintInvalidationFlags() {
       m_layoutObject.clearPaintInvalidationFlags();
     }
     void setShouldDoFullPaintInvalidation(PaintInvalidationReason reason) {
       m_layoutObject.setShouldDoFullPaintInvalidation(reason);
     }
     void ensureIsReadyForPaintInvalidation() {
       m_layoutObject.ensureIsReadyForPaintInvalidation();
     }
 
-    void setPreviousPaintInvalidationRect(const LayoutRect& r) {
-      m_layoutObject.setPreviousPaintInvalidationRect(r);
+    void setPreviousVisualRect(const LayoutRect& r) {
+      m_layoutObject.setPreviousVisualRect(r);
     }
     void setPreviousPositionFromPaintInvalidationBacking(const LayoutPoint& p) {
       m_layoutObject.setPreviousPositionFromPaintInvalidationBacking(p);
     }
     void setPreviousBackgroundObscured(bool b) {
       m_layoutObject.setPreviousBackgroundObscured(b);
     }
-    void clearPreviousPaintInvalidationRects() {
-      m_layoutObject.clearPreviousPaintInvalidationRects();
+    void clearPreviousVisualRects() {
+      m_layoutObject.clearPreviousVisualRects();
     }
 
    protected:
     friend class PaintPropertyTreeBuilder;
     // The following two functions can be called from PaintPropertyTreeBuilder
     // only.
     ObjectPaintProperties& ensurePaintProperties() {
       return m_layoutObject.ensurePaintProperties();
     }
     ObjectPaintProperties* paintProperties() {
@@ skipping 166 matching lines @@
                                     const PaintLayer* currentLayer,
                                     const LayoutPoint& layerOffset,
                                     const LayoutRect& containerRect) const;
 
   // Add hit-test rects for this layoutObject only to the provided list.
   // layerOffset is the offset of this layoutObject within the current layer
   // that should be used for each result.
   virtual void computeSelfHitTestRects(Vector<LayoutRect>&,
                                        const LayoutPoint& layerOffset) const {}
 
-  void setPreviousPaintInvalidationRect(const LayoutRect& rect) {
-    m_previousPaintInvalidationRect = rect;
+  void setPreviousVisualRect(const LayoutRect& rect) {
+    m_previousVisualRect = rect;
   }
 
 #if ENABLE(ASSERT)
   virtual bool paintInvalidationStateIsDirty() const {
     return shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState();
   }
 #endif
 
   // Called before paint invalidation.
   virtual void ensureIsReadyForPaintInvalidation() { DCHECK(!needsLayout()); }
@@ skipping 27 matching lines @@
   void removeFromLayoutFlowThread();
 
   bool containsInlineWithOutlineAndContinuation() const {
     return m_bitfields.containsInlineWithOutlineAndContinuation();
   }
   void setContainsInlineWithOutlineAndContinuation(bool b) {
     m_bitfields.setContainsInlineWithOutlineAndContinuation(b);
   }
 
  private:
-  // Adjusts a paint invalidation rect in the space of
-  // |m_previousPaintInvalidationRect| and
-  // |m_previousPositionFromPaintInvalidationBacking|
-  // to be in the space of the |paintInvalidationContainer|, if needed. They can
-  // be different only if |paintInvalidationContainer| is a composited scroller.
-  void adjustInvalidationRectForCompositedScrolling(
+  // Adjusts a visual rect in the space of |m_previousVisualRect| and
+  // |m_previousPositionFromPaintInvalidationBacking| to be in the space of the
+  // |paintInvalidationContainer|, if needed. They can be different only if
+  // |paintInvalidationContainer| is a composited scroller.
+  void adjustVisualRectForCompositedScrolling(
       LayoutRect&,
       const LayoutBoxModelObject& paintInvalidationContainer) const;
 
   void clearLayoutRootIfNeeded() const;
 
   bool isInert() const;
 
   void updateImage(StyleImage*, StyleImage*);
 
   void scheduleRelayout();
@@ skipping 388 matching lines @@
     m_bitfields.setSelfNeedsOverflowRecalcAfterStyleChange(true);
   }
   void setChildNeedsOverflowRecalcAfterStyleChange() {
     m_bitfields.setChildNeedsOverflowRecalcAfterStyleChange(true);
   }
 
  private:
   // Store state between styleWillChange and styleDidChange
   static bool s_affectsParentBlock;
 
-  // This stores the paint invalidation rect from the previous frame. This rect
-  // does *not* account for composited scrolling. See
-  // adjustInvalidationRectForCompositedScrolling().
-  LayoutRect m_previousPaintInvalidationRect;
+  // This stores the visual rect from the previous frame. This rect does *not*
+  // account for composited scrolling. See
+  // adjustVisualRectForCompositedScrolling().
+  LayoutRect m_previousVisualRect;
 
   // This stores the position in the paint invalidation backing's coordinate.
   // It is used to detect layoutObject shifts that forces a full invalidation.
   // This point does *not* account for composited scrolling. See
   // adjustInvalidationRectForCompositedScrolling().
   LayoutPoint m_previousPositionFromPaintInvalidationBacking;
 };
 
 // FIXME: remove this once the layout object lifecycle ASSERTS are no longer
 // hit.
@@ skipping 207 matching lines @@
 CORE_EXPORT void showLineTree(const blink::LayoutObject*);
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showLayoutTree
 // can be called from gdb easily.
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1,
                                 const blink::LayoutObject* object2);
 
 #endif
 
 #endif  // LayoutObject_h