Remove mean_pixels_checkerboarded metric

It's basically redundant (with some differences) with UMA metrics
Graphics.Smoothness.Checkerboarding4.* which are also collected for
related benchmarks. The metric has not been monitored since some
time in 2018.

The catapult side CL is
https://chromium-review.googlesource.com/c/catapult/+/5961950.

Bug: chromium:40619073
Change-Id: Ia9516678e47fece1c47636d6cd85ca4a14205f0b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5963622
Reviewed-by: Philip Rogers <pdr@chromium.org>
Commit-Queue: Xianzhu Wang <wangxianzhu@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1374147}

cc/debug/rendering_stats.cc

@@ -51,12 +51,6 @@ RenderingStats::AsTraceableData() const {
   record_data->SetInteger("visible_content_area", visible_content_area);
   record_data->SetInteger("approximated_visible_content_area",
                           approximated_visible_content_area);
-  record_data->SetInteger("checkerboarded_visible_content_area",
-                          checkerboarded_visible_content_area);
-  record_data->SetInteger("checkerboarded_needs_record_content_area",
-                          checkerboarded_needs_record_content_area);
-  record_data->SetInteger("checkerboarded_needs_raster_content_area",
-                          checkerboarded_needs_raster_content_area);
   draw_duration.AddToTracedValue("draw_duration_ms", record_data.get());
 
   draw_duration_estimate.AddToTracedValue("draw_duration_estimate_ms",

cc/debug/rendering_stats.h

@@ -43,9 +43,6 @@ struct CC_DEBUG_EXPORT RenderingStats {
   int64_t frame_count = 0;
   int64_t visible_content_area = 0;
   int64_t approximated_visible_content_area = 0;
-  int64_t checkerboarded_visible_content_area = 0;
-  int64_t checkerboarded_needs_record_content_area = 0;
-  int64_t checkerboarded_needs_raster_content_area = 0;
 
   TimeDeltaList draw_duration;
   TimeDeltaList draw_duration_estimate;

cc/debug/rendering_stats_instrumentation.cc

@@ -54,33 +54,6 @@ void RenderingStatsInstrumentation::AddApproximatedVisibleContentArea(
   impl_thread_rendering_stats_.approximated_visible_content_area += area;
 }
 
-void RenderingStatsInstrumentation::AddCheckerboardedVisibleContentArea(
-    int64_t area) {
-  if (!record_rendering_stats_)
-    return;
-
-  base::AutoLock scoped_lock(lock_);
-  impl_thread_rendering_stats_.checkerboarded_visible_content_area += area;
-}
-
-void RenderingStatsInstrumentation::AddCheckerboardedNeedsRecordContentArea(
-    int64_t area) {
-  if (!record_rendering_stats_)
-    return;
-
-  base::AutoLock scoped_lock(lock_);
-  impl_thread_rendering_stats_.checkerboarded_needs_record_content_area += area;
-}
-
-void RenderingStatsInstrumentation::AddCheckerboardedNeedsRasterContentArea(
-    int64_t area) {
-  if (!record_rendering_stats_)
-    return;
-
-  base::AutoLock scoped_lock(lock_);
-  impl_thread_rendering_stats_.checkerboarded_needs_raster_content_area += area;
-}
-
 void RenderingStatsInstrumentation::AddDrawDuration(
     base::TimeDelta draw_duration,
     base::TimeDelta draw_duration_estimate) {

cc/debug/rendering_stats_instrumentation.h

@@ -41,9 +41,6 @@ class CC_DEBUG_EXPORT RenderingStatsInstrumentation {
   void IncrementFrameCount(int64_t count);
   void AddVisibleContentArea(int64_t area);
   void AddApproximatedVisibleContentArea(int64_t area);
-  void AddCheckerboardedVisibleContentArea(int64_t area);
-  void AddCheckerboardedNeedsRecordContentArea(int64_t area);
-  void AddCheckerboardedNeedsRasterContentArea(int64_t area);
   void AddDrawDuration(base::TimeDelta draw_duration,
                        base::TimeDelta draw_duration_estimate);
   void AddBeginMainFrameToCommitDuration(

cc/layers/append_quads_data.h

@@ -21,21 +21,15 @@ class CC_EXPORT AppendQuadsData {
   AppendQuadsData();
   ~AppendQuadsData();
 
-  int num_incompletely_rastered_tiles = 0;
-  int num_incompletely_recorded_tiles = 0;
   int num_missing_tiles = 0;
 
-  int64_t visible_layer_area = 0;
-  int64_t approximated_visible_content_area = 0;
+  bool checkerboarded_needs_raster = false;
+  bool checkerboarded_needs_record = false;
 
-  // This is total of the following areas. Overlapping areas are excluded.
-  int64_t checkerboarded_visible_content_area = 0;
-  // This is the visible content area of outside of the record cull rect,
-  // which may be incompletedly recorded.
-  int64_t checkerboarded_needs_record_content_area = 0;
-  // This is the visible content area containing existing recording but not
-  // rasterized (even in low resolution). This may overlap with the above.
-  int64_t checkerboarded_needs_raster_content_area = 0;
+  int64_t visible_layer_area = 0;
+
+  // The visible content area of tiles that are of low or non-ideal resolution.
+  int64_t approximated_visible_content_area = 0;
 
   // The non-default number of BeginFrames to wait before forcibly activating
   // this CompositorFrame.

cc/layers/heads_up_display_layer_impl_unittest.cc

@@ -42,8 +42,8 @@ void CheckDrawLayer(HeadsUpDisplayLayerImpl* layer,
   size_t expected_quad_list_size = will_draw ? 1 : 0;
   EXPECT_EQ(expected_quad_list_size, pass_list.back()->quad_list.size());
   EXPECT_EQ(0, data.num_missing_tiles);
-  EXPECT_EQ(0, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(0, data.num_incompletely_recorded_tiles);
+  EXPECT_FALSE(data.checkerboarded_needs_raster);
+  EXPECT_FALSE(data.checkerboarded_needs_record);
 }
 
 class HeadsUpDisplayLayerImplTest : public LayerTreeImplTestBase,

cc/layers/picture_layer_impl.cc

@@ -421,7 +421,7 @@ void PictureLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
     }
   }
 
-  int missing_tile_count = 0u;
+  int missing_tile_count = 0;
   only_used_low_res_last_append_quads_ = true;
   gfx::Rect scaled_recorded_bounds = gfx::ScaleToEnclosingRect(
       raster_source_->recorded_bounds(), max_contents_scale);
@@ -476,7 +476,7 @@ void PictureLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
           if (iter->contents_scale_key() != raster_contents_scale_key() &&
               iter->contents_scale_key() < ideal_contents_scale_key() &&
               geometry_rect.Intersects(scaled_viewport_for_tile_priority)) {
-            append_quads_data->num_incompletely_rastered_tiles++;
+            append_quads_data->checkerboarded_needs_raster = true;
           }
 
           auto* quad =
@@ -511,17 +511,9 @@ void PictureLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
       }
     }
 
-    int64_t needs_record_content_area = 0;
-    if (scaled_cull_rect) {
-      gfx::Rect fully_recorded_rect =
-          gfx::IntersectRects(*scaled_cull_rect, visible_geometry_rect);
-      if (fully_recorded_rect != visible_geometry_rect) {
-        append_quads_data->num_incompletely_recorded_tiles++;
-        needs_record_content_area =
-            visible_geometry_area - fully_recorded_rect.size().Area64();
-        append_quads_data->checkerboarded_needs_record_content_area +=
-            needs_record_content_area;
-      }
+    if (scaled_cull_rect &&
+        !scaled_cull_rect->Contains(visible_geometry_rect)) {
+      append_quads_data->checkerboarded_needs_record = true;
     }
 
     if (!has_draw_quad) {
@@ -538,19 +530,8 @@ void PictureLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
       ValidateQuadResources(quad);
 
       if (geometry_rect.Intersects(scaled_viewport_for_tile_priority)) {
-        append_quads_data->num_missing_tiles++;
         ++missing_tile_count;
       }
-      append_quads_data->checkerboarded_visible_content_area +=
-          visible_geometry_area;
-      // Intersect checkerboard rect with recorded bounds to generate rect where
-      // we checkerboarded and has recording. The area where we don't have
-      // recording is not necessarily a Rect, and its area is calculated using
-      // subtraction.
-      gfx::Rect visible_rect_has_recording = visible_geometry_rect;
-      visible_rect_has_recording.Intersect(scaled_recorded_bounds);
-      append_quads_data->checkerboarded_needs_raster_content_area +=
-          visible_rect_has_recording.size().Area64();
 
       // Report data on any missing images that might be the largest
       // contentful image.
@@ -563,9 +544,6 @@ void PictureLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
       continue;
     }
 
-    append_quads_data->checkerboarded_visible_content_area +=
-        needs_record_content_area;
-
     if (iter.resolution() != HIGH_RESOLUTION) {
       append_quads_data->approximated_visible_content_area +=
           visible_geometry_area;
@@ -589,6 +567,8 @@ void PictureLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
   shared_quad_state->visible_quad_layer_rect.Offset(quad_offset);
 
   if (missing_tile_count) {
+    append_quads_data->num_missing_tiles += missing_tile_count;
+    append_quads_data->checkerboarded_needs_raster = true;
     TRACE_EVENT_INSTANT1("cc", "PictureLayerImpl::AppendQuads checkerboard",
                          TRACE_EVENT_SCOPE_THREAD, "missing_tile_count",
                          missing_tile_count);

cc/layers/picture_layer_impl_unittest.cc

@@ -1968,8 +1968,8 @@ TEST_F(NoLowResPictureLayerImplTest,
 
   // All tiles in activation rect is ready to draw.
   EXPECT_EQ(0, data.num_missing_tiles);
-  EXPECT_EQ(0, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(0, data.num_incompletely_recorded_tiles);
+  EXPECT_FALSE(data.checkerboarded_needs_raster);
+  EXPECT_FALSE(data.checkerboarded_needs_record);
   EXPECT_FALSE(active_layer()->only_used_low_res_last_append_quads());
 }
 
@@ -1999,8 +1999,8 @@ TEST_F(LegacySWPictureLayerImplTest, HighResTileIsComplete) {
   // All high res tiles drew, nothing was incomplete.
   EXPECT_EQ(9u, render_pass->quad_list.size());
   EXPECT_EQ(0, data.num_missing_tiles);
-  EXPECT_EQ(0, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(0, data.num_incompletely_recorded_tiles);
+  EXPECT_FALSE(data.checkerboarded_needs_raster);
+  EXPECT_FALSE(data.checkerboarded_needs_record);
   EXPECT_FALSE(active_layer()->only_used_low_res_last_append_quads());
 }
 
@@ -2023,8 +2023,8 @@ TEST_F(LegacySWPictureLayerImplTest, HighResTileIsIncomplete) {
 
   EXPECT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(1, data.num_missing_tiles);
-  EXPECT_EQ(0, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(0, data.num_incompletely_recorded_tiles);
+  EXPECT_TRUE(data.checkerboarded_needs_raster);
+  EXPECT_FALSE(data.checkerboarded_needs_record);
   EXPECT_TRUE(active_layer()->only_used_low_res_last_append_quads());
 }
 
@@ -2052,8 +2052,8 @@ TEST_F(LegacySWPictureLayerImplTest, HighResTileIsIncompleteLowResComplete) {
 
   EXPECT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(0, data.num_missing_tiles);
-  EXPECT_EQ(1, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(0, data.num_incompletely_recorded_tiles);
+  EXPECT_TRUE(data.checkerboarded_needs_raster);
+  EXPECT_FALSE(data.checkerboarded_needs_record);
   EXPECT_TRUE(active_layer()->only_used_low_res_last_append_quads());
 }
 
@@ -2090,8 +2090,8 @@ TEST_F(LegacySWPictureLayerImplTest, LowResTileIsIncomplete) {
   // The missing high res tile was replaced by a low res tile.
   EXPECT_EQ(9u, render_pass->quad_list.size());
   EXPECT_EQ(0, data.num_missing_tiles);
-  EXPECT_EQ(1, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(0, data.num_incompletely_recorded_tiles);
+  EXPECT_TRUE(data.checkerboarded_needs_raster);
+  EXPECT_FALSE(data.checkerboarded_needs_record);
   EXPECT_FALSE(active_layer()->only_used_low_res_last_append_quads());
 }
 
@@ -2155,8 +2155,8 @@ TEST_F(LegacySWPictureLayerImplTest,
 
   // Neither the high res nor the ideal tiles were considered as incomplete.
   EXPECT_EQ(0, data.num_missing_tiles);
-  EXPECT_EQ(0, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(0, data.num_incompletely_recorded_tiles);
+  EXPECT_FALSE(data.checkerboarded_needs_raster);
+  EXPECT_FALSE(data.checkerboarded_needs_record);
   EXPECT_FALSE(active_layer()->only_used_low_res_last_append_quads());
 }
 
@@ -2187,11 +2187,8 @@ TEST_F(LegacySWPictureLayerImplTest, AppendQuadsDataForCheckerboard) {
   EXPECT_EQ(recorded_bounds, active_layer()->HighResTiling()->tiling_rect());
   EXPECT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(1, data.num_missing_tiles);
-  EXPECT_EQ(0, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(1, data.num_incompletely_recorded_tiles);
-  EXPECT_EQ(22500, data.checkerboarded_visible_content_area);
-  EXPECT_EQ(8100, data.checkerboarded_needs_record_content_area);
-  EXPECT_EQ(22500, data.checkerboarded_needs_raster_content_area);
+  EXPECT_TRUE(data.checkerboarded_needs_raster);
+  EXPECT_TRUE(data.checkerboarded_needs_record);
   EXPECT_TRUE(active_layer()->only_used_low_res_last_append_quads());
 
   recorded_bounds = gfx::Rect(30, 30, 150, 150);
@@ -2210,11 +2207,8 @@ TEST_F(LegacySWPictureLayerImplTest, AppendQuadsDataForCheckerboard) {
             active_layer()->HighResTiling()->tiling_rect());
   EXPECT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(1, data.num_missing_tiles);
-  EXPECT_EQ(0, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(1, data.num_incompletely_recorded_tiles);
-  EXPECT_EQ(32400, data.checkerboarded_visible_content_area);
-  EXPECT_EQ(18000, data.checkerboarded_needs_record_content_area);
-  EXPECT_EQ(22500, data.checkerboarded_needs_raster_content_area);
+  EXPECT_TRUE(data.checkerboarded_needs_raster);
+  EXPECT_TRUE(data.checkerboarded_needs_record);
   EXPECT_TRUE(active_layer()->only_used_low_res_last_append_quads());
 
   // Initialize all tiles with resources.
@@ -2230,11 +2224,8 @@ TEST_F(LegacySWPictureLayerImplTest, AppendQuadsDataForCheckerboard) {
   active_layer()->DidDraw(nullptr);
   EXPECT_EQ(4u, render_pass->quad_list.size());
   EXPECT_EQ(0, data.num_missing_tiles);
-  EXPECT_EQ(0, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(3, data.num_incompletely_recorded_tiles);
-  EXPECT_EQ(18000, data.checkerboarded_visible_content_area);
-  EXPECT_EQ(18000, data.checkerboarded_needs_record_content_area);
-  EXPECT_EQ(0, data.checkerboarded_needs_raster_content_area);
+  EXPECT_FALSE(data.checkerboarded_needs_raster);
+  EXPECT_TRUE(data.checkerboarded_needs_record);
   EXPECT_FALSE(active_layer()->only_used_low_res_last_append_quads());
 
   // Now the layer is fully recorded.
@@ -2252,11 +2243,8 @@ TEST_F(LegacySWPictureLayerImplTest, AppendQuadsDataForCheckerboard) {
   active_layer()->DidDraw(nullptr);
   EXPECT_EQ(4u, render_pass->quad_list.size());
   EXPECT_EQ(0, data.num_missing_tiles);
-  EXPECT_EQ(0, data.num_incompletely_rastered_tiles);
-  EXPECT_EQ(0, data.num_incompletely_recorded_tiles);
-  EXPECT_EQ(0, data.checkerboarded_visible_content_area);
-  EXPECT_EQ(0, data.checkerboarded_needs_record_content_area);
-  EXPECT_EQ(0, data.checkerboarded_needs_raster_content_area);
+  EXPECT_FALSE(data.checkerboarded_needs_raster);
+  EXPECT_FALSE(data.checkerboarded_needs_record);
   EXPECT_FALSE(active_layer()->only_used_low_res_last_append_quads());
 }
 
@@ -5926,8 +5914,8 @@ TEST_F(LegacySWPictureLayerImplTest, CompositedImageIgnoreIdealContentsScale) {
   EXPECT_EQ(viz::DrawQuad::Material::kTiledContent,
             render_pass->quad_list.front()->material);
 
-  // Tiles are ready at correct scale, so should not set had_incomplete_tile.
-  EXPECT_EQ(0, data.num_incompletely_rastered_tiles);
+  // Tiles are ready at correct scale. No tiles need raster.
+  EXPECT_FALSE(data.checkerboarded_needs_raster);
 }
 
 TEST_F(LegacySWPictureLayerImplTest, CompositedImageRasterScaleChanges) {

cc/trees/layer_tree_host_impl.cc

@@ -1389,8 +1389,8 @@ DrawResult LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   const DrawMode draw_mode = GetDrawMode();
 
   int num_missing_tiles = 0;
-  bool has_incompletely_rastered_tiles = false;
-  bool has_incompletely_recorded_tiles = false;
+  CHECK(!frame->checkerboarded_needs_raster);
+  CHECK(!frame->checkerboarded_needs_record);
 
   bool have_copy_request =
       active_tree()->property_trees()->effect_tree().HasCopyRequests();
@@ -1461,18 +1461,12 @@ DrawResult LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
           append_quads_data.visible_layer_area);
       rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
           append_quads_data.approximated_visible_content_area);
-      rendering_stats_instrumentation_->AddCheckerboardedVisibleContentArea(
-          append_quads_data.checkerboarded_visible_content_area);
-      rendering_stats_instrumentation_->AddCheckerboardedNeedsRecordContentArea(
-          append_quads_data.checkerboarded_needs_record_content_area);
-      rendering_stats_instrumentation_->AddCheckerboardedNeedsRasterContentArea(
-          append_quads_data.checkerboarded_needs_raster_content_area);
 
       num_missing_tiles += append_quads_data.num_missing_tiles;
-      has_incompletely_rastered_tiles |=
-          append_quads_data.num_incompletely_rastered_tiles > 0;
-      has_incompletely_recorded_tiles |=
-          append_quads_data.num_incompletely_recorded_tiles > 0;
+      frame->checkerboarded_needs_raster |=
+          append_quads_data.checkerboarded_needs_raster;
+      frame->checkerboarded_needs_record |=
+          append_quads_data.checkerboarded_needs_record;
 
       if (append_quads_data.num_missing_tiles > 0) {
         have_missing_animated_tiles |=
@@ -1509,7 +1503,7 @@ DrawResult LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   // not cause the scheduler to do a main frame, instead it will continue to try
   // drawing until we finally complete, so the copy request will not be lost.
   // TODO(weiliangc): Remove RequiresHighResToDraw. crbug.com/469175
-  if (has_incompletely_rastered_tiles || num_missing_tiles) {
+  if (frame->checkerboarded_needs_raster) {
     if (RequiresHighResToDraw())
       draw_result = DrawResult::kAbortedMissingHighResContent;
   }
@@ -1565,10 +1559,6 @@ DrawResult LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
     active_tree()->set_needs_update_draw_properties();
   }
 
-  frame->checkerboarded_needs_raster =
-      num_missing_tiles > 0 || has_incompletely_rastered_tiles;
-  frame->checkerboarded_needs_record = has_incompletely_recorded_tiles;
-
   TRACE_EVENT_END2("cc,benchmark", "LayerTreeHostImpl::CalculateRenderPasses",
                    "draw_result", draw_result, "missing tiles",
                    num_missing_tiles);

cc/trees/layer_tree_host_impl_unittest.cc

@@ -3734,8 +3734,7 @@ class IncompleteRecordingLayer : public LayerImpl {
 
   void AppendQuads(viz::CompositorRenderPass* render_pass,
                    AppendQuadsData* append_quads_data) override {
-    append_quads_data->checkerboarded_needs_record_content_area += 200;
-    append_quads_data->num_incompletely_recorded_tiles++;
+    append_quads_data->checkerboarded_needs_record = true;
     append_quads_data->visible_layer_area += 200;
   }
 };
@@ -6776,10 +6775,11 @@ class MissingTextureAnimatingLayer : public DidDrawCheckLayer {
                    AppendQuadsData* append_quads_data) override {
     LayerImpl::AppendQuads(render_pass, append_quads_data);
     if (had_incomplete_tile_) {
-      append_quads_data->num_incompletely_rastered_tiles++;
+      append_quads_data->checkerboarded_needs_raster = true;
     }
     if (tile_missing_) {
       append_quads_data->num_missing_tiles++;
+      append_quads_data->checkerboarded_needs_raster = true;
     }
   }
 

docs/speed/benchmark/harnesses/rendering.md

@@ -30,7 +30,7 @@ These benchmarks are run on the [Chromium Perf Waterfall](https://ci.chromium.or
 Rendering metrics are [written in Javascript](https://cs.chromium.org/chromium/src/third_party/catapult/tracing/tracing/metrics/rendering/). The list of all metrics and their meanings should be documented in the files they are defined in.
 
 -   [cpu\_utilization.html](https://cs.chromium.org/chromium/src/third_party/catapult/tracing/tracing/metrics/rendering/cpu_utilization.html): `cpu_time_per_frame` and `tasks_per_frame`
--   [pixels.html](https://cs.chromium.org/chromium/src/third_party/catapult/tracing/tracing/metrics/rendering/pixels.html): `mean_pixels_approximated` and `mean_pixels_checkerboarded`
+-   [pixels.html](https://cs.chromium.org/chromium/src/third_party/catapult/tracing/tracing/metrics/rendering/pixels.html): `mean_pixels_approximated`
 -   [queueing\_duration.html](https://cs.chromium.org/chromium/src/third_party/catapult/tracing/tracing/metrics/rendering/queueing_duration.html): `queueing_durations`
 
 ## How to run rendering benchmarks on local devices