[SPv2] Fix layout test crashes about raster invalidation

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.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 "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/paint/display_item_list.h"
@@ skipping 73 matching lines @@
     return 0;
   }
 
   void ResetTrackedRasterInvalidations() {
     RasterInvalidationTracking* tracking =
         CcLayersRasterInvalidationTrackingMap().Find(cc_picture_layer_.get());
     if (!tracking)
       return;
 
     if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
-      tracking->tracked_raster_invalidations.clear();
+      tracking->tracked_invalidations.clear();
     else
       CcLayersRasterInvalidationTrackingMap().Remove(cc_picture_layer_.get());
   }
 
   bool HasTrackedRasterInvalidations() const {
     RasterInvalidationTracking* tracking =
         CcLayersRasterInvalidationTrackingMap().Find(cc_picture_layer_.get());
     if (tracking)
-      return !tracking->tracked_raster_invalidations.IsEmpty();
+      return !tracking->tracked_invalidations.IsEmpty();
     return false;
   }
 
-  void SetNeedsDisplayRect(const gfx::Rect& rect,
-                           RasterInvalidationInfo* raster_invalidation_info) {
+  void SetNeedsDisplayRect(const gfx::Rect& rect) {
     cc_picture_layer_->SetNeedsDisplayRect(rect);
+  }
 
-    if (!raster_invalidation_info || rect.IsEmpty())
-      return;
-
-    RasterInvalidationTracking& tracking =
+  void AddTrackedRasterInvalidations(
+      const RasterInvalidationTracking& tracking) {
+    auto& cc_tracking =
         CcLayersRasterInvalidationTrackingMap().Add(cc_picture_layer_.get());

[chrishtr, 2017/05/10 17:25:33]

cc_picture_layer_ is persisted across frames, and already tracks raster
invalidations.
What advantage does copying it from frame to frame in PaintController do vs
storing it here?

[Xianzhu, 2017/05/10 18:27:02]

I see. That's not necessary. We can just keep incremental tracking in
PaintController and add into cc_tracking.

-
-    tracking.tracked_raster_invalidations.push_back(*raster_invalidation_info);
+    cc_tracking.tracked_invalidations.AppendVector(
+        tracking.tracked_invalidations);
 
     if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
-      // TODO(crbug.com/496260): Some antialiasing effects overflow the paint
-      // invalidation rect.
-      IntRect r = raster_invalidation_info->rect;
-      r.Inflate(1);
-      tracking.raster_invalidation_region_since_last_paint.Unite(r);
+      cc_tracking.invalidation_region_since_last_paint.Unite(
+          tracking.invalidation_region_since_last_paint);
     }
   }
 
   std::unique_ptr<JSONObject> LayerAsJSON(LayerTreeFlags flags) {
     std::unique_ptr<JSONObject> json = JSONObject::Create();
     json->SetString("name", debug_name_);
     IntSize bounds(cc_picture_layer_->bounds().width(),
                    cc_picture_layer_->bounds().height());
     if (!bounds.IsEmpty())
       json->SetArray("bounds", SizeAsJSONArray(bounds));
@@ skipping 29 matching lines @@
   gfx::Rect paintable_region_;
   Vector<std::unique_ptr<JSONArray>> paint_chunk_debug_data_;
 };
 
 PaintArtifactCompositor::PaintArtifactCompositor() {
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return;
   root_layer_ = cc::Layer::Create();
   web_layer_ = Platform::Current()->CompositorSupport()->CreateLayerFromCCLayer(
       root_layer_.get());
-  is_tracking_raster_invalidations_ = false;
 }
 
 PaintArtifactCompositor::~PaintArtifactCompositor() {}
 
-void PaintArtifactCompositor::SetTracksRasterInvalidations(
-    bool tracks_paint_invalidations) {
-  ResetTrackedRasterInvalidations();
-  is_tracking_raster_invalidations_ = tracks_paint_invalidations;
-}
-
 void PaintArtifactCompositor::ResetTrackedRasterInvalidations() {
   for (auto& client : content_layer_clients_)
     client->ResetTrackedRasterInvalidations();
 }
 
 bool PaintArtifactCompositor::HasTrackedRasterInvalidations() const {
   for (auto& client : content_layer_clients_) {
     if (client->HasTrackedRasterInvalidations())
       return true;
   }
@@ skipping 86 matching lines @@
   content_layer_client->SetPaintableRegion(
       gfx::Rect(cc_combined_bounds.size()));
 
   scoped_refptr<cc::PictureLayer> cc_picture_layer =
       content_layer_client->CcPictureLayer();
   cc_picture_layer->SetBounds(cc_combined_bounds.size());
   cc_picture_layer->SetIsDrawable(true);
   cc_picture_layer->SetContentsOpaque(pending_layer.known_to_be_opaque);
   content_layer_client->ClearPaintChunkDebugData();
 
+  // We always copy all tracked invalidations from paint_chunk to
+  // content_layer_client from scratch.
+  if (tracking_map)
+    content_layer_client->ResetTrackedRasterInvalidations();
+
   for (const auto& paint_chunk : pending_layer.paint_chunks) {
-    RasterInvalidationTracking* raster_tracking =
-        tracking_map ? tracking_map->Find(paint_chunk) : nullptr;
-    DCHECK(!raster_tracking ||
-           raster_tracking->tracked_raster_invalidations.size() ==
-               paint_chunk->raster_invalidation_rects.size());
-
     if (store_debug_info) {
       content_layer_client->AddPaintChunkDebugData(
           paint_artifact.GetDisplayItemList().SubsequenceAsJSON(
               paint_chunk->begin_index, paint_chunk->end_index,
               DisplayItemList::kSkipNonDrawings |
                   DisplayItemList::kShownOnlyDisplayItemTypes));
     }
 
-    for (unsigned index = 0;
-         index < paint_chunk->raster_invalidation_rects.size(); ++index) {
-      IntRect rect(
-          EnclosingIntRect(paint_chunk->raster_invalidation_rects[index]));
+    for (const auto& r : paint_chunk->raster_invalidation_rects) {
+      IntRect rect(EnclosingIntRect(r));
       gfx::Rect cc_invalidation_rect(rect.X(), rect.Y(),
                                      std::max(0, rect.Width()),
                                      std::max(0, rect.Height()));
       if (cc_invalidation_rect.IsEmpty())
         continue;
       // Raster paintChunk.rasterInvalidationRects is in the space of the
       // containing transform node, so need to subtract off the layer offset.
       cc_invalidation_rect.Offset(-cc_combined_bounds.OffsetFromOrigin());
-      content_layer_client->SetNeedsDisplayRect(
-          cc_invalidation_rect,
-          raster_tracking
-              ? &raster_tracking->tracked_raster_invalidations[index]
-              : nullptr);
+      content_layer_client->SetNeedsDisplayRect(cc_invalidation_rect);
     }
+
+    if (auto* raster_tracking =
+            tracking_map ? tracking_map->Find(paint_chunk) : nullptr)
+      content_layer_client->AddTrackedRasterInvalidations(*raster_tracking);
   }
 
   new_content_layer_clients.push_back(std::move(content_layer_client));
   return cc_picture_layer;
 }
 
 PaintArtifactCompositor::PendingLayer::PendingLayer(
     const PaintChunk& first_paint_chunk,
     bool chunk_is_foreign)
     : bounds(first_paint_chunk.bounds),
@@ skipping 363 matching lines @@
 #ifndef NDEBUG
 void PaintArtifactCompositor::ShowDebugData() {
   LOG(ERROR) << LayersAsJSON(kLayerTreeIncludesDebugInfo)
                     ->ToPrettyJSONString()
                     .Utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink