Don't access DisplayItemClient::VisualRect() for cached display items.

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"
@@ skipping 227 matching lines @@
       // Mark the client shouldKeepAlive under the current subsequence.
       // The status will end when the subsequence owner is invalidated or
       // deleted.
       client.BeginShouldKeepAlive(current_subsequence_clients_.back());
     }
   }
 }
 #endif
 
 void PaintController::ProcessNewItem(DisplayItem& display_item) {
+#if DCHECK_IS_ON()
   DCHECK(!construction_disabled_);
 
+  if (display_item.VisualRect() != display_item.Client().VisualRect()) {
+    LOG(ERROR) << "Visual rect changed without invalidation: "
+               << display_item.Client().DebugName()
+               << " old=" << display_item.VisualRect().ToString()
+               << " new=" << display_item.Client().VisualRect().ToString();
+    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
+      NOTREACHED();
+  }
+#endif
+
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
   if (display_item.IsCacheable()) {
     BeginShouldKeepAlive(display_item.Client());
   }
 #endif
 
   if (IsSkippingCache())
     display_item.SetSkippedCache();
 
   if (raster_invalidation_tracking_info_) {
@@ skipping 262 matching lines @@
                new_paint_chunks_.LastChunk().Matches(*cached_chunk));
     }
   }
 
   if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
     under_invalidation_checking_end_ = end_index + 1;
     DCHECK(IsCheckingUnderInvalidation());
   }
 }
 
-DISABLE_CFI_PERF
-static IntRect VisualRectForDisplayItem(
-    const DisplayItem& display_item,
-    const LayoutSize& offset_from_layout_object) {
-  LayoutRect visual_rect = display_item.Client().VisualRect();
-  visual_rect.Move(-offset_from_layout_object);
-  return EnclosingIntRect(visual_rect);
-}
-
 void PaintController::ResetCurrentListIndices() {
   next_item_to_match_ = 0;
   next_item_to_index_ = 0;
   next_chunk_to_match_ = 0;
   under_invalidation_checking_begin_ = 0;
   under_invalidation_checking_end_ = 0;
   skipped_probable_under_invalidation_count_ = 0;
 }
 
 DISABLE_CFI_PERF
-void PaintController::CommitNewDisplayItems(
-    const LayoutSize& offset_from_layout_object) {
+void PaintController::CommitNewDisplayItems() {
   TRACE_EVENT2("blink,benchmark", "PaintController::commitNewDisplayItems",
                "current_display_list_size",
                (int)current_paint_artifact_.GetDisplayItemList().size(),
                "num_non_cached_new_items",
                (int)new_display_item_list_.size() - num_cached_new_items_);
+
   num_cached_new_items_ = 0;
   // These data structures are used during painting only.
   DCHECK(!IsSkippingCache());
 #if DCHECK_IS_ON()
   new_display_item_indices_by_client_.clear();
 #endif
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
       !new_display_item_list_.IsEmpty())
     GenerateRasterInvalidations(new_paint_chunks_.LastChunk());
@@ skipping 13 matching lines @@
     DCHECK(current_subsequence_clients_.IsEmpty());
 #endif
   }
 
   Vector<const DisplayItemClient*> skipped_cache_clients;
   for (const auto& item : new_display_item_list_) {
     // No reason to continue the analysis once we have a veto.
     if (num_slow_paths <= kMaxNumberOfSlowPathsBeforeVeto)
       num_slow_paths += item.NumberOfSlowPaths();
 
-    // TODO(wkorman): Only compute and append visual rect for drawings.
-    new_display_item_list_.AppendVisualRect(
-        VisualRectForDisplayItem(item, offset_from_layout_object));
-
     if (item.IsCacheable()) {
       item.Client().SetDisplayItemsCached(current_cache_generation_);
     } else {
       if (item.Client().IsJustCreated())
         item.Client().ClearIsJustCreated();
       if (item.SkippedCache())
         skipped_cache_clients.push_back(&item.Client());
     }
   }
 
@@ skipping 63 matching lines @@
 
   // Memory outside this class due to m_newDisplayItemList.
   DCHECK(new_display_item_list_.IsEmpty());
   memory_usage += new_display_item_list_.MemoryUsageInBytes();
 
   return memory_usage;
 }
 
 void PaintController::AppendDebugDrawingAfterCommit(
     const DisplayItemClient& display_item_client,
-    sk_sp<PaintRecord> record,
-    const LayoutSize& offset_from_layout_object) {
+    sk_sp<PaintRecord> record) {
   DCHECK(new_display_item_list_.IsEmpty());
   DrawingDisplayItem& display_item =
       current_paint_artifact_.GetDisplayItemList()
           .AllocateAndConstruct<DrawingDisplayItem>(display_item_client,
                                                     DisplayItem::kDebugDrawing,
                                                     std::move(record));
   display_item.SetSkippedCache();
-  // TODO(wkorman): Only compute and append visual rect for drawings.
-  current_paint_artifact_.GetDisplayItemList().AppendVisualRect(
-      VisualRectForDisplayItem(display_item, offset_from_layout_object));
 }
 
 void PaintController::GenerateRasterInvalidations(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) {
@@ skipping 93 matching lines @@
         current_paint_artifact_.GetDisplayItemList()[old_index];
     const DisplayItemClient* client_to_invalidate = nullptr;
 
     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();
+          const auto& new_item = new_display_item_list_[moved_to_index];
+          client_to_invalidate = &new_item.Client();
           // And invalidate in the new chunk into which the item was moved.
           PaintChunk& moved_to_chunk =
               new_paint_chunks_.FindChunkByDisplayItemIndex(moved_to_index);
           AddRasterInvalidation(*client_to_invalidate, moved_to_chunk,
-                                FloatRect(client_to_invalidate->VisualRect()));
+                                FloatRect(new_item.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()) {
       client_to_invalidate = &old_item.Client();
     }
     if (client_to_invalidate &&
         invalidated_clients_in_old_chunk.insert(client_to_invalidate)
             .is_new_entry) {
-      AddRasterInvalidation(
-          *client_to_invalidate, new_chunk,
-          FloatRect(current_paint_artifact_.GetDisplayItemList().VisualRect(
-              old_index)));
+      AddRasterInvalidation(*client_to_invalidate, new_chunk,
+                            FloatRect(old_item.VisualRect()));
     }
   }
 
   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) {
       AddRasterInvalidation(new_item.Client(), new_chunk,
-                            FloatRect(new_item.Client().VisualRect()));
+                            FloatRect(new_item.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 144 matching lines @@
 }
 
 FrameFirstPaint PaintController::EndFrame(const void* frame) {
   FrameFirstPaint result = frame_first_paints_.back();
   DCHECK(result.frame == frame);
   frame_first_paints_.pop_back();
   return result;
 }
 
 }  // namespace blink