(WIP) Paint invalidation 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 655 matching lines @@
     // See if we have the thread cached because we're in the middle of layout.
     if (LayoutState* layoutState = view()->layoutState()) {
         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);
 }
 
+// TODO: May remove this for slimming paint v2 because if the object paints
+// nothing, then repainting is fast and invalidation of it won't generate any
+// rastarization invalidation.
 bool LayoutObject::skipInvalidationWhenLaidOutChildren() const
 {
     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;
 
@@ skipping 351 matching lines @@
     RELEASE_ASSERT(isRooted());
 
     const LayoutBoxModelObject* paintInvalidationContainer = containerForPaintInvalidation();
     ASSERT(paintInvalidationContainer);
 
     return *paintInvalidationContainer;
 }
 
 const LayoutBoxModelObject* LayoutObject::enclosingCompositedContainer() const
 {
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        // Get the LayoutView of the top level frame. This is temporary before we remove blink compositing.
+        return adjustCompositedContainerForSpecialAncestors(nullptr);
+    }
+
     LayoutBoxModelObject* container = nullptr;
     // FIXME: CompositingState is not necessarily up to date for many callers of this function.
     DisableCompositingQueryAsserts disabler;
 
     if (DeprecatedPaintLayer* compositingLayer = enclosingLayer()->enclosingLayerForPaintInvalidationCrossingFrameBoundaries())
         container = compositingLayer->layoutObject();
     return container;
 }
 
 const LayoutBoxModelObject* LayoutObject::adjustCompositedContainerForSpecialAncestors(const LayoutBoxModelObject* paintInvalidationContainer) const
@@ skipping 140 matching lines @@
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
         setNeedsRepaint();
     paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*this);
 }
 
 void LayoutObject::setNeedsRepaint()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
-    ASSERT(document().lifecycle().state() <= DocumentLifecycle::InPaintInvalidation);
+    ASSERT(document().lifecycle().state() <= DocumentLifecycle::InPaintForSlimmingPaintV2);
 
     if (!selfNeedsRepaint()) {
         m_bitfields.setSelfNeedsRepaint(true);
         markStackingContextContainerChainForChildNeedsRepaint();
     }
 }
 
 void LayoutObject::setChildNeedsRepaint()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
-    ASSERT(document().lifecycle().state() <= DocumentLifecycle::InPaintInvalidation);
+    ASSERT(document().lifecycle().state() <= DocumentLifecycle::InPaintForSlimmingPaintV2);
 
     if (!childNeedsRepaint()) {
         m_bitfields.setChildNeedsRepaint(true);
         markStackingContextContainerChainForChildNeedsRepaint();
     }
 }
 
 void LayoutObject::markStackingContextContainerChainForChildNeedsRepaint()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
@@ skipping 207 matching lines @@
 
     if (invalidationReason == PaintInvalidationIncremental) {
         incrementallyInvalidatePaint(paintInvalidationContainer, oldBounds, newBounds, newLocation);
         return invalidationReason;
     }
 
     fullyInvalidatePaint(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
     return invalidationReason;
 }
 
+PaintInvalidationReason LayoutObject::invalidatePaintIfNeededForSlimmingPaintV2(const LayoutPoint& newPaintOffset)
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    if (!selfShouldCheckForPaintInvalidation())
+        return PaintInvalidationNone;
+
+    LayoutPoint oldPaintOffset = m_previousPaintOffset;
+    m_previousPaintOffset = newPaintOffset;
+
+    const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidationOnRootedTree(); // This is fast for slimming paint v2.
+    PaintInvalidationReason invalidationReason = paintInvalidationReason(paintInvalidationContainer, LayoutRect(), oldPaintOffset, LayoutRect(), newPaintOffset);
+
+    bool boxDecorationBackgroundObscured = boxDecorationBackgroundIsKnownToBeObscured();
+    if (!isFullPaintInvalidationReason(invalidationReason) && boxDecorationBackgroundObscured != m_bitfields.lastBoxDecorationBackgroundObscured())
+        invalidationReason = PaintInvalidationBackgroundObscurationChange;
+    m_bitfields.setLastBoxDecorationBackgroundObscured(boxDecorationBackgroundObscured);
+
+    TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), "LayoutObject::invalidatePaintIfNeededForSlimmingPaintV2()",
+        "object", this->debugName().ascii(),
+        // TODO: Update the function to reflect new meanings.
+        "", jsonObjectForOldAndNewRects(LayoutRect(), oldPaintOffset, LayoutRect(), newPaintOffset));
+
+    if (invalidationReason == PaintInvalidationNone)
+        return invalidationReason;
+
+    invalidateDisplayItemClients(paintInvalidationContainer);
+
+    clearSelfPaintInvalidationFlags();
+    return invalidationReason;
+}
+
 PaintInvalidationReason LayoutObject::paintInvalidationReason(const LayoutBoxModelObject& paintInvalidationContainer,
     const LayoutRect& oldBounds, const LayoutPoint& oldPositionFromPaintInvalidationBacking,
     const LayoutRect& newBounds, const LayoutPoint& newPositionFromPaintInvalidationBacking) const
 {
     // First check for InvalidationLocationChange to avoid it from being hidden by other
     // invalidation reasons because we'll need to force check for paint invalidation for
     // children when location of this object changed.
     if (newPositionFromPaintInvalidationBacking != oldPositionFromPaintInvalidationBacking)
         return PaintInvalidationLocationChange;
 
@@ skipping 1769 matching lines @@
 }
 
 inline void LayoutObject::markContainerChainForPaintInvalidation()
 {
     for (LayoutObject* container = this->containerCrossingFrameBoundaries(); container && !container->shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState(); container = container->containerCrossingFrameBoundaries())
         container->m_bitfields.setChildShouldCheckForPaintInvalidation(true);
 }
 
 void LayoutObject::setShouldInvalidateSelection()
 {
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        setShouldDoFullPaintInvalidation(PaintInvalidationSelection);
+        return;
+    }
+
     if (!canUpdateSelectionOnRootLineBoxes())
         return;
 
     m_bitfields.setShouldInvalidateSelection(true);
     markContainerChainForPaintInvalidation();
 }
 
 void LayoutObject::setShouldDoFullPaintInvalidation(PaintInvalidationReason reason)
 {
     // Only full invalidation reasons are allowed.
@@ skipping 21 matching lines @@
     m_bitfields.setMayNeedPaintInvalidation(true);
     markContainerChainForPaintInvalidation();
     frame()->page()->animator().scheduleVisualUpdate(); // In case that this is called outside of FrameView::updateLayoutAndStyleForPainting().
 }
 
 void LayoutObject::clearPaintInvalidationState(const PaintInvalidationState& paintInvalidationState)
 {
     // paintInvalidationStateIsDirty should be kept in sync with the
     // booleans that are cleared below.
     ASSERT(paintInvalidationState.ancestorHadPaintInvalidationForLocationChange() || paintInvalidationStateIsDirty());
+    m_bitfields.setChildShouldCheckForPaintInvalidation(false);
+    clearSelfPaintInvalidationFlags();
+}
+
+void LayoutObject::clearSelfPaintInvalidationFlags()
+{
     clearShouldDoFullPaintInvalidation();
-    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();
@@ skipping 189 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