Tweak PaintInvalidationReasons

third_party/WebKit/Source/core/paint/ObjectPaintInvalidator.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/ObjectPaintInvalidator.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutPartItem.h"
@@ skipping 196 matching lines @@
     InvalidatePaintIncludingNonCompositingDescendants() {
   // Since we're only painting non-composited layers, we know that they all
   // share the same paintInvalidationContainer.
   const LayoutBoxModelObject& paint_invalidation_container =
       object_.ContainerForPaintInvalidation();
   SlowSetPaintingLayerNeedsRepaint();
   TraverseNonCompositingDescendantsInPaintOrder(
       object_, [&paint_invalidation_container](const LayoutObject& object) {
         SetPaintingLayerNeedsRepaintDuringTraverse(object);
         ObjectPaintInvalidator(object).InvalidatePaintOfPreviousVisualRect(
-            paint_invalidation_container, kPaintInvalidationSubtree);
+            paint_invalidation_container, PaintInvalidationReason::kSubtree);
       });
 }
 
 void ObjectPaintInvalidator::
     InvalidatePaintIncludingNonSelfPaintingLayerDescendantsInternal(
         const LayoutBoxModelObject& paint_invalidation_container) {
   InvalidatePaintOfPreviousVisualRect(paint_invalidation_container,
-                                      kPaintInvalidationSubtree);
+                                      PaintInvalidationReason::kSubtree);
   for (LayoutObject* child = object_.SlowFirstChild(); child;
        child = child->NextSibling()) {
     if (!child->HasLayer() ||
         !ToLayoutBoxModelObject(child)->Layer()->IsSelfPaintingLayer())
       ObjectPaintInvalidator(*child)
           .InvalidatePaintIncludingNonSelfPaintingLayerDescendantsInternal(
               paint_invalidation_container);
   }
 }
 
@@ skipping 81 matching lines @@
       // here. It is already taken into account.
       squashing_layer->SetNeedsDisplayInRect(EnclosingIntRect(rect), reason,
                                              object_);
     }
   } else if (object_.CompositedScrollsWithRespectTo(
                  paint_invalidation_container)) {
     layer.GetCompositedLayerMapping()->SetScrollingContentsNeedDisplayInRect(
         rect, reason, object_);
   } else if (paint_invalidation_container.UsesCompositedScrolling()) {
     DCHECK(object_ == paint_invalidation_container);
-    if (reason == kPaintInvalidationBackgroundOnScrollingContentsLayer ||
-        reason == kPaintInvalidationCaret) {
+    if (reason ==
+            PaintInvalidationReason::kBackgroundOnScrollingContentsLayer ||
+        reason == PaintInvalidationReason::kCaret) {
       layer.GetCompositedLayerMapping()->SetScrollingContentsNeedDisplayInRect(
           rect, reason, object_);
     } else {
       layer.GetCompositedLayerMapping()
           ->SetNonScrollingContentsNeedDisplayInRect(rect, reason, object_);
     }
   } else {
     // Otherwise invalidate everything.
     layer.GetCompositedLayerMapping()->SetContentsNeedDisplayInRect(
         rect, reason, object_);
@@ skipping 66 matching lines @@
 
   const LayoutBoxModelObject& paint_invalidation_container =
       object_.ContainerForPaintInvalidation();
   LayoutRect dirty_rect_on_backing = dirty_rect;
   PaintLayer::MapRectToPaintInvalidationBacking(
       object_, paint_invalidation_container, dirty_rect_on_backing);
   dirty_rect_on_backing.Move(object_.ScrollAdjustmentForPaintInvalidation(
       paint_invalidation_container));
   InvalidatePaintUsingContainer(paint_invalidation_container,
                                 dirty_rect_on_backing,
-                                kPaintInvalidationRectangle);
+                                PaintInvalidationReason::kRectangle);
 
   SlowSetPaintingLayerNeedsRepaint();
-  if (display_item_client)
+  if (display_item_client) {
     InvalidateDisplayItemClient(*display_item_client,
-                                kPaintInvalidationRectangle);
-  else
-    object_.InvalidateDisplayItemClients(kPaintInvalidationRectangle);
+                                PaintInvalidationReason::kRectangle);
+  } else {
+    object_.InvalidateDisplayItemClients(PaintInvalidationReason::kRectangle);
+  }
 
   return dirty_rect_on_backing;
 }
 
 void ObjectPaintInvalidator::SlowSetPaintingLayerNeedsRepaint() {
   if (PaintLayer* painting_layer = object_.PaintingLayer())
     painting_layer->SetNeedsRepaint();
 }
 
 LayoutPoint ObjectPaintInvalidator::LocationInBacking() const {
@@ skipping 87 matching lines @@
   bool background_obscuration_changed = false;
   bool background_obscured = object_.BackgroundIsKnownToBeObscured();
   if (background_obscured != object_.PreviousBackgroundObscured()) {
     object_.GetMutableForPainting().SetPreviousBackgroundObscured(
         background_obscured);
     background_obscuration_changed = true;
   }
 
   if (context_.forced_subtree_invalidation_flags &
       PaintInvalidatorContext::kForcedSubtreeFullInvalidation)
-    return kPaintInvalidationSubtree;
+    return PaintInvalidationReason::kSubtree;
 
   if (object_.ShouldDoFullPaintInvalidation())
     return object_.FullPaintInvalidationReason();
 
   if (context_.old_visual_rect.IsEmpty() && object_.VisualRect().IsEmpty())
-    return kPaintInvalidationNone;
+    return PaintInvalidationReason::kNone;
 
   if (background_obscuration_changed)
-    return kPaintInvalidationBackgroundObscurationChange;
+    return PaintInvalidationReason::kBackground;
 
   if (object_.PaintedOutputOfObjectHasNoEffectRegardlessOfSize())
-    return kPaintInvalidationNone;
+    return PaintInvalidationReason::kNone;
 
   // Force full paint invalidation if the outline may be affected by descendants
   // and this object is marked for checking paint invalidation for any reason.
   if (object_.OutlineMayBeAffectedByDescendants() ||
       object_.PreviousOutlineMayBeAffectedByDescendants()) {
     object_.GetMutableForPainting()
         .UpdatePreviousOutlineMayBeAffectedByDescendants();
-    return kPaintInvalidationOutline;
+    return PaintInvalidationReason::kOutline;
   }
 
   // If the size is zero on one of our bounds then we know we're going to have
   // to do a full invalidation of either old bounds or new bounds.
   if (context_.old_visual_rect.IsEmpty())
-    return kPaintInvalidationBecameVisible;
+    return PaintInvalidationReason::kAppeared;
   if (object_.VisualRect().IsEmpty())
-    return kPaintInvalidationBecameInvisible;
+    return PaintInvalidationReason::kDisappeared;
 
   // If we shifted, we don't know the exact reason so we are conservative and
   // trigger a full invalidation. Shifting could be caused by some layout
   // property (left / top) or some in-flow layoutObject inserted / removed
   // before us in the tree.
   if (object_.VisualRect().Location() != context_.old_visual_rect.Location())
-    return kPaintInvalidationBoundsChange;
+    return PaintInvalidationReason::kGeometry;
 
   if (context_.new_location != context_.old_location)
-    return kPaintInvalidationLocationChange;
+    return PaintInvalidationReason::kGeometry;
 
   // Incremental invalidation is only applicable to LayoutBoxes. Return
   // PaintInvalidationIncremental no matter if oldVisualRect and newVisualRect
   // are equal because a LayoutBox may need paint invalidation if its border box
   // changes. BoxPaintInvalidator may also override this reason with a full
   // paint invalidation reason if needed.
   if (object_.IsBox())
-    return kPaintInvalidationIncremental;
+    return PaintInvalidationReason::kIncremental;
 
   if (context_.old_visual_rect != object_.VisualRect())
-    return kPaintInvalidationBoundsChange;
+    return PaintInvalidationReason::kGeometry;
 
-  return kPaintInvalidationNone;
+  return PaintInvalidationReason::kNone;
 }
 
 DISABLE_CFI_PERF
 void ObjectPaintInvalidatorWithContext::InvalidateSelectionIfNeeded(
     PaintInvalidationReason reason) {
   // Update selection rect when we are doing full invalidation with geometry
   // change (in case that the object is moved, composite status changed, etc.)
   // or shouldInvalidationSelection is set (in case that the selection itself
   // changed).
   bool full_invalidation = IsImmediateFullPaintInvalidationReason(reason);
@@ skipping 14 matching lines @@
   if (context_.NeedsVisualRectUpdate(object_)) {
     new_selection_rect = object_.LocalSelectionRect();
     context_.MapLocalRectToVisualRectInBacking(object_, new_selection_rect);
   } else {
     new_selection_rect = old_selection_rect;
   }
 
   SetSelectionVisualRect(object_, new_selection_rect);
 
   if (!full_invalidation) {
-    FullyInvalidatePaint(kPaintInvalidationSelection, old_selection_rect,
-                         new_selection_rect);
+    FullyInvalidatePaint(PaintInvalidationReason::kSelection,
+                         old_selection_rect, new_selection_rect);
     context_.painting_layer->SetNeedsRepaint();
-    object_.InvalidateDisplayItemClients(kPaintInvalidationSelection);
+    object_.InvalidateDisplayItemClients(PaintInvalidationReason::kSelection);
   }
 }
 
 DISABLE_CFI_PERF
 PaintInvalidationReason
 ObjectPaintInvalidatorWithContext::InvalidatePaintWithComputedReason(
     PaintInvalidationReason reason) {
   // We need to invalidate the selection before checking for whether we are
   // doing a full invalidation.  This is because we need to update the previous
   // selection rect regardless.
   InvalidateSelectionIfNeeded(reason);
 
   switch (reason) {
-    case kPaintInvalidationNone:
+    case PaintInvalidationReason::kNone:
       // There are corner cases that the display items need to be invalidated
       // for paint offset mutation, but incurs no pixel difference (i.e. bounds
       // stay the same) so no rect-based invalidation is issued. See
       // crbug.com/508383 and crbug.com/515977.
       if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
           (context_.forced_subtree_invalidation_flags &
            PaintInvalidatorContext::kForcedSubtreeInvalidationChecking) &&
           !object_.IsSVGChild()) {
         // For SPv1, we conservatively assume the object changed paint offset
         // except for non-root SVG whose paint offset is always zero.
-        reason = kPaintInvalidationLocationChange;
+        reason = PaintInvalidationReason::kGeometry;
         break;
       }
 
       if (object_.IsSVG() &&
           (context_.forced_subtree_invalidation_flags &
            PaintInvalidatorContext::kForcedSubtreeSVGResourceChange)) {
-        reason = kPaintInvalidationSVGResourceChange;
+        reason = PaintInvalidationReason::kSVGResource;
         break;
       }
-      return kPaintInvalidationNone;
-    case kPaintInvalidationDelayedFull:
-      return kPaintInvalidationDelayedFull;
+      return PaintInvalidationReason::kNone;
+    case PaintInvalidationReason::kDelayedFull:
+      return PaintInvalidationReason::kDelayedFull;
     default:
       DCHECK(IsImmediateFullPaintInvalidationReason(reason));
       // This allows descendants to know the computed reason if it's different
       // from the original reason before paint invalidation.
       object_.GetMutableForPainting()
           .SetShouldDoFullPaintInvalidationWithoutGeometryChange(reason);
       FullyInvalidatePaint(reason, context_.old_visual_rect,
                            object_.VisualRect());
   }
 
   context_.painting_layer->SetNeedsRepaint();
   object_.InvalidateDisplayItemClients(reason);
   return reason;
 }
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : disabler_(&g_disable_paint_invalidation_state_asserts, true) {}
 
 }  // namespace blink