cc: Implement overdraw feedback debugging feature.

cc/output/direct_renderer.cc

 // Copyright 2012 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/direct_renderer.h"
 
 #include <stddef.h>
 
 #include <unordered_map>
 #include <utility>
@@ skipping 69 matching lines @@
   overlay_processor_->Initialize();
 
   auto* context_provider = output_surface_->context_provider();
 
   use_partial_swap_ = settings_->partial_swap_enabled && CanPartialSwap();
   allow_empty_swap_ = use_partial_swap_;
   if (context_provider &&
       context_provider->ContextCapabilities().commit_overlay_planes)
     allow_empty_swap_ = true;
 
+  LOG_IF(WARNING, settings_->show_overdraw_feedback &&

[danakj, 2017/01/12 00:42:57]

use DLOG_IF instead.

why doesn't this happen for tracing path too?

[reveman, 2017/01/13 01:27:42]

Done.
Tracing is turned on/off so it would need to be logged every frame or we'd need
some more complicated mechanism to handle that. Overdraw trace counter just not
showing up in traces when not supported is fine imo. Someone enabling visual
feedback in about:flags but nothing happens is more surprising so I figured that
might deserve a LOG statement.

[danakj, 2017/01/16 16:22:01]

What about just a simple static bool? It's okay to only report once per process.

[reveman, 2017/01/16 18:02:26]

Done. Although "call once" execution of code using a static bool without a
subtle race condition is not pretty imo. Happy to change it to use
std::call_once if that's OK with you?

[danakj, 2017/01/16 18:17:52]

What race are you worried about, DirectRenderer being used on multiple threads
in the same process? There's no place that happens right? Maybe put a static
thread-checker that runs in debug mode only if you're worried about it. I'd
rather debug-only verify this than use more complicated code for a whatif. wdyt?

[reveman, 2017/01/16 22:46:18]

I'd rather not introduce the assumption that this class is never instantiated on
more than one thread just for this debugging feature and this log statement. I
changed the code to use a member variable in latest patch. I can continue to
propose alternatives until we find one that we're both happy with but we might
be overthinking this as it's really just a log statement for a debug feature.

+                      !output_surface_->capabilities().supports_stencil)
+      << "Overdraw feedback enabled without output surface stencil support.";

[danakj, 2017/01/12 00:42:57]

This error is pretty vague, I think it might be nicer to say on a platform
without support? WDYT? Also if you disable GPU you lose this.. I guess that's
not feasible to do there, not sure if we can include that in the error?

[reveman, 2017/01/13 01:27:42]

Makes sense. Done.

+
   initialized_ = true;
 }
 
 // static
 gfx::RectF DirectRenderer::QuadVertexRect() {
   return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f);
 }
 
 // static
 void DirectRenderer::QuadRectTransform(gfx::Transform* quad_rect_transform,
@@ skipping 118 matching lines @@
                                const gfx::Size& device_viewport_size) {
   DCHECK(visible_);
   TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
   UMA_HISTOGRAM_COUNTS(
       "Renderer4.renderPassCount",
       base::saturated_cast<int>(render_passes_in_draw_order->size()));
 
   RenderPass* root_render_pass = render_passes_in_draw_order->back().get();
   DCHECK(root_render_pass);
 
+  bool overdraw_tracing_enabled;
+  TRACE_EVENT_CATEGORY_GROUP_ENABLED(
+      TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"),
+      &overdraw_tracing_enabled);
+  overdraw_feedback_ =
+      (settings_->show_overdraw_feedback || overdraw_tracing_enabled) &&
+      output_surface_->capabilities().supports_stencil;
+
   DrawingFrame frame;
   frame.render_passes_in_draw_order = render_passes_in_draw_order;
   frame.root_render_pass = root_render_pass;
   frame.root_damage_rect = root_render_pass->damage_rect;
   frame.root_damage_rect.Union(overlay_processor_->GetAndResetOverlayDamage());
   frame.root_damage_rect.Intersect(gfx::Rect(device_viewport_size));
   frame.device_viewport_size = device_viewport_size;
   frame.device_color_space = device_color_space;
 
   // Only reshape when we know we are going to draw. Otherwise, the reshape
   // can leave the window at the wrong size if we never draw and the proper
   // viewport size is never set.
   bool frame_has_alpha = frame.root_render_pass->has_transparent_background;
+  bool use_stencil = overdraw_feedback_;
   if (device_viewport_size != reshape_surface_size_ ||
       device_scale_factor != reshape_device_scale_factor_ ||
       device_color_space != reshape_device_color_space_ ||
-      frame_has_alpha != reshape_has_alpha_) {
+      frame_has_alpha != reshape_has_alpha_ ||
+      use_stencil != reshape_use_stencil_) {
     reshape_surface_size_ = device_viewport_size;
     reshape_device_scale_factor_ = device_scale_factor;
     reshape_device_color_space_ = device_color_space;
     reshape_has_alpha_ = frame.root_render_pass->has_transparent_background;
-    output_surface_->Reshape(reshape_surface_size_,
-                             reshape_device_scale_factor_,
-                             reshape_device_color_space_, reshape_has_alpha_);
+    reshape_use_stencil_ = overdraw_feedback_;
+    output_surface_->Reshape(
+        reshape_surface_size_, reshape_device_scale_factor_,
+        reshape_device_color_space_, reshape_has_alpha_, reshape_use_stencil_);
   }
 
   BeginDrawingFrame(&frame);
 
   for (const auto& pass : *render_passes_in_draw_order) {
     if (!pass->filters.IsEmpty())
       render_pass_filters_.push_back(std::make_pair(pass->id, &pass->filters));
     if (!pass->background_filters.IsEmpty()) {
       render_pass_background_filters_.push_back(
           std::make_pair(pass->id, &pass->background_filters));
@@ skipping 346 matching lines @@
   auto iter = render_pass_textures_.find(render_pass_id);
   return iter != render_pass_textures_.end() && iter->second->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc