Tweak PaintInvalidationReasons

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

 // Copyright 2015 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/PaintInvalidationCapableScrollableArea.h"
 
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutScrollbar.h"
 #include "core/layout/LayoutScrollbarPart.h"
 #include "core/layout/PaintInvalidationState.h"
 #include "core/paint/FindPaintOffsetAndVisualRectNeedingUpdate.h"
 #include "core/paint/ObjectPaintInvalidator.h"
 #include "core/paint/PaintInvalidator.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/graphics/GraphicsLayer.h"
 
 namespace blink {
 
 void PaintInvalidationCapableScrollableArea::WillRemoveScrollbar(
     Scrollbar& scrollbar,
     ScrollbarOrientation orientation) {
   if (!scrollbar.IsCustomScrollbar() &&
       !(orientation == kHorizontalScrollbar ? LayerForHorizontalScrollbar()
-                                            : LayerForVerticalScrollbar()))
+                                            : LayerForVerticalScrollbar())) {
     ObjectPaintInvalidator(*GetLayoutBox())
         .SlowSetPaintingLayerNeedsRepaintAndInvalidateDisplayItemClient(
-            scrollbar, kPaintInvalidationScroll);
+            scrollbar, PaintInvalidationReason::kScrollControl);
+  }
 
   ScrollableArea::WillRemoveScrollbar(scrollbar, orientation);
 }
 
 static LayoutRect ScrollControlVisualRect(
     const IntRect& scroll_control_rect,
     const LayoutBox& box,
     const PaintInvalidatorContext& context,
     const LayoutRect& previous_visual_rect) {
   LayoutRect visual_rect(scroll_control_rect);
@@ skipping 22 matching lines @@
 static bool InvalidatePaintOfScrollControlIfNeeded(
     const LayoutRect& new_visual_rect,
     const LayoutRect& previous_visual_rect,
     bool needs_paint_invalidation,
     LayoutBox& box,
     const LayoutBoxModelObject& paint_invalidation_container) {
   bool should_invalidate_new_rect = needs_paint_invalidation;
   if (new_visual_rect != previous_visual_rect) {
     ObjectPaintInvalidator(box).InvalidatePaintUsingContainer(
         paint_invalidation_container, previous_visual_rect,
-        kPaintInvalidationScroll);
+        PaintInvalidationReason::kScrollControl);
     should_invalidate_new_rect = true;
   }
   if (should_invalidate_new_rect) {
     ObjectPaintInvalidator(box).InvalidatePaintUsingContainer(
         paint_invalidation_container, new_visual_rect,
-        kPaintInvalidationScroll);
+        PaintInvalidationReason::kScrollControl);
     return true;
   }
   return false;
 }
 
 static LayoutRect InvalidatePaintOfScrollbarIfNeeded(
     Scrollbar* scrollbar,
     GraphicsLayer* graphics_layer,
     bool& previously_was_overlay,
     const LayoutRect& previous_visual_rect,
@@ skipping 35 matching lines @@
       *context.paint_invalidation_container;
   LayoutSize new_scrollbar_used_space_in_box;
   if (!is_overlay)
     new_scrollbar_used_space_in_box = new_visual_rect.Size();
   LayoutSize previous_scrollbar_used_space_in_box;
   if (!previously_was_overlay)
     previous_scrollbar_used_space_in_box = previous_visual_rect.Size();
   if (new_scrollbar_used_space_in_box != previous_scrollbar_used_space_in_box) {
     context.painting_layer->SetNeedsRepaint();
     ObjectPaintInvalidator(box).InvalidateDisplayItemClient(
-        box, kPaintInvalidationScroll);
+        box, PaintInvalidationReason::kGeometry);
   }
 
   bool invalidated = InvalidatePaintOfScrollControlIfNeeded(
       new_visual_rect, previous_visual_rect, needs_paint_invalidation, box,
       paint_invalidation_container);
 
   previously_was_overlay = is_overlay;
 
   if (!invalidated || !scrollbar || graphics_layer)
     return new_visual_rect;
 
   context.painting_layer->SetNeedsRepaint();
   ObjectPaintInvalidator(box).InvalidateDisplayItemClient(
-      *scrollbar, kPaintInvalidationScroll);
+      *scrollbar, PaintInvalidationReason::kScrollControl);
   if (scrollbar->IsCustomScrollbar()) {
     ToLayoutScrollbar(scrollbar)
         ->InvalidateDisplayItemClientsOfScrollbarParts();
   }
 
   return new_visual_rect;
 }
 
 void PaintInvalidationCapableScrollableArea::
     InvalidatePaintOfScrollControlsIfNeeded(
@@ skipping 17 matching lines @@
       *context.paint_invalidation_container;
   if (InvalidatePaintOfScrollControlIfNeeded(
           scroll_corner_and_resizer_visual_rect,
           scroll_corner_and_resizer_visual_rect_,
           ScrollCornerNeedsPaintInvalidation(), box,
           paint_invalidation_container)) {
     SetScrollCornerAndResizerVisualRect(scroll_corner_and_resizer_visual_rect);
     if (LayoutScrollbarPart* scroll_corner = this->ScrollCorner()) {
       ObjectPaintInvalidator(*scroll_corner)
           .InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-              kPaintInvalidationScroll);
+              PaintInvalidationReason::kScrollControl);
     }
     if (LayoutScrollbarPart* resizer = this->Resizer()) {
       ObjectPaintInvalidator(*resizer)
           .InvalidateDisplayItemClientsIncludingNonCompositingDescendants(
-              kPaintInvalidationScroll);
+              PaintInvalidationReason::kScrollControl);
     }
   }
 
   ClearNeedsPaintInvalidationForScrollControls();
 }
 
 void PaintInvalidationCapableScrollableArea::
     InvalidatePaintOfScrollControlsIfNeeded(
         const PaintInvalidationState& paint_invalidation_state) {
   InvalidatePaintOfScrollControlsIfNeeded(
@@ skipping 62 matching lines @@
                : UseCounter::kScrollbarUseHorizontalScrollbarTrack);
       break;
     default:
       return;
   }
 
   UseCounter::Count(GetLayoutBox()->GetDocument(), scrollbar_use_uma);
 }
 
 }  // namespace blink