Tweak PaintInvalidationReasons

third_party/WebKit/Source/core/paint/BoxPaintInvalidator.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/BoxPaintInvalidator.h"
 
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/paint/ObjectPaintInvalidator.h"
@@ skipping 38 matching lines @@
   return LayoutRect();
 }
 
 bool BoxPaintInvalidator::IncrementallyInvalidatePaint(
     PaintInvalidationReason reason,
     const LayoutRect& old_rect,
     const LayoutRect& new_rect) {
   DCHECK(old_rect.Location() == new_rect.Location());
   LayoutRect right_delta = ComputeRightDelta(
       new_rect.Location(), old_rect.Size(), new_rect.Size(),
-      reason == kPaintInvalidationIncremental ? box_.BorderRight()
-                                              : LayoutUnit());
+      reason == PaintInvalidationReason::kIncremental ? box_.BorderRight()
+                                                      : LayoutUnit());
   LayoutRect bottom_delta = ComputeBottomDelta(
       new_rect.Location(), old_rect.Size(), new_rect.Size(),
-      reason == kPaintInvalidationIncremental ? box_.BorderBottom()
-                                              : LayoutUnit());
+      reason == PaintInvalidationReason::kIncremental ? box_.BorderBottom()
+                                                      : LayoutUnit());
 
   if (right_delta.IsEmpty() && bottom_delta.IsEmpty())
     return false;
 
   ObjectPaintInvalidatorWithContext object_paint_invalidator(box_, context_);
   object_paint_invalidator.InvalidatePaintRectangleWithContext(right_delta,
                                                                reason);
   object_paint_invalidator.InvalidatePaintRectangleWithContext(bottom_delta,
                                                                reason);
   return true;
 }
 
 PaintInvalidationReason BoxPaintInvalidator::ComputePaintInvalidationReason() {
   PaintInvalidationReason reason =
       ObjectPaintInvalidatorWithContext(box_, context_)
           .ComputePaintInvalidationReason();
 
-  if (reason != kPaintInvalidationIncremental)
+  if (reason != PaintInvalidationReason::kIncremental)
     return reason;
 
   if (box_.IsLayoutView()) {
     const LayoutView& layout_view = ToLayoutView(box_);
     // In normal compositing mode, root background doesn't need to be
     // invalidated for box changes, because the background always covers the
     // whole document rect and clipping is done by
     // compositor()->m_containerLayer. Also the scrollbars are always
     // composited. There are no other box decoration on the LayoutView thus we
     // can safely exit here.
     if (layout_view.UsesCompositing() &&
         !RuntimeEnabledFeatures::rootLayerScrollingEnabled())
       return reason;
   }
 
   const ComputedStyle& style = box_.StyleRef();
 
   if ((style.BackgroundLayers().ThisOrNextLayersUseContentBox() ||
        style.MaskLayers().ThisOrNextLayersUseContentBox()) &&
       box_.PreviousContentBoxSize() != box_.ContentBoxRect().Size())
-    return kPaintInvalidationContentBoxChange;
+    return PaintInvalidationReason::kGeometry;
 
   LayoutSize old_border_box_size = box_.PreviousSize();
   LayoutSize new_border_box_size = box_.Size();
   bool border_box_changed = old_border_box_size != new_border_box_size;
   if (!border_box_changed && context_.old_visual_rect == box_.VisualRect())
-    return kPaintInvalidationNone;
+    return PaintInvalidationReason::kNone;
 
   // If either border box changed or bounds changed, and old or new border box
   // doesn't equal old or new bounds, incremental invalidation is not
   // applicable. This captures the following cases:
   // - pixel snapping of paint invalidation bounds,
   // - scale, rotate, skew etc. transforms,
   // - visual overflows.
   if (context_.old_visual_rect !=
           LayoutRect(context_.old_location, old_border_box_size) ||
       box_.VisualRect() !=
           LayoutRect(context_.new_location, new_border_box_size)) {
-    return border_box_changed ? kPaintInvalidationBorderBoxChange
-                              : kPaintInvalidationBoundsChange;
+    return PaintInvalidationReason::kGeometry;
   }
 
   DCHECK(border_box_changed);
 
   if (style.HasVisualOverflowingEffect() || style.HasAppearance() ||
       style.HasFilterInducingProperty() || style.HasMask())
-    return kPaintInvalidationBorderBoxChange;
+    return PaintInvalidationReason::kGeometry;
 
   if (style.HasBorderRadius())
-    return kPaintInvalidationBorderBoxChange;
+    return PaintInvalidationReason::kGeometry;
 
   if (old_border_box_size.Width() != new_border_box_size.Width() &&
       box_.MustInvalidateBackgroundOrBorderPaintOnWidthChange())
-    return kPaintInvalidationBorderBoxChange;
+    return PaintInvalidationReason::kGeometry;
   if (old_border_box_size.Height() != new_border_box_size.Height() &&
       box_.MustInvalidateBackgroundOrBorderPaintOnHeightChange())
-    return kPaintInvalidationBorderBoxChange;
+    return PaintInvalidationReason::kGeometry;
 
   // Needs to repaint frame boundaries.
   if (box_.IsFrameSet())
-    return kPaintInvalidationBorderBoxChange;
+    return PaintInvalidationReason::kGeometry;
 
   // Needs to repaint column rules.
   if (box_.IsLayoutMultiColumnSet())
-    return kPaintInvalidationBorderBoxChange;
+    return PaintInvalidationReason::kGeometry;
 
-  return kPaintInvalidationIncremental;
+  return PaintInvalidationReason::kIncremental;
 }
 
 bool BoxPaintInvalidator::BackgroundGeometryDependsOnLayoutOverflowRect() {
   return !box_.IsDocumentElement() && !box_.BackgroundStolenForBeingBody() &&
          box_.StyleRef()
              .BackgroundLayers()
              .ThisOrNextLayersHaveLocalAttachment();
 }
 
 // Background positioning in layout overflow rect doesn't mean it will
@@ skipping 52 matching lines @@
     // Check change of layout overflow for full or incremental invalidation.
     if (new_layout_overflow == old_layout_overflow)
       return;
     bool should_fully_invalidate =
         ShouldFullyInvalidateBackgroundOnLayoutOverflowChange(
             old_layout_overflow, new_layout_overflow);
     if (!paints_onto_scrolling_contents_layer) {
       if (should_fully_invalidate) {
         box_.GetMutableForPainting()
             .SetShouldDoFullPaintInvalidationWithoutGeometryChange(
-                kPaintInvalidationLayoutOverflowBoxChange);
+                PaintInvalidationReason::kBackground);
       }
       return;
     }
     should_fully_invalidate_on_scrolling_contents_layer =
         should_fully_invalidate;
   }
 
   if (should_fully_invalidate_on_scrolling_contents_layer) {
     ObjectPaintInvalidatorWithContext(box_, context_)
         .FullyInvalidatePaint(
-            kPaintInvalidationBackgroundOnScrollingContentsLayer,
+            PaintInvalidationReason::kBackgroundOnScrollingContentsLayer,
             old_layout_overflow, new_layout_overflow);
   } else {
     IncrementallyInvalidatePaint(
-        kPaintInvalidationBackgroundOnScrollingContentsLayer,
+        PaintInvalidationReason::kBackgroundOnScrollingContentsLayer,
         old_layout_overflow, new_layout_overflow);
   }
 
   context_.painting_layer->SetNeedsRepaint();
   // Currently we use CompositedLayerMapping as the DisplayItemClient to paint
   // background on the scrolling contents layer.
   ObjectPaintInvalidator(box_).InvalidateDisplayItemClient(
       *box_.Layer()->GetCompositedLayerMapping()->ScrollingContentsLayer(),
-      kPaintInvalidationBackgroundOnScrollingContentsLayer);
+      PaintInvalidationReason::kBackgroundOnScrollingContentsLayer);
 }
 
 PaintInvalidationReason BoxPaintInvalidator::InvalidatePaint() {
   InvalidateScrollingContentsBackgroundIfNeeded();
 
   PaintInvalidationReason reason = ComputePaintInvalidationReason();
-  if (reason == kPaintInvalidationIncremental) {
+  if (reason == PaintInvalidationReason::kIncremental) {
     bool invalidated;
     if (box_.IsLayoutView() &&
         !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       invalidated = IncrementallyInvalidatePaint(
           reason, context_.old_visual_rect, box_.VisualRect());
     } else {
       invalidated = IncrementallyInvalidatePaint(
           reason, LayoutRect(context_.old_location, box_.PreviousSize()),
           LayoutRect(context_.new_location, box_.Size()));
     }
     if (invalidated) {
       context_.painting_layer->SetNeedsRepaint();
       box_.InvalidateDisplayItemClients(reason);
     } else {
-      reason = kPaintInvalidationNone;
+      reason = PaintInvalidationReason::kNone;
     }
 
     // Though we have done incremental invalidation, we still need to call
     // ObjectPaintInvalidator with PaintInvalidationNone to do any other
     // required operations.
-    reason = std::max(
-        reason, ObjectPaintInvalidatorWithContext(box_, context_)
-                    .InvalidatePaintWithComputedReason(kPaintInvalidationNone));
+    reason = std::max(reason, ObjectPaintInvalidatorWithContext(box_, context_)
+                                  .InvalidatePaintWithComputedReason(
+                                      PaintInvalidationReason::kNone));
   } else {
     reason = ObjectPaintInvalidatorWithContext(box_, context_)
                  .InvalidatePaintWithComputedReason(reason);
   }
 
   if (PaintLayerScrollableArea* area = box_.GetScrollableArea())
     area->InvalidatePaintOfScrollControlsIfNeeded(context_);
 
   // This is for the next invalidatePaintIfNeeded so must be at the end.
   SavePreviousBoxGeometriesIfNeeded();
@@ skipping 33 matching lines @@
   if (NeedsToSavePreviousContentBoxSizeOrLayoutOverflowRect()) {
     box_.GetMutableForPainting()
         .SavePreviousContentBoxSizeAndLayoutOverflowRect();
   } else {
     box_.GetMutableForPainting()
         .ClearPreviousContentBoxSizeAndLayoutOverflowRect();
   }
 }
 
 }  // namespace blink