Allow switching DirectCompositionSurfaceWin between drawing modes.

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>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/bsp_tree.h"
 #include "cc/output/bsp_walk_action.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/renderer_settings.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/resources/scoped_resource.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
+namespace {
+
 static gfx::Transform OrthoProjectionMatrix(float left,
                                             float right,
                                             float bottom,
                                             float top) {
   // Use the standard formula to map the clipping frustum to the cube from
   // [-1, -1, -1] to [1, 1, 1].
   float delta_x = right - left;
   float delta_y = top - bottom;
   gfx::Transform proj;
   if (!delta_x || !delta_y)
@@ skipping 17 matching lines @@
   canvas.Translate3d(x, y, 0);
   canvas.Scale3d(width, height, 0);
 
   // Map from ([-1, -1] to [1, 1]) -> ([0, 0] to [1, 1])
   canvas.Translate3d(0.5, 0.5, 0.5);
   canvas.Scale3d(0.5, 0.5, 0.5);
 
   return canvas;
 }
 
+// Switching between enabling DC layers and not is expensive, so only
+// switch away after a large number of frames not needing DC layers have
+// been produced.
+constexpr int kNumberOfFramesBeforeDisablingDCLayers = 60;
+
+}  // namespace
+
 namespace cc {
 
 DirectRenderer::DrawingFrame::DrawingFrame() = default;
 DirectRenderer::DrawingFrame::~DrawingFrame() = default;
 
 DirectRenderer::DirectRenderer(const RendererSettings* settings,
                                OutputSurface* output_surface,
                                ResourceProvider* resource_provider)
     : settings_(settings),
       output_surface_(output_surface),
       resource_provider_(resource_provider),
       overlay_processor_(new OverlayProcessor(output_surface)) {}
 
 DirectRenderer::~DirectRenderer() = default;
 
 void DirectRenderer::Initialize() {
   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) {
     if (context_provider->ContextCapabilities().commit_overlay_planes)
       allow_empty_swap_ = true;
-    if (context_provider->ContextCapabilities().set_draw_rectangle)
-      use_set_draw_rectangle_ = true;
+    if (context_provider->ContextCapabilities().dc_layers)
+      supports_dc_layers_ = true;
   }
 
   initialized_ = true;
 }
 
 // static
 gfx::RectF DirectRenderer::QuadVertexRect() {
   return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f);
 }
 
@@ skipping 205 matching lines @@
 
   // Attempt to replace some or all of the quads of the root render pass with
   // overlays.
   overlay_processor_->ProcessForOverlays(
       resource_provider_, root_render_pass, render_pass_filters_,
       render_pass_background_filters_, &current_frame()->overlay_list,
       &current_frame()->ca_layer_overlay_list,
       &current_frame()->dc_layer_overlay_list,
       &current_frame()->root_damage_rect,
       &current_frame()->root_content_bounds);
+  bool was_using_dc_layers = using_dc_layers_;
+  if (!current_frame()->dc_layer_overlay_list.empty()) {
+    DCHECK(supports_dc_layers_);
+    using_dc_layers_ = true;
+    frames_since_using_dc_layers_ = 0;
+  } else if (++frames_since_using_dc_layers_ >=
+             kNumberOfFramesBeforeDisablingDCLayers) {
+    using_dc_layers_ = false;
+  }
+  if (was_using_dc_layers != using_dc_layers_) {
+    current_frame()->root_damage_rect =
+        current_frame()->root_render_pass->output_rect;
+  }
 
   // We can skip all drawing if the damage rect is now empty.
   bool skip_drawing_root_render_pass =
       current_frame()->root_damage_rect.IsEmpty() && allow_empty_swap_;
 
   // If we have to draw but don't support partial swap, the whole output should
   // be considered damaged.
   if (!skip_drawing_root_render_pass && !use_partial_swap_)
     current_frame()->root_damage_rect = root_render_pass->output_rect;
 
@@ skipping 189 matching lines @@
   }
 
   bool is_root_render_pass =
       current_frame()->current_render_pass == current_frame()->root_render_pass;
 
   // The SetDrawRectangleCHROMIUM spec requires that the scissor bit is always
   // set on the root framebuffer or else the rendering may modify something
   // outside the damage rectangle, even if the damage rectangle is the size of
   // the full backbuffer.
   bool render_pass_is_clipped =
-      (use_set_draw_rectangle_ && is_root_render_pass) ||
+      (supports_dc_layers_ && is_root_render_pass) ||
       !render_pass_scissor_in_draw_space.Contains(surface_rect_in_draw_space);
   bool has_external_stencil_test =
       is_root_render_pass && output_surface_->HasExternalStencilTest();
   bool should_clear_surface =
       !has_external_stencil_test &&
       (!is_root_render_pass || settings_->should_clear_root_render_pass);
 
   // If |has_external_stencil_test| we can't discard or clear. Make sure we
   // don't need to.
   DCHECK(!has_external_stencil_test ||
@@ skipping 53 matching lines @@
                 render_pass_is_clipped);
   FinishDrawingQuadList();
 }
 
 bool DirectRenderer::UseRenderPass(const RenderPass* render_pass) {
   current_frame()->current_render_pass = render_pass;
   current_frame()->current_texture = nullptr;
   if (render_pass == current_frame()->root_render_pass) {
     BindFramebufferToOutputSurface();
 
-    if (use_set_draw_rectangle_)
+    if (supports_dc_layers_) {
+      SetEnableDCLayers(using_dc_layers_);
       output_surface_->SetDrawRectangle(current_frame()->root_damage_rect);
+    }
     InitializeViewport(current_frame(), render_pass->output_rect,
                        gfx::Rect(current_frame()->device_viewport_size),
                        current_frame()->device_viewport_size);
     return true;
   }
 
   ScopedResource* texture = render_pass_textures_[render_pass->id].get();
   DCHECK(texture);
 
   gfx::Size size = RenderPassTextureSize(render_pass);
@@ skipping 25 matching lines @@
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 void DirectRenderer::SetCurrentFrameForTesting(const DrawingFrame& frame) {
   current_frame_valid_ = true;
   current_frame_ = frame;
 }
 
 }  // namespace cc