[SPv2] Fix layout test crashes about raster invalidation

third_party/WebKit/Source/platform/graphics/paint/PaintController.cpp

 // Copyright 2014 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 "platform/graphics/paint/PaintController.h"
 
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/wtf/AutoReset.h"
 #include "platform/wtf/text/StringBuilder.h"
 #include "third_party/skia/include/core/SkPictureAnalyzer.h"
 
 #ifndef NDEBUG
 #include "platform/graphics/LoggingCanvas.h"
 #include <stdio.h>
 #endif
 
 static constexpr int kMaxNumberOfSlowPathsBeforeVeto = 5;
 
 namespace blink {
 
 void PaintController::SetTracksRasterInvalidations(bool value) {
-  if (value) {
-    paint_chunks_raster_invalidation_tracking_map_ =
+  if (value ||
+      RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
+    raster_invalidation_tracking_map_ =
         WTF::WrapUnique(new RasterInvalidationTrackingMap<const PaintChunk>);
-  } else {
-    paint_chunks_raster_invalidation_tracking_map_ = nullptr;
+    return;
   }
+  raster_invalidation_tracking_map_ = nullptr;
 }
 
 const PaintArtifact& PaintController::GetPaintArtifact() const {
   DCHECK(new_display_item_list_.IsEmpty());
   DCHECK(new_paint_chunks_.IsInInitialState());
   return current_paint_artifact_;
 }
 
 bool PaintController::UseCachedDrawingIfPossible(
     const DisplayItemClient& client,
@@ skipping 550 matching lines @@
         break;
       }
     }
   }
 
   for (auto* client : skipped_cache_clients)
     client->SetDisplayItemsUncached();
 
   // The new list will not be appended to again so we can release unused memory.
   new_display_item_list_.ShrinkToFit();
+
+  if (raster_invalidation_tracking_map_) {
+    for (const auto& chunk : current_paint_artifact_.PaintChunks())
+      raster_invalidation_tracking_map_->Remove(&chunk);
+  }
   current_paint_artifact_ = PaintArtifact(
       std::move(new_display_item_list_), new_paint_chunks_.ReleasePaintChunks(),
       num_slow_paths <= kMaxNumberOfSlowPathsBeforeVeto);
+
   ResetCurrentListIndices();
   out_of_order_item_indices_.clear();
   out_of_order_chunk_indices_.clear();
   items_moved_into_new_list_.clear();
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     for (const auto& chunk : current_paint_artifact_.PaintChunks()) {
       if (chunk.id && chunk.id->client.IsJustCreated())
         chunk.id->client.ClearIsJustCreated();
     }
@@ skipping 56 matching lines @@
 
 void PaintController::GenerateChunkRasterInvalidationRects(
     PaintChunk& new_chunk) {
   DCHECK(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
   if (new_chunk.begin_index >=
       current_cached_subsequence_begin_index_in_new_list_)
     return;
 
   static FloatRect infinite_float_rect(LayoutRect::InfiniteIntRect());
   if (!new_chunk.id) {
-    AddRasterInvalidationInfo(nullptr, new_chunk, infinite_float_rect);
+    AddRasterInvalidation(nullptr, new_chunk, infinite_float_rect);
     return;
   }
 
   // Try to match old chunk sequentially first.
   const auto& old_chunks = current_paint_artifact_.PaintChunks();
   while (next_chunk_to_match_ < old_chunks.size()) {
     const PaintChunk& old_chunk = old_chunks[next_chunk_to_match_];
     if (new_chunk.Matches(old_chunk)) {
       GenerateChunkRasterInvalidationRectsComparingOldChunk(new_chunk,
                                                             old_chunk);
@@ skipping 21 matching lines @@
     for (size_t i : it->value) {
       if (new_chunk.Matches(old_chunks[i])) {
         GenerateChunkRasterInvalidationRectsComparingOldChunk(new_chunk,
                                                               old_chunks[i]);
         return;
       }
     }
   }
 
   // We reach here because the chunk is new.
-  AddRasterInvalidationInfo(nullptr, new_chunk, infinite_float_rect);
+  AddRasterInvalidation(nullptr, new_chunk, infinite_float_rect);
 }
 
-void PaintController::AddRasterInvalidationInfo(const DisplayItemClient* client,
-                                                PaintChunk& chunk,
-                                                const FloatRect& rect) {
+void PaintController::AddRasterInvalidation(const DisplayItemClient* client,
+                                            PaintChunk& chunk,
+                                            const FloatRect& rect) {
   chunk.raster_invalidation_rects.push_back(rect);
-  if (!paint_chunks_raster_invalidation_tracking_map_)
+  if (!raster_invalidation_tracking_map_)
     return;
   RasterInvalidationInfo info;
   info.rect = EnclosingIntRect(rect);
   info.client = client;
   if (client) {
     info.client_debug_name = client->DebugName();
     info.reason = client->GetPaintInvalidationReason();
   }
-  RasterInvalidationTracking& tracking =
-      paint_chunks_raster_invalidation_tracking_map_->Add(&chunk);
-  tracking.tracked_raster_invalidations.push_back(info);
+  raster_invalidation_tracking_map_->AddInvalidation(&chunk, info);
 }
 
 void PaintController::GenerateChunkRasterInvalidationRectsComparingOldChunk(
     PaintChunk& new_chunk,
     const PaintChunk& old_chunk) {
   DCHECK(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   // TODO(wangxianzhu): Handle PaintInvalidationIncremental.
   // TODO(wangxianzhu): Optimize paint offset change.
 
+  // We may track raster invalidations across multiple paints. The new chunk
+  // should contain all previously tracked invalidations.
+  if (raster_invalidation_tracking_map_) {
+    // Add() must be before Find() otherwise Add() might invalidate the pointer
+    // returned from Find().
+    auto& new_tracking = raster_invalidation_tracking_map_->Add(&new_chunk);
+    if (auto* old_tracking =
+            raster_invalidation_tracking_map_->Find(&old_chunk)) {
+      new_tracking.tracked_invalidations.AppendVector(
+          old_tracking->tracked_invalidations);
+    }
+  }
+
   HashSet<const DisplayItemClient*> invalidated_clients_in_old_chunk;
   size_t highest_moved_to_index = 0;
   for (size_t old_index = old_chunk.begin_index;
        old_index < old_chunk.end_index; ++old_index) {
     const DisplayItem& old_item =
         current_paint_artifact_.GetDisplayItemList()[old_index];
     const DisplayItemClient* client_to_invalidate = nullptr;
     bool is_potentially_invalid_client = false;
     if (!old_item.HasValidClient()) {
       size_t moved_to_index = items_moved_into_new_list_[old_index];
       if (new_display_item_list_[moved_to_index].DrawsContent()) {
         if (moved_to_index < new_chunk.begin_index ||
             moved_to_index >= new_chunk.end_index) {
           // The item has been moved into another chunk, so need to invalidate
           // it in the old chunk.
           client_to_invalidate =
               &new_display_item_list_[moved_to_index].Client();
           // And invalidate in the new chunk into which the item was moved.
           PaintChunk& moved_to_chunk =
               new_paint_chunks_.FindChunkByDisplayItemIndex(moved_to_index);
-          AddRasterInvalidationInfo(
-              client_to_invalidate, moved_to_chunk,
-              FloatRect(client_to_invalidate->VisualRect()));
+          AddRasterInvalidation(client_to_invalidate, moved_to_chunk,
+                                FloatRect(client_to_invalidate->VisualRect()));
         } else if (moved_to_index < highest_moved_to_index) {
           // The item has been moved behind other cached items, so need to
           // invalidate the area that is probably exposed by the item moved
           // earlier.
           client_to_invalidate =
               &new_display_item_list_[moved_to_index].Client();
         } else {
           highest_moved_to_index = moved_to_index;
         }
       }
     } else if (old_item.DrawsContent()) {
       is_potentially_invalid_client = true;
       client_to_invalidate = &old_item.Client();
     }
     if (client_to_invalidate &&
         invalidated_clients_in_old_chunk.insert(client_to_invalidate)
             .is_new_entry) {
-      AddRasterInvalidationInfo(
+      AddRasterInvalidation(
           is_potentially_invalid_client ? nullptr : client_to_invalidate,
           new_chunk,
           FloatRect(current_paint_artifact_.GetDisplayItemList().VisualRect(
               old_index)));
     }
   }
 
   HashSet<const DisplayItemClient*> invalidated_clients_in_new_chunk;
   for (size_t new_index = new_chunk.begin_index;
        new_index < new_chunk.end_index; ++new_index) {
     const DisplayItem& new_item = new_display_item_list_[new_index];
     if (new_item.DrawsContent() && !ClientCacheIsValid(new_item.Client()) &&
         invalidated_clients_in_new_chunk.insert(&new_item.Client())
             .is_new_entry) {
-      AddRasterInvalidationInfo(&new_item.Client(), new_chunk,
-                                FloatRect(new_item.Client().VisualRect()));
+      AddRasterInvalidation(&new_item.Client(), new_chunk,
+                            FloatRect(new_item.Client().VisualRect()));
     }
   }
 }
 
 void PaintController::ShowUnderInvalidationError(
     const char* reason,
     const DisplayItem& new_item,
     const DisplayItem* old_item) const {
   LOG(ERROR) << under_invalidation_message_prefix_ << " " << reason;
 #ifndef NDEBUG
@@ skipping 121 matching lines @@
               show_paint_records
                   ? (DisplayItemList::JsonOptions::kShowPaintRecords |
                      DisplayItemList::JsonOptions::kShowClientDebugName)
                   : DisplayItemList::JsonOptions::kShowClientDebugName)
           ->ToPrettyJSONString()
           .Utf8()
           .data());
 }
 
 }  // namespace blink