Cleanup bitfield accessors for slimming paint v2

Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 657 matching lines @@
         if (LayoutFlowThread* flowThread = layoutState->flowThread())
             return flowThread;
     }
 
     // Not in the middle of layout so have to find the thread the slow way.
     return LayoutFlowThread::locateFlowThreadContainingBlockOf(*this);
 }
 
 bool LayoutObject::skipInvalidationWhenLaidOutChildren() const
 {
-    if (!neededLayoutBecauseOfChildren())
+    if (!m_bitfields.neededLayoutBecauseOfChildren())
         return false;
 
     // SVG layoutObjects need to be invalidated when their children are laid out.
     // LayoutBlocks with line boxes are responsible to invalidate them so we can't ignore them.
     if (isSVG() || (isLayoutBlockFlow() && toLayoutBlockFlow(this)->firstLineBox()))
         return false;
 
     // In case scrollbars got repositioned (which will typically happen if the layout object got
     // resized), we cannot skip invalidation.
     if (hasNonCompositedScrollbars())
@@ skipping 60 matching lines @@
             return;
         if (!last->isTextOrSVGChild() && last->style()->hasOutOfFlowPosition()) {
             bool willSkipRelativelyPositionedInlines = !object->isLayoutBlock() || object->isAnonymousBlock();
             // Skip relatively positioned inlines and anonymous blocks to get to the enclosing LayoutBlock.
             while (object && (!object->isLayoutBlock() || object->isAnonymousBlock()))
                 object = object->container();
             if (!object || object->posChildNeedsLayout())
                 return;
             if (willSkipRelativelyPositionedInlines)
                 container = object->container();
-            object->setPosChildNeedsLayout(true);
+            object->m_bitfields.setPosChildNeedsLayout(true);
             simplifiedNormalFlowLayout = true;
             ASSERT(!object->isSetNeedsLayoutForbidden());
         } else if (simplifiedNormalFlowLayout) {
             if (object->needsSimplifiedNormalFlowLayout())
                 return;
-            object->setNeedsSimplifiedNormalFlowLayout(true);
+            object->m_bitfields.setNeedsSimplifiedNormalFlowLayout(true);
             ASSERT(!object->isSetNeedsLayoutForbidden());
         } else {
             if (object->normalChildNeedsLayout())
                 return;
-            object->setNormalChildNeedsLayout(true);
+            object->m_bitfields.setNormalChildNeedsLayout(true);
             ASSERT(!object->isSetNeedsLayoutForbidden());
         }
 
         if (layouter) {
             layouter->recordObjectMarkedForLayout(object);
             if (object == layouter->root())
                 return;
         }
 
         last = object;
@@ skipping 560 matching lines @@
             return;
         selectionPaintInvalidationMap = new SelectionPaintInvalidationMap();
     }
 
     if (selectionRect.isEmpty())
         selectionPaintInvalidationMap->remove(this);
     else
         selectionPaintInvalidationMap->set(this, selectionRect);
 }
 
+// TODO: Remove this for slimming paint v2 because we don't care about paint invalidation rects.
 inline void LayoutObject::invalidateSelectionIfNeeded(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason)
 {
     // Update selection rect when we are doing full invalidation (in case that the object is moved, composite status changed, etc.)
     // or shouldInvalidationSelection is set (in case that the selection itself changed).
     bool fullInvalidation = view()->doingFullPaintInvalidation() || isFullPaintInvalidationReason(invalidationReason);
     if (!fullInvalidation && !shouldInvalidateSelection())
         return;
 
     LayoutRect oldSelectionRect = previousSelectionRectForPaintInvalidation();
     LayoutRect newSelectionRect = selectionRectForPaintInvalidation(&paintInvalidationContainer);
@@ skipping 460 matching lines @@
         // TODO(rune@opera.com): We should use the diff to determine whether a repaint vs. layout
         // is needed, but for now just assume a layout will be required. The diff code
         // in LayoutObject::setStyle would need to be factored out so that it could be reused.
         setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::StyleChange);
     }
 }
 
 void LayoutObject::markContainingBlocksForOverflowRecalc()
 {
     for (LayoutBlock* container = containingBlock(); container && !container->childNeedsOverflowRecalcAfterStyleChange(); container = container->containingBlock())
-        container->setChildNeedsOverflowRecalcAfterStyleChange(true);
+        container->m_bitfields.setChildNeedsOverflowRecalcAfterStyleChange(true);
 }
 
 void LayoutObject::setNeedsOverflowRecalcAfterStyleChange()
 {
     bool neededRecalc = needsOverflowRecalcAfterStyleChange();
-    setSelfNeedsOverflowRecalcAfterStyleChange(true);
+    m_bitfields.setSelfNeedsOverflowRecalcAfterStyleChange(true);
     if (!neededRecalc)
         markContainingBlocksForOverflowRecalc();
 }
 
 void LayoutObject::setStyle(PassRefPtr<ComputedStyle> style)
 {
     ASSERT(style);
 
     if (m_style == style) {
         // We need to run through adjustStyleDifference() for iframes, plugins, and canvas so
@@ skipping 813 matching lines @@
 }
 
 PositionWithAffinity LayoutObject::positionForPoint(const LayoutPoint&)
 {
     return createPositionWithAffinity(caretMinOffset());
 }
 
 void LayoutObject::updateDragState(bool dragOn)
 {
     bool valueChanged = (dragOn != isDragging());
-    setIsDragging(dragOn);
+    m_bitfields.setIsDragging(dragOn);
     if (valueChanged && node()) {
         if (node()->isElementNode() && toElement(node())->childrenOrSiblingsAffectedByDrag())
             node()->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Drag));
         else if (style()->affectedByDrag())
             node()->setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Drag));
     }
     for (LayoutObject* curr = slowFirstChild(); curr; curr = curr->nextSibling())
         curr->updateDragState(dragOn);
 }
 
@@ skipping 64 matching lines @@
             if (LayoutView* layoutView = view()) {
                 if (FrameView* frameView = layoutView->frameView())
                     frameView->scheduleRelayoutOfSubtree(this);
             }
         }
     }
 }
 
 void LayoutObject::forceLayout()
 {
-    setSelfNeedsLayout(true);
+    m_bitfields.setSelfNeedsLayout(true);
     setShouldDoFullPaintInvalidation();
     layout();
 }
 
 // FIXME: Does this do anything different than forceLayout given that we don't walk
 // the containing block chain. If not, we should change all callers to use forceLayout.
 void LayoutObject::forceChildLayout()
 {
-    setNormalChildNeedsLayout(true);
+    m_bitfields.setNormalChildNeedsLayout(true);
     layout();
 }
 
 enum StyleCacheState {
     Cached,
     Uncached
 };
 
 static PassRefPtr<ComputedStyle> firstLineStyleForCachedUncachedType(StyleCacheState type, const LayoutObject* layoutObject, ComputedStyle* style)
 {
@@ skipping 417 matching lines @@
     case DocumentLifecycle::InCompositingUpdate:
         return PaintInvalidationCompositingUpdate;
     default:
         return PaintInvalidationFull;
     }
 }
 
 inline void LayoutObject::markContainerChainForPaintInvalidation()
 {
     for (LayoutObject* container = this->containerCrossingFrameBoundaries(); container && !container->shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState(); container = container->containerCrossingFrameBoundaries())
-        container->setSelfMayNeedPaintInvalidation();
-}
-
-void LayoutObject::setLayoutDidGetCalledSinceLastFrame()
-{
-    m_bitfields.setLayoutDidGetCalledSinceLastFrame(true);
-
-    // Make sure our parent is marked as needing invalidation.
-    // This would be unneeded if we allowed sub-tree invalidation (akin to sub-tree layouts).
-    markContainerChainForPaintInvalidation();
+        container->m_bitfields.setChildShouldCheckForPaintInvalidation(true);
 }
 
 void LayoutObject::setShouldInvalidateSelection()
 {
     if (!canUpdateSelectionOnRootLineBoxes())
         return;
 
     m_bitfields.setShouldInvalidateSelection(true);
     markContainerChainForPaintInvalidation();
 }
@@ skipping 16 matching lines @@
         frame()->page()->animator().scheduleVisualUpdate(); // In case that this is called outside of FrameView::updateLayoutAndStyleForPainting().
         markContainerChainForPaintInvalidation();
     }
 }
 
 void LayoutObject::setMayNeedPaintInvalidation()
 {
     if (mayNeedPaintInvalidation())
         return;
     m_bitfields.setMayNeedPaintInvalidation(true);
-    // Make sure our parent is marked as needing invalidation.
     markContainerChainForPaintInvalidation();
     frame()->page()->animator().scheduleVisualUpdate(); // In case that this is called outside of FrameView::updateLayoutAndStyleForPainting().
 }
 
-void LayoutObject::clearMayNeedPaintInvalidation()
-{
-    m_bitfields.setMayNeedPaintInvalidation(false);
-}
-
-void LayoutObject::setSelfMayNeedPaintInvalidation()
-{
-    m_bitfields.setMayNeedPaintInvalidation(true);
-}
-
 void LayoutObject::clearPaintInvalidationState(const PaintInvalidationState& paintInvalidationState)
 {
     // paintInvalidationStateIsDirty should be kept in sync with the
     // booleans that are cleared below.
     ASSERT(paintInvalidationState.ancestorHadPaintInvalidationForLocationChange() || paintInvalidationStateIsDirty());
     clearShouldDoFullPaintInvalidation();
-    setNeededLayoutBecauseOfChildren(false);
-    setShouldInvalidateOverflowForPaint(false);
-    clearLayoutDidGetCalledSinceLastFrame();
-    clearMayNeedPaintInvalidation();
-    clearShouldInvalidateSelection();
+    m_bitfields.setChildShouldCheckForPaintInvalidation(false);
+    m_bitfields.setNeededLayoutBecauseOfChildren(false);
+    m_bitfields.setShouldInvalidateOverflowForPaint(false);
+    m_bitfields.setMayNeedPaintInvalidation(false);
+    m_bitfields.setShouldInvalidateSelection(false);
 }
 
 bool LayoutObject::isAllowedToModifyLayoutTreeStructure(Document& document)
 {
     return DeprecatedDisableModifyLayoutTreeStructureAsserts::canModifyLayoutTreeStateInAnyState()
         || document.lifecycle().stateAllowsLayoutTreeMutations();
 }
 
 DeprecatedDisableModifyLayoutTreeStructureAsserts::DeprecatedDisableModifyLayoutTreeStructureAsserts()
     : m_disabler(gModifyLayoutTreeStructureAnyState, true)
@@ skipping 185 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif