Move LayoutObject::m_previousPosition... into a global map in ObjectPaintInvalidator

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 1571 matching lines @@
   const LayoutRect& previousVisualRect() const { return m_previousVisualRect; }
 
   // 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;
-  }
-  void setPreviousPositionFromPaintInvalidationBacking(
-      const LayoutPoint& positionFromPaintInvalidationBacking) {
-    m_previousPositionFromPaintInvalidationBacking =
-        positionFromPaintInvalidationBacking;
-  }
-
   PaintInvalidationReason fullPaintInvalidationReason() const {
     return m_bitfields.fullPaintInvalidationReason();
   }
   bool shouldDoFullPaintInvalidation() const {
     return m_bitfields.fullPaintInvalidationReason() != PaintInvalidationNone;
   }
   void setShouldDoFullPaintInvalidation(
       PaintInvalidationReason = PaintInvalidationFull);
   void clearShouldDoFullPaintInvalidation() {
     m_bitfields.setFullPaintInvalidationReason(PaintInvalidationNone);
@@ skipping 70 matching lines @@
     void setShouldDoFullPaintInvalidation(PaintInvalidationReason reason) {
       m_layoutObject.setShouldDoFullPaintInvalidation(reason);
     }
     void ensureIsReadyForPaintInvalidation() {
       m_layoutObject.ensureIsReadyForPaintInvalidation();
     }
 
     void setPreviousVisualRect(const LayoutRect& r) {
       m_layoutObject.setPreviousVisualRect(r);
     }
-    void setPreviousPositionFromPaintInvalidationBacking(const LayoutPoint& p) {
-      m_layoutObject.setPreviousPositionFromPaintInvalidationBacking(p);
+    void setHasPreviousLocationInBacking(bool b) {
+      m_layoutObject.m_bitfields.setHasPreviousLocationInBacking(b);
     }
     void setPreviousBackgroundObscured(bool b) {
       m_layoutObject.setPreviousBackgroundObscured(b);
     }
     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() {
       return const_cast<ObjectPaintProperties*>(
           m_layoutObject.paintProperties());
@@ skipping 34 matching lines @@
     return m_bitfields.previousBackgroundObscured();
   }
   void setPreviousBackgroundObscured(bool b) {
     m_bitfields.setPreviousBackgroundObscured(b);
   }
 
   bool isBackgroundAttachmentFixedObject() const {
     return m_bitfields.isBackgroundAttachmentFixedObject();
   }
 
+  // ObjectPaintInvalidator will access the internal global map storing
+  // previousLocationInBacking only when the flag is set, to avoid unnecessary
+  // map lookups.
+  bool hasPreviousLocationInBacking() const {
+    return m_bitfields.hasPreviousLocationInBacking();
+  }
+
  protected:
   enum LayoutObjectType {
     LayoutObjectBr,
     LayoutObjectCanvas,
     LayoutObjectFieldset,
     LayoutObjectCounter,
     LayoutObjectDetailsMarker,
     LayoutObjectEmbeddedObject,
     LayoutObjectFileUploadControl,
     LayoutObjectFrame,
@@ skipping 158 matching lines @@
   void removeFromLayoutFlowThread();
 
   bool containsInlineWithOutlineAndContinuation() const {
     return m_bitfields.containsInlineWithOutlineAndContinuation();
   }
   void setContainsInlineWithOutlineAndContinuation(bool b) {
     m_bitfields.setContainsInlineWithOutlineAndContinuation(b);
   }
 
  private:
-  // 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.
+  // Adjusts a visual rect in the space of |m_previousVisualRect| 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*);
 
@@ skipping 138 matching lines @@
           m_notifiedOfSubtreeChange(false),
           m_consumesSubtreeChangeNotification(false),
           m_childrenInline(false),
           m_containsInlineWithOutlineAndContinuation(false),
           m_alwaysCreateLineBoxesForLayoutInline(false),
           m_previousBackgroundObscured(false),
           m_isBackgroundAttachmentFixedObject(false),
           m_isScrollAnchorObject(false),
           m_scrollAnchorDisablingStyleChanged(false),
           m_hasBoxDecorationBackground(false),
+          m_hasPreviousLocationInBacking(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 138 matching lines @@
     // layout should suppress any adjustments that would be made during the next
     // layout by ScrollAnchor objects for which this LayoutObject is on the path
     // from the anchor node to the scroller.
     // See http://bit.ly/sanaclap for more info.
     ADD_BOOLEAN_BITFIELD(scrollAnchorDisablingStyleChanged,
                          ScrollAnchorDisablingStyleChanged);
 
     ADD_BOOLEAN_BITFIELD(hasBoxDecorationBackground,
                          HasBoxDecorationBackground);
 
+    ADD_BOOLEAN_BITFIELD(hasPreviousLocationInBacking,
+                         HasPreviousLocationInBacking);
+
    private:
     // This is the cached 'position' value of this object
     // (see ComputedStyle::position).
     unsigned m_positionedState : 2;  // PositionedState
     unsigned m_selectionState : 3;   // SelectionState
     // Mutable for getter which lazily update this field.
     mutable unsigned
         m_backgroundObscurationState : 2;        // BackgroundObscurationState
     unsigned m_fullPaintInvalidationReason : 5;  // PaintInvalidationReason
 
@@ skipping 71 matching lines @@
   }
 
  private:
   // Store state between styleWillChange and styleDidChange
   static bool s_affectsParentBlock;
 
   // 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.
 class DeprecatedDisableModifyLayoutTreeStructureAsserts {
   STACK_ALLOCATED();
   WTF_MAKE_NONCOPYABLE(DeprecatedDisableModifyLayoutTreeStructureAsserts);
 
  public:
   DeprecatedDisableModifyLayoutTreeStructureAsserts();
@@ skipping 201 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