[SPInvalidation] Handle pixel-snapping of paint invalidation rects

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 1581 matching lines @@
   // invalidation container (*not* the graphics layer that paints
   // this object).
   LayoutRect previousPaintInvalidationRectIncludingCompositedScrolling(
       const LayoutBoxModelObject& paintInvalidationContainer) const;
 
   // The returned rect does *not* account for composited scrolling.
   const LayoutRect& previousPaintInvalidationRect() const {
     return m_previousPaintInvalidationRect;
   }
 
+  // The previous paint invalidation rect may have been expanded to whole pixels
+  // or be rotated, skewed, etc., so covers more pixels than the object covers.
+  bool previousPaintInvalidationRectCoversExtraPixels() const {
+    return m_bitfields.previousPaintInvalidationRectCoversExtraPixels();
+  }
+
   // Called when the previous paint invalidation rect(s) is no longer valid.
   virtual void clearPreviousPaintInvalidationRects();
 
   // 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.
@@ skipping 86 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) {
+    void setPreviousPaintInvalidationRect(const LayoutRect& r,

[pdr., 2016/10/26 20:59:29]

Idea: Could we refactor this to take a PaintInvalidationRectInBacking?
(If it's a good idea and simple, lets include it in this patch. If not, just
ignore or we can do it in a followup).

[Xianzhu, 2016/10/26 21:05:21]

I didn't want to include PaintInvalidator.h from LayoutObject.h or vice versa,
so kept this to make them independent.

+                                          bool coversExtraPixels) {
       m_layoutObject.setPreviousPaintInvalidationRect(r);
+      m_layoutObject.m_bitfields
+          .setPreviousPaintInvalidationRectCoversExtraPixels(coversExtraPixels);
     }
     void setPreviousPositionFromPaintInvalidationBacking(const LayoutPoint& p) {
       m_layoutObject.setPreviousPositionFromPaintInvalidationBacking(p);
     }
     void setPreviousBackgroundObscured(bool b) {
       m_layoutObject.setPreviousBackgroundObscured(b);
     }
     void clearPreviousPaintInvalidationRects() {
       m_layoutObject.clearPreviousPaintInvalidationRects();
     }
@@ skipping 366 matching lines @@
           m_posChildNeedsLayout(false),
           m_needsSimplifiedNormalFlowLayout(false),
           m_selfNeedsOverflowRecalcAfterStyleChange(false),
           m_childNeedsOverflowRecalcAfterStyleChange(false),
           m_preferredLogicalWidthsDirty(false),
           m_childShouldCheckForPaintInvalidation(false),
           m_mayNeedPaintInvalidation(false),
           m_mayNeedPaintInvalidationSubtree(false),
           m_mayNeedPaintInvalidationAnimatedBackgroundImage(false),
           m_shouldInvalidateSelection(false),
+          m_previousPaintInvalidationRectCoversExtraPixels(false),
           m_floating(false),
           m_isAnonymous(!node),
           m_isText(false),
           m_isBox(false),
           m_isInline(true),
           m_isAtomicInlineLevel(false),
           m_horizontalWritingMode(true),
           m_hasLayer(false),
           m_hasOverflowClip(false),
           m_hasTransformRelatedProperty(false),
@@ skipping 11 matching lines @@
           m_previousBackgroundObscured(false),
           m_isBackgroundAttachmentFixedObject(false),
           m_isScrollAnchorObject(false),
           m_scrollAnchorDisablingStyleChanged(false),
           m_hasBoxDecorationBackground(false),
           m_positionedState(IsStaticallyPositioned),
           m_selectionState(SelectionNone),
           m_backgroundObscurationState(BackgroundObscurationStatusInvalid),
           m_fullPaintInvalidationReason(PaintInvalidationNone) {}
 
-    // 32 bits have been used in the first word, and 19 in the second.
+    // 32 bits have been used in the first word, and 20 in the second.
 
     // Self needs layout means that this layout object is marked for a full
     // layout. This is the default layout but it is expensive as it recomputes
     // everything. For CSS boxes, this includes the width (laying out the line
     // boxes again), the margins (due to block collapsing margins), the
     // positions, the height and the potential overflow.
     ADD_BOOLEAN_BITFIELD(selfNeedsLayout, SelfNeedsLayout);
 
     // A positioned movement layout is a specialized type of layout used on
     // positioned objects that only visually moved. This layout is used when
@@ skipping 47 matching lines @@
 
     ADD_BOOLEAN_BITFIELD(childShouldCheckForPaintInvalidation,
                          ChildShouldCheckForPaintInvalidation);
     ADD_BOOLEAN_BITFIELD(mayNeedPaintInvalidation, MayNeedPaintInvalidation);
     ADD_BOOLEAN_BITFIELD(mayNeedPaintInvalidationSubtree,
                          MayNeedPaintInvalidationSubtree);
     ADD_BOOLEAN_BITFIELD(mayNeedPaintInvalidationAnimatedBackgroundImage,
                          MayNeedPaintInvalidationAnimatedBackgroundImage);
     ADD_BOOLEAN_BITFIELD(shouldInvalidateSelection, ShouldInvalidateSelection);
 
+    ADD_BOOLEAN_BITFIELD(previousPaintInvalidationRectCoversExtraPixels,
+                         PreviousPaintInvalidationRectCoversExtraPixels);
+
     // This boolean is the cached value of 'float'
     // (see ComputedStyle::isFloating).
     ADD_BOOLEAN_BITFIELD(floating, Floating);
 
     ADD_BOOLEAN_BITFIELD(isAnonymous, IsAnonymous);
     ADD_BOOLEAN_BITFIELD(isText, IsText);
     ADD_BOOLEAN_BITFIELD(isBox, IsBox);
 
     // This boolean represents whether the LayoutObject is 'inline-level'
     // (a CSS concept). Inline-level boxes are laid out inside a line. If
@@ skipping 389 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