Use IDCompositionSurface to implement DirectCompositionSurfaceWin.

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 66 matching lines @@
 
 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 &&
-      context_provider->ContextCapabilities().commit_overlay_planes)
-    allow_empty_swap_ = true;
+  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;
+  }
 
   initialized_ = true;
 }
 
 // static
 gfx::RectF DirectRenderer::QuadVertexRect() {
   return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f);
 }
 
 // static
@@ skipping 403 matching lines @@
       current_frame()->root_render_pass) {
     render_pass_scissor_in_draw_space.Intersect(
         DeviceViewportRectInDrawSpace());
   }
 
   if (use_partial_swap_) {
     render_pass_scissor_in_draw_space.Intersect(
         current_frame()->ComputeScissorRectForRenderPass());
   }
 
-  bool render_pass_is_clipped =
-      !render_pass_scissor_in_draw_space.Contains(surface_rect_in_draw_space);
   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) ||
+      !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 ||
          !current_frame()->current_render_pass->has_transparent_background);
@@ skipping 48 matching lines @@
 
     DoDrawQuad(&quad, nullptr);
   }
   FlushPolygons(&poly_list, render_pass_scissor_in_draw_space,
                 render_pass_is_clipped);
   FinishDrawingQuadList();
 }
 
 bool DirectRenderer::UseRenderPass(const RenderPass* render_pass) {
   current_frame()->current_render_pass = render_pass;
-  current_frame()->current_texture = NULL;
+  current_frame()->current_texture = nullptr;
   if (render_pass == current_frame()->root_render_pass) {
     BindFramebufferToOutputSurface();
+
+    if (use_set_draw_rectangle_)
+      output_surface_->SetDrawRectangle(current_frame()->root_damage_rect);

[danakj, 2017/02/22 15:04:08]

Is this guaranteed to be the full surface if the surface size changed?

     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