[SPv2] Renaming and refactor about raster invalidation tracking

third_party/WebKit/Source/platform/graphics/GraphicsLayer.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 268 matching lines @@
   if (PaintWithoutCommit(interest_rect, disabled_mode)) {
     GetPaintController().CommitNewDisplayItems(
         OffsetFromLayoutObjectWithSubpixelAccumulation());
     if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
       sk_sp<PaintRecord> record = CaptureRecord();
       CheckPaintUnderInvalidations(record);
       RasterInvalidationTracking& tracking =
           GetRasterInvalidationTrackingMap().Add(this);
       tracking.last_painted_record = std::move(record);
       tracking.last_interest_rect = previous_interest_rect_;
-      tracking.raster_invalidation_region_since_last_paint = Region();
+      tracking.invalidation_region_since_last_paint = Region();
     }
   }
 }
 
 bool GraphicsLayer::PaintWithoutCommit(
     const IntRect* interest_rect,
     GraphicsContext::DisabledMode disabled_mode) {
   DCHECK(DrawsContent());
 
   if (!client_)
@@ skipping 175 matching lines @@
   is_tracking_raster_invalidations_ = tracks_raster_invalidations;
 }
 
 void GraphicsLayer::ResetTrackedRasterInvalidations() {
   RasterInvalidationTracking* tracking =
       GetRasterInvalidationTrackingMap().Find(this);
   if (!tracking)
     return;
 
   if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
-    tracking->tracked_raster_invalidations.clear();
+    tracking->invalidations.clear();
   else
     GetRasterInvalidationTrackingMap().Remove(this);
 }
 
 bool GraphicsLayer::HasTrackedRasterInvalidations() const {
   if (auto* tracking = GetRasterInvalidationTracking())
-    return !tracking->tracked_raster_invalidations.IsEmpty();
+    return !tracking->invalidations.IsEmpty();
   return false;
 }
 
 const RasterInvalidationTracking* GraphicsLayer::GetRasterInvalidationTracking()
     const {
   return GetRasterInvalidationTrackingMap().Find(this);
 }
 
 void GraphicsLayer::TrackRasterInvalidation(const DisplayItemClient& client,
                                             const IntRect& rect,
                                             PaintInvalidationReason reason) {
   if (!IsTrackingOrCheckingRasterInvalidations() || rect.IsEmpty())
     return;
 
   RasterInvalidationTracking& tracking =
       GetRasterInvalidationTrackingMap().Add(this);
 
   if (is_tracking_raster_invalidations_) {
     RasterInvalidationInfo info;
     info.client = &client;
     info.client_debug_name = client.DebugName();
     info.rect = rect;
     info.reason = reason;
-    tracking.tracked_raster_invalidations.push_back(info);
+    tracking.invalidations.push_back(info);
   }
 
   if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
     // TODO(crbug.com/496260): Some antialiasing effects overflow the paint
     // invalidation rect.
     IntRect r = rect;
     r.Inflate(1);
-    tracking.raster_invalidation_region_since_last_paint.Unite(r);
+    tracking.invalidation_region_since_last_paint.Unite(r);
   }
 }
 
 template <typename T>
 static std::unique_ptr<JSONArray> PointAsJSONArray(const T& point) {
   std::unique_ptr<JSONArray> array = JSONArray::Create();
   array->PushDouble(point.X());
   array->PushDouble(point.Y());
   return array;
 }
@@ skipping 710 matching lines @@
 
   int mismatching_pixels = 0;
   static const int kMaxMismatchesToReport = 50;
   for (int bitmap_y = 0; bitmap_y < rect.Height(); ++bitmap_y) {
     int layer_y = bitmap_y + rect.Y();
     for (int bitmap_x = 0; bitmap_x < rect.Width(); ++bitmap_x) {
       int layer_x = bitmap_x + rect.X();
       SkColor old_pixel = old_bitmap.getColor(bitmap_x, bitmap_y);
       SkColor new_pixel = new_bitmap.getColor(bitmap_x, bitmap_y);
       if (PixelsDiffer(old_pixel, new_pixel) &&
-          !tracking->raster_invalidation_region_since_last_paint.Contains(
+          !tracking->invalidation_region_since_last_paint.Contains(
               IntPoint(layer_x, layer_y))) {
         if (mismatching_pixels < kMaxMismatchesToReport) {
-          UnderPaintInvalidation under_paint_invalidation = {
-              layer_x, layer_y, old_pixel, new_pixel};
-          tracking->under_paint_invalidations.push_back(
-              under_paint_invalidation);
+          UnderRasterInvalidation under_invalidation = {layer_x, layer_y,
+                                                        old_pixel, new_pixel};
+          tracking->under_invalidations.push_back(under_invalidation);
           LOG(ERROR) << DebugName()
                      << " Uninvalidated old/new pixels mismatch at " << layer_x
                      << "," << layer_y << " old:" << std::hex << old_pixel
                      << " new:" << new_pixel;
         } else if (mismatching_pixels == kMaxMismatchesToReport) {
           LOG(ERROR) << "and more...";
         }
         ++mismatching_pixels;
         *new_bitmap.getAddr32(bitmap_x, bitmap_y) =
             SkColorSetARGB(0xFF, 0xA0, 0, 0);  // Dark red.
@@ skipping 20 matching lines @@
 void showGraphicsLayerTree(const blink::GraphicsLayer* layer) {
   if (!layer) {
     LOG(INFO) << "Cannot showGraphicsLayerTree for (nil).";
     return;
   }
 
   String output = layer->LayerTreeAsText(blink::kLayerTreeIncludesDebugInfo);
   LOG(INFO) << output.Utf8().data();
 }
 #endif