cc: Remove all impl-side caps from RendererCapabilitiesImpl.

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 54 matching lines @@
 
 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)) {
-  // TODO(danakj): This should not be happening in the constructor.
-  overlay_processor_->Initialize();
-}
+      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();

[danakj, 2016/08/17 02:06:43]

This is a behaviour change. What it changed is that if
LayerTreeSettings::partial_swap_enabled = false, then we won't use partial swap
for software compositing (as demonstrated by a unit test change also to set the
setting to true). ui::Compositor is the only place that we have a Display that
does software compositing, and it sets it to true so that should be fine, and
making --ui-disable-partial-swap work for software too seems pretty reasonable?

[enne (OOO), 2016/08/17 17:48:42]

Yeah, this sounds good to me.  We've had a bunch of partial swap issues over
time and being able to have a flag that makes it easy to know when that's the
case even in software seems great.

+  allow_empty_swap_ = use_partial_swap_;
+  if (context_provider &&
+      context_provider->ContextCapabilities().commit_overlay_planes)
+    allow_empty_swap_ = 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,
                                        const gfx::Transform& quad_transform,
                                        const gfx::RectF& quad_rect) {
   *quad_rect_transform = quad_transform;
@@ skipping 162 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, &frame.overlay_list,
       &frame.ca_layer_overlay_list, &frame.root_damage_rect);
 
   // We can skip all drawing if the damage rect is now empty.
   bool skip_drawing_root_render_pass =
-      frame.root_damage_rect.IsEmpty() && Capabilities().allow_empty_swap;
+      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 && !Capabilities().using_partial_swap)
+  if (!skip_drawing_root_render_pass && !use_partial_swap_)
     frame.root_damage_rect = root_render_pass->output_rect;
 
   if (skip_drawing_root_render_pass) {
     // If any of the overlays is the output surface, then ensure that the
     // backbuffer be allocated (allocation of the backbuffer is a side-effect
     // of BindFramebufferToOutputSurface).
     for (auto& overlay : frame.overlay_list) {
       if (overlay.use_output_surface_for_resource) {
         BindFramebufferToOutputSurface(&frame);
         break;
@@ skipping 165 matching lines @@
 
   const gfx::Rect surface_rect_in_draw_space =
       OutputSurfaceRectInDrawSpace(frame);
   gfx::Rect render_pass_scissor_in_draw_space = surface_rect_in_draw_space;
 
   if (frame->current_render_pass == frame->root_render_pass) {
     render_pass_scissor_in_draw_space.Intersect(
         DeviceViewportRectInDrawSpace(frame));
   }
 
-  if (Capabilities().using_partial_swap) {
+  if (use_partial_swap_) {
     render_pass_scissor_in_draw_space.Intersect(
         ComputeScissorRectForRenderPass(frame));
   }
 
   if (NeedDeviceClip(frame)) {
     render_pass_scissor_in_draw_space.Intersect(
         DeviceClipRectInDrawSpace(frame));
   }
 
   bool render_pass_is_clipped =
@@ skipping 108 matching lines @@
   auto iter = render_pass_textures_.find(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