Put PaintInvalidatorContext on the heap, to reduce stack overflows.

third_party/WebKit/Source/core/paint/PrePaintTreeWalk.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/PrePaintTreeWalk.h"
 
 #include "core/dom/DocumentLifecycle.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutMultiColumnSpannerPlaceholder.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/graphics/paint/GeometryMapper.h"
 
 namespace blink {
 
 struct PrePaintTreeWalkContext {
   PrePaintTreeWalkContext()
       : tree_builder_context(
             WTF::WrapUnique(new PaintPropertyTreeBuilderContext)),
+        paint_invalidator_context(WTF::WrapUnique(new PaintInvalidatorContext)),
         ancestor_overflow_paint_layer(nullptr),
         ancestor_transformed_or_root_paint_layer(nullptr) {}
 
   PrePaintTreeWalkContext(const PrePaintTreeWalkContext& parent_context,
                           bool needs_tree_builder_context)
       : tree_builder_context(
             WTF::WrapUnique(needs_tree_builder_context || DCHECK_IS_ON()
                                 ? new PaintPropertyTreeBuilderContext(
                                       *parent_context.tree_builder_context)
                                 : nullptr)),
-        paint_invalidator_context(parent_context.paint_invalidator_context),
+        paint_invalidator_context(WTF::WrapUnique(new PaintInvalidatorContext(
+            *parent_context.paint_invalidator_context))),
         ancestor_overflow_paint_layer(
             parent_context.ancestor_overflow_paint_layer),
         ancestor_transformed_or_root_paint_layer(
             parent_context.ancestor_transformed_or_root_paint_layer) {
 #if DCHECK_IS_ON()
     if (needs_tree_builder_context)
       DCHECK(parent_context.tree_builder_context->is_actually_needed);
     tree_builder_context->is_actually_needed = needs_tree_builder_context;
 #endif
   }
 
   // PaintPropertyTreeBuilderContext is large and can lead to stack overflows
   // when recursion is deep so this context object is allocated on the heap.
   // See: https://crbug.com/698653.
   std::unique_ptr<PaintPropertyTreeBuilderContext> tree_builder_context;
 
-  PaintInvalidatorContext paint_invalidator_context;
+  std::unique_ptr<PaintInvalidatorContext> paint_invalidator_context;
 
   // The ancestor in the PaintLayer tree which has overflow clip, or
   // is the root layer. Note that it is tree ancestor, not containing
   // block or stacking ancestor.
   PaintLayer* ancestor_overflow_paint_layer;
 
   // The ancestor in the PaintLayer tree which has a transform or is a root
   // layer for painting (i.e. a paint invalidation container).
   PaintLayer* ancestor_transformed_or_root_paint_layer;
 };
@@ skipping 26 matching lines @@
   PrePaintTreeWalkContext context(parent_context,
                                   needs_tree_builder_context_update);
   // ancestorOverflowLayer does not cross frame boundaries.
   context.ancestor_overflow_paint_layer = nullptr;
   if (context.tree_builder_context) {
     property_tree_builder_.UpdateProperties(frame_view,
                                             *context.tree_builder_context);
   }
   paint_invalidator_.InvalidatePaint(frame_view,
                                      context.tree_builder_context.get(),
-                                     context.paint_invalidator_context);
+                                     *context.paint_invalidator_context);
 
   if (LayoutView* view = frame_view.GetLayoutView()) {
     Walk(*view, context);
 #if DCHECK_IS_ON()
     view->AssertSubtreeClearedPaintInvalidationFlags();
 #endif
   }
   frame_view.ClearNeedsPaintPropertyUpdate();
 }
 
@@ skipping 41 matching lines @@
 
 void PrePaintTreeWalk::InvalidatePaintLayerOptimizationsIfNeeded(
     const LayoutObject& object,
     PrePaintTreeWalkContext& context) {
   if (!object.HasLayer())
     return;
 
   PaintLayer& paint_layer = *ToLayoutBoxModelObject(object).Layer();
   if (object.StyleRef().HasTransform() ||
       &object ==
-          context.paint_invalidator_context.paint_invalidation_container) {
+          context.paint_invalidator_context->paint_invalidation_container) {
     context.ancestor_transformed_or_root_paint_layer = &paint_layer;
   }
 
   // This code below checks whether any clips have changed that might:
   // (a) invalidate optimizations made for a PaintLayer that supports
   //     subsequence caching, or
   // (b) impact clipping of descendant visual rects.
   if (!paint_layer.SupportsSubsequenceCaching() &&
       !paint_layer.GetLayoutObject().HasClipRelatedProperty())
     return;
 
   FragmentData* fragment_data =
       &object.GetMutableForPainting().EnsureFirstFragment();
   for (auto& fragment : context.tree_builder_context->fragments) {
     DCHECK(fragment_data);
     if (InvalidatePaintLayerOptimizationsForFragment(
             object, context.ancestor_transformed_or_root_paint_layer, fragment,
             *fragment_data)) {
-      context.paint_invalidator_context.forced_subtree_invalidation_flags |=
+      context.paint_invalidator_context->forced_subtree_invalidation_flags |=
           PaintInvalidatorContext::kForcedSubtreeVisualRectUpdate;
     }
     fragment_data = fragment_data->NextFragment();
   }
 }
 
 bool PrePaintTreeWalk::InvalidatePaintLayerOptimizationsForFragment(
     const LayoutObject& object,
     const PaintLayer* ancestor_transformed_or_root_paint_layer,
     const PaintPropertyTreeBuilderFragmentContext& context,
@@ skipping 86 matching lines @@
 
 bool PrePaintTreeWalk::NeedsTreeBuilderContextUpdate(
     const LayoutObject& object,
     const PrePaintTreeWalkContext& parent_context) {
   return object.NeedsPaintPropertyUpdate() ||
          object.DescendantNeedsPaintPropertyUpdate() ||
          (parent_context.tree_builder_context &&
           parent_context.tree_builder_context->force_subtree_update) ||
          // If the object needs visual rect update, we should update tree
          // builder context which is needed by visual rect update.
-         parent_context.paint_invalidator_context.NeedsVisualRectUpdate(object);
+         parent_context.paint_invalidator_context->NeedsVisualRectUpdate(
+             object);
 }
 
 void PrePaintTreeWalk::ClearPreviousClipRectsForTesting(
     const LayoutObject& object) {
   object.GetMutableForPainting().FirstFragment()->ClearPreviousClipRects();
 }
 
 void PrePaintTreeWalk::Walk(const LayoutObject& object,
                             const PrePaintTreeWalkContext& parent_context) {
   // Early out from the tree walk if possible.
@@ skipping 10 matching lines @@
   // some of the state computed here.
   UpdateAuxiliaryObjectProperties(object, context);
 
   if (context.tree_builder_context) {
     DCHECK(context.tree_builder_context);
     property_tree_builder_.UpdatePropertiesForSelf(
         object, *context.tree_builder_context);
   }
 
   paint_invalidator_.InvalidatePaint(object, context.tree_builder_context.get(),
-                                     context.paint_invalidator_context);
+                                     *context.paint_invalidator_context);
 
   if (context.tree_builder_context) {
     property_tree_builder_.UpdatePropertiesForChildren(
         object, *context.tree_builder_context);
     InvalidatePaintLayerOptimizationsIfNeeded(object, context);
   }
 
   for (const LayoutObject* child = object.SlowFirstChild(); child;
        child = child->NextSibling()) {
     if (child->IsLayoutMultiColumnSpannerPlaceholder()) {
@@ skipping 17 matching lines @@
       }
       Walk(*frame_view, context);
     }
     // TODO(pdr): Investigate RemoteFrameView (crbug.com/579281).
   }
 
   object.GetMutableForPainting().ClearPaintFlags();
 }
 
 }  // namespace blink