[wip/exp] cc: Measure the amount of overdraw.

cc/output/gl_renderer.cc

 // Copyright 2010 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 "cc/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 548 matching lines @@
   ReinitializeGLState();
 }
 
 void GLRenderer::DoDrawQuad(const DrawQuad* quad,
                             const gfx::QuadF* clip_region) {
   DCHECK(quad->rect.Contains(quad->visible_rect));
   if (quad->material != DrawQuad::TEXTURE_CONTENT) {
     FlushTextureQuadCache(SHARED_BINDING);
   }
 
+  bool was_drawn = false;
   switch (quad->material) {
     case DrawQuad::INVALID:
       NOTREACHED();
       break;
     case DrawQuad::DEBUG_BORDER:
       DrawDebugBorderQuad(DebugBorderDrawQuad::MaterialCast(quad));
+      was_drawn = true;
       break;
     case DrawQuad::PICTURE_CONTENT:
       // PictureDrawQuad should only be used for resourceless software draws.
       NOTREACHED();
       break;
     case DrawQuad::RENDER_PASS:
-      DrawRenderPassQuad(RenderPassDrawQuad::MaterialCast(quad), clip_region);
+      was_drawn = DrawRenderPassQuad(RenderPassDrawQuad::MaterialCast(quad),
+                                     clip_region);
       break;
     case DrawQuad::SOLID_COLOR:
-      DrawSolidColorQuad(SolidColorDrawQuad::MaterialCast(quad), clip_region);
+      was_drawn = DrawSolidColorQuad(SolidColorDrawQuad::MaterialCast(quad),
+                                     clip_region);
       break;
     case DrawQuad::STREAM_VIDEO_CONTENT:
-      DrawStreamVideoQuad(StreamVideoDrawQuad::MaterialCast(quad), clip_region);
+      was_drawn = DrawStreamVideoQuad(StreamVideoDrawQuad::MaterialCast(quad),
+                                      clip_region);
       break;
     case DrawQuad::SURFACE_CONTENT:
       // Surface content should be fully resolved to other quad types before
       // reaching a direct renderer.
       NOTREACHED();
       break;
     case DrawQuad::TEXTURE_CONTENT:
-      EnqueueTextureQuad(TextureDrawQuad::MaterialCast(quad), clip_region);
+      was_drawn =
+          EnqueueTextureQuad(TextureDrawQuad::MaterialCast(quad), clip_region);
       break;
     case DrawQuad::TILED_CONTENT:
-      DrawTileQuad(TileDrawQuad::MaterialCast(quad), clip_region);
+      was_drawn = DrawTileQuad(TileDrawQuad::MaterialCast(quad), clip_region);
       break;
     case DrawQuad::YUV_VIDEO_CONTENT:
-      DrawYUVVideoQuad(YUVVideoDrawQuad::MaterialCast(quad), clip_region);
+      was_drawn =
+          DrawYUVVideoQuad(YUVVideoDrawQuad::MaterialCast(quad), clip_region);
       break;
   }
+  if (was_drawn)
+    area_drawn_ += quad->visible_rect.size().GetArea();
 }
 
 // This function does not handle 3D sorting right now, since the debug border
 // quads are just drawn as their original quads and not in split pieces. This
 // results in some debug border quads drawing over foreground quads.
 void GLRenderer::DrawDebugBorderQuad(const DebugBorderDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   SetUseProgram(ProgramKey::DebugBorder(), gfx::ColorSpace::CreateSRGB());
 
@@ skipping 412 matching lines @@
     return nullptr;
 #if defined(OS_MACOSX)
   // On Macs, this path can sometimes lead to all black output.
   // TODO(enne): investigate this and remove this hack.
   return nullptr;
 #endif
 
   return tile_quad;
 }
 
-void GLRenderer::DrawRenderPassQuad(const RenderPassDrawQuad* quad,
+bool GLRenderer::DrawRenderPassQuad(const RenderPassDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
   auto bypass = render_pass_bypass_quads_.find(quad->render_pass_id);
   DrawRenderPassDrawQuadParams params;
   params.quad = quad;
   params.clip_region = clip_region;
   params.window_matrix = current_frame()->window_matrix;
   params.projection_matrix = current_frame()->projection_matrix;
   params.tex_coord_rect = quad->tex_coord_rect;
   if (bypass != render_pass_bypass_quads_.end()) {
     TileDrawQuad* tile_quad = &bypass->second;
     // RGBA_8888 here is arbitrary and unused.
     Resource tile_resource(tile_quad->resource_id(), tile_quad->texture_size,
                            ResourceFormat::RGBA_8888,
                            current_frame()->current_render_pass->color_space);
     // The projection matrix used by GLRenderer has a flip.  As tile texture
     // inputs are oriented opposite to framebuffer outputs, don't flip via
     // texture coords and let the projection matrix naturallyd o it.
     params.flip_texture = false;
     params.contents_texture = &tile_resource;
-    DrawRenderPassQuadInternal(&params);
+    return DrawRenderPassQuadInternal(&params);
   } else {
     ScopedResource* contents_texture =
         render_pass_textures_[quad->render_pass_id].get();
     DCHECK(contents_texture);
     DCHECK(contents_texture->id());
     // See above comments about texture flipping.  When the input is a
     // render pass, it needs to an extra flip to be oriented correctly.
     params.flip_texture = true;
     params.contents_texture = contents_texture;
-    DrawRenderPassQuadInternal(&params);
+    return DrawRenderPassQuadInternal(&params);
   }
 }
 
-void GLRenderer::DrawRenderPassQuadInternal(
+bool GLRenderer::DrawRenderPassQuadInternal(
     DrawRenderPassDrawQuadParams* params) {
   params->quad_to_target_transform =
       params->quad->shared_quad_state->quad_to_target_transform;
   if (!InitializeRPDQParameters(params))
-    return;
+    return false;
   UpdateRPDQShadersForBlending(params);
   if (!UpdateRPDQWithSkiaFilters(params))
-    return;
+    return false;
   UseRenderPass(current_frame()->current_render_pass);
   SetViewport();
   UpdateRPDQTexturesForSampling(params);
   UpdateRPDQBlendMode(params);
   ChooseRPDQProgram(params);
   UpdateRPDQUniforms(params);
   DrawRPDQ(*params);
+  return true;
 }
 
 bool GLRenderer::InitializeRPDQParameters(
     DrawRenderPassDrawQuadParams* params) {
   const RenderPassDrawQuad* quad = params->quad;
   SkMatrix local_matrix;
   local_matrix.setTranslate(quad->filters_origin.x(), quad->filters_origin.y());
   local_matrix.postScale(quad->filters_scale.x(), quad->filters_scale.y());
   params->filters = FiltersForPass(quad->render_pass_id);
   params->background_filters = BackgroundFiltersForPass(quad->render_pass_id);
@@ skipping 621 matching lines @@
     device_quad = GetDeviceQuadWithAntialiasingOnExteriorEdges(
         device_layer_edges, device_transform, tile_quad, local_clip_region,
         quad);
   } else {
     device_quad = device_layer_edges.ToQuadF();
   }
 
   *local_quad = MapQuadToLocalSpace(device_transform, device_quad);
 }
 
-void GLRenderer::DrawSolidColorQuad(const SolidColorDrawQuad* quad,
+bool GLRenderer::DrawSolidColorQuad(const SolidColorDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   SkColor color = quad->color;
   float opacity = quad->shared_quad_state->opacity;
   float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
 
   // Early out if alpha is small enough that quad doesn't contribute to output.
   if (alpha < std::numeric_limits<float>::epsilon() &&
       quad->ShouldDrawWithBlending())
-    return;
+    return false;
 
   gfx::Transform device_transform =
       current_frame()->window_matrix * current_frame()->projection_matrix *
       quad->shared_quad_state->quad_to_target_transform;
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
-    return;
+    return false;
 
   auto local_quad = gfx::QuadF(gfx::RectF(tile_rect));
 
   gfx::QuadF device_layer_quad;
   bool use_aa = false;
   bool allow_aa = settings_->allow_antialiasing &&
                   !quad->force_anti_aliasing_off && quad->IsEdge();
 
   if (allow_aa) {
     bool clipped = false;
@@ skipping 45 matching lines @@
     DrawQuadGeometry(current_frame()->projection_matrix,
                      quad->shared_quad_state->quad_to_target_transform,
                      centered_rect);
   } else {
     PrepareGeometry(SHARED_BINDING);
     SetShaderQuadF(local_quad);
     SetShaderMatrix(current_frame()->projection_matrix *
                     quad->shared_quad_state->quad_to_target_transform);
     gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
   }
+  return true;
 }
 
-void GLRenderer::DrawTileQuad(const TileDrawQuad* quad,
+bool GLRenderer::DrawTileQuad(const TileDrawQuad* quad,
                               const gfx::QuadF* clip_region) {
-  DrawContentQuad(quad, quad->resource_id(), clip_region);
+  return DrawContentQuad(quad, quad->resource_id(), clip_region);
 }
 
-void GLRenderer::DrawContentQuad(const ContentDrawQuadBase* quad,
+bool GLRenderer::DrawContentQuad(const ContentDrawQuadBase* quad,
                                  ResourceId resource_id,
                                  const gfx::QuadF* clip_region) {
   gfx::Transform device_transform =
       current_frame()->window_matrix * current_frame()->projection_matrix *
       quad->shared_quad_state->quad_to_target_transform;
   device_transform.FlattenTo2d();
 
   gfx::QuadF device_layer_quad;
   bool use_aa = false;
   bool allow_aa = settings_->allow_antialiasing && quad->IsEdge();
   if (allow_aa) {
     bool clipped = false;
     bool force_aa = false;
     device_layer_quad = MathUtil::MapQuad(
         device_transform,
         gfx::QuadF(
             gfx::RectF(quad->shared_quad_state->visible_quad_layer_rect)),
         &clipped);
     use_aa = ShouldAntialiasQuad(device_layer_quad, clipped, force_aa);
   }
 
   // TODO(timav): simplify coordinate transformations in DrawContentQuadAA
   // similar to the way DrawContentQuadNoAA works and then consider
   // combining DrawContentQuadAA and DrawContentQuadNoAA into one method.
   if (use_aa)
-    DrawContentQuadAA(quad, resource_id, device_transform, device_layer_quad,
-                      clip_region);
-  else
-    DrawContentQuadNoAA(quad, resource_id, clip_region);
+    return DrawContentQuadAA(quad, resource_id, device_transform,
+                             device_layer_quad, clip_region);
+  return DrawContentQuadNoAA(quad, resource_id, clip_region);
 }
 
-void GLRenderer::DrawContentQuadAA(const ContentDrawQuadBase* quad,
+bool GLRenderer::DrawContentQuadAA(const ContentDrawQuadBase* quad,
                                    ResourceId resource_id,
                                    const gfx::Transform& device_transform,
                                    const gfx::QuadF& aa_quad,
                                    const gfx::QuadF* clip_region) {
   if (!device_transform.IsInvertible())
-    return;
+    return false;
 
   gfx::Rect tile_rect = quad->visible_rect;
 
   gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(
       quad->tex_coord_rect, gfx::RectF(quad->rect), gfx::RectF(tile_rect));
   float tex_to_geom_scale_x = quad->rect.width() / quad->tex_coord_rect.width();
   float tex_to_geom_scale_y =
       quad->rect.height() / quad->tex_coord_rect.height();
 
   gfx::RectF clamp_geom_rect(tile_rect);
@@ skipping 79 matching lines @@
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   gfx::RectF centered_rect(
       gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
       gfx::SizeF(tile_rect.size()));
   DrawQuadGeometry(current_frame()->projection_matrix,
                    quad->shared_quad_state->quad_to_target_transform,
                    centered_rect);
+  return true;
 }
 
-void GLRenderer::DrawContentQuadNoAA(const ContentDrawQuadBase* quad,
+bool GLRenderer::DrawContentQuadNoAA(const ContentDrawQuadBase* quad,
                                      ResourceId resource_id,
                                      const gfx::QuadF* clip_region) {
   gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(
       quad->tex_coord_rect, gfx::RectF(quad->rect),
       gfx::RectF(quad->visible_rect));
   float tex_to_geom_scale_x = quad->rect.width() / quad->tex_coord_rect.width();
   float tex_to_geom_scale_y =
       quad->rect.height() / quad->tex_coord_rect.height();
 
   bool scaled = (tex_to_geom_scale_x != 1.f || tex_to_geom_scale_y != 1.f);
@@ skipping 72 matching lines @@
       tile_quad.p4().x(), tile_quad.p4().y(), tile_quad.p1().x(),
       tile_quad.p1().y(), tile_quad.p2().x(), tile_quad.p2().y(),
       tile_quad.p3().x(), tile_quad.p3().y(),
   };
   gl_->Uniform2fv(current_program_->quad_location(), 4, gl_quad);
 
   SetShaderMatrix(current_frame()->projection_matrix *
                   quad->shared_quad_state->quad_to_target_transform);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
+  return true;
 }
 
-void GLRenderer::DrawYUVVideoQuad(const YUVVideoDrawQuad* quad,
+bool GLRenderer::DrawYUVVideoQuad(const YUVVideoDrawQuad* quad,
                                   const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, settings_->highp_threshold_min,
       quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
   YUVAlphaTextureMode alpha_texture_mode = quad->a_plane_resource_id()
                                                ? YUV_HAS_ALPHA_TEXTURE
                                                : YUV_NO_ALPHA_TEXTURE;
   UVTextureMode uv_texture_mode =
@@ skipping 144 matching lines @@
   } else {
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     gfx::QuadF region_quad = *clip_region;
     region_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
     DrawQuadGeometryClippedByQuadF(
         quad->shared_quad_state->quad_to_target_transform, tile_rect,
         region_quad, uvs);
   }
+  return true;
 }
 
-void GLRenderer::DrawStreamVideoQuad(const StreamVideoDrawQuad* quad,
+bool GLRenderer::DrawStreamVideoQuad(const StreamVideoDrawQuad* quad,
                                      const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   DCHECK(output_surface_->context_provider()
              ->ContextCapabilities()
              .egl_image_external);
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, settings_->highp_threshold_min,
       quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
@@ skipping 20 matching lines @@
   } else {
     gfx::QuadF region_quad(*clip_region);
     region_quad.Scale(1.0f / quad->rect.width(), 1.0f / quad->rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     DrawQuadGeometryClippedByQuadF(
         quad->shared_quad_state->quad_to_target_transform,
         gfx::RectF(quad->rect), region_quad, uvs);
   }
+  return true;
 }
 
 void GLRenderer::FlushTextureQuadCache(BoundGeometry flush_binding) {
   // Check to see if we have anything to draw.
   if (draw_cache_.is_empty)
     return;
 
   PrepareGeometry(flush_binding);
 
   // Set the correct blending mode.
@@ skipping 74 matching lines @@
   draw_cache_.vertex_opacity_data.resize(0);
   draw_cache_.matrix_data.resize(0);
 
   // If we had a clipped binding, prepare the shared binding for the
   // next inserts.
   if (flush_binding == CLIPPED_BINDING) {
     PrepareGeometry(SHARED_BINDING);
   }
 }
 
-void GLRenderer::EnqueueTextureQuad(const TextureDrawQuad* quad,
+bool GLRenderer::EnqueueTextureQuad(const TextureDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
   // If we have a clip_region then we have to render the next quad
   // with dynamic geometry, therefore we must flush all pending
   // texture quads.
   if (clip_region) {
     // We send in false here because we want to flush what's currently in the
     // queue using the shared_geometry and not clipped_geometry
     FlushTextureQuadCache(SHARED_BINDING);
   }
 
@@ skipping 70 matching lines @@
     uv[0] = scaled_region.p1().x() + 0.5f;
     uv[1] = scaled_region.p1().y() + 0.5f;
     uv[2] = scaled_region.p2().x() + 0.5f;
     uv[3] = scaled_region.p2().y() + 0.5f;
     uv[4] = scaled_region.p3().x() + 0.5f;
     uv[5] = scaled_region.p3().y() + 0.5f;
     uv[6] = scaled_region.p4().x() + 0.5f;
     uv[7] = scaled_region.p4().y() + 0.5f;
     PrepareGeometry(CLIPPED_BINDING);
     clipped_geometry_->InitializeCustomQuadWithUVs(scaled_region, uv);
+    if (draw_cache_.is_empty)
+      return false;
     FlushTextureQuadCache(CLIPPED_BINDING);
   } else if (gl_composited_texture_quad_border_) {
+    if (draw_cache_.is_empty)
+      return false;
     FlushTextureQuadCache(SHARED_BINDING);
+  } else {
+    return false;
   }
+  return true;
 }
 
 void GLRenderer::FinishDrawingFrame() {
   if (use_sync_query_) {
     DCHECK(current_sync_query_);
     current_sync_query_->End();
     pending_sync_queries_.push_back(std::move(current_sync_query_));
   }
 
   swap_buffer_rect_.Union(current_frame()->root_damage_rect);
   if (overdraw_feedback_)
     FlushOverdrawFeedback(swap_buffer_rect_);
 
   if (use_swap_with_bounds_)
     swap_content_bounds_ = current_frame()->root_content_bounds;
 
   current_framebuffer_lock_ = nullptr;
 
   gl_->Disable(GL_BLEND);
   blend_shadow_ = false;
 
   ScheduleCALayers();
   ScheduleDCLayers();
   ScheduleOverlays();
 }
 
 void GLRenderer::FinishDrawingQuadList() {
   FlushTextureQuadCache(SHARED_BINDING);
+  size_t area_total = surface_size_for_swap_buffers().GetArea();
+  if (area_total) {
+    LOG(ERROR) << "Total drawn: " << area_drawn_ << " vs. " << area_total
+               << " = " << static_cast<float>(area_drawn_) / area_total;
+  }
+  area_drawn_ = 0;
 }
 
 void GLRenderer::SetEnableDCLayers(bool enable) {
   gl_->SetEnableDCLayersCHROMIUM(enable);
 }
 
 bool GLRenderer::FlippedFramebuffer() const {
   if (force_drawing_frame_framebuffer_unflipped_)
     return false;
   if (current_frame()->current_render_pass != current_frame()->root_render_pass)
@@ skipping 1123 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc