Preliminary compositor disabling patch.

cc/quads/render_pass.cc

 // Copyright 2011 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/quads/render_pass.h"
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/checkerboard_draw_quad.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/largest_draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
+#include "ui/gfx/geometry/rect_conversions.h"
 
 namespace {
 const size_t kDefaultNumSharedQuadStatesToReserve = 32;
 const size_t kDefaultNumQuadsToReserve = 128;
 }
 
 namespace cc {
 
 QuadList::QuadList(size_t default_size_to_reserve)
     : ListContainer<DrawQuad>(LargestDrawQuadSize(), default_size_to_reserve) {
@@ skipping 41 matching lines @@
 
 RenderPass::~RenderPass() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
       "cc::RenderPass", id.AsTracingId());
 }
 
 scoped_ptr<RenderPass> RenderPass::Copy(RenderPassId new_id) const {
   scoped_ptr<RenderPass> copy_pass(
       Create(shared_quad_state_list.size(), quad_list.size()));
-  copy_pass->SetAll(new_id,
-                    output_rect,
-                    damage_rect,
-                    transform_to_root_target,
-                    has_transparent_background);
+  copy_pass->SetAll(new_id, output_rect, damage_rect, overlay_rect,
+                    transform_to_root_target, has_transparent_background);
   return copy_pass.Pass();
 }
 
 // static
 void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
                          ScopedPtrVector<RenderPass>* out) {
   for (size_t i = 0; i < in.size(); ++i) {
     RenderPass* source = in[i];
 
     // Since we can't copy these, it's wrong to use CopyAll in a situation where
     // you may have copy_requests present.
     DCHECK_EQ(source->copy_requests.size(), 0u);
 
     scoped_ptr<RenderPass> copy_pass(Create(
         source->shared_quad_state_list.size(), source->quad_list.size()));
-    copy_pass->SetAll(source->id,
-                      source->output_rect,
-                      source->damage_rect,
-                      source->transform_to_root_target,
+    copy_pass->SetAll(source->id, source->output_rect, source->damage_rect,
+                      source->overlay_rect, source->transform_to_root_target,
                       source->has_transparent_background);
     for (const auto& shared_quad_state : source->shared_quad_state_list) {
       SharedQuadState* copy_shared_quad_state =
           copy_pass->CreateAndAppendSharedQuadState();
       copy_shared_quad_state->CopyFrom(shared_quad_state);
     }
     SharedQuadStateList::Iterator sqs_iter =
         source->shared_quad_state_list.begin();
     SharedQuadStateList::Iterator copy_sqs_iter =
         copy_pass->shared_quad_state_list.begin();
@@ skipping 35 matching lines @@
   this->damage_rect = damage_rect;
   this->transform_to_root_target = transform_to_root_target;
 
   DCHECK(quad_list.empty());
   DCHECK(shared_quad_state_list.empty());
 }
 
 void RenderPass::SetAll(RenderPassId id,
                         const gfx::Rect& output_rect,
                         const gfx::Rect& damage_rect,
+                        const gfx::Rect& overlay_rect,
                         const gfx::Transform& transform_to_root_target,
                         bool has_transparent_background) {
   DCHECK_GT(id.layer_id, 0);
   DCHECK_GE(id.index, 0);
 
   this->id = id;
   this->output_rect = output_rect;
   this->damage_rect = damage_rect;
+  this->overlay_rect = overlay_rect;
   this->transform_to_root_target = transform_to_root_target;
   this->has_transparent_background = has_transparent_background;
 
   DCHECK(quad_list.empty());
   DCHECK(shared_quad_state_list.empty());
 }
 
 void RenderPass::AsValueInto(base::trace_event::TracedValue* value) const {
   MathUtil::AddToTracedValue("output_rect", output_rect, value);
   MathUtil::AddToTracedValue("damage_rect", damage_rect, value);
+  MathUtil::AddToTracedValue("overlay_rect", overlay_rect, value);
 
   value->SetBoolean("has_transparent_background", has_transparent_background);
   value->SetInteger("copy_requests", copy_requests.size());
 
   value->BeginArray("shared_quad_state_list");
   for (const auto& shared_quad_state : shared_quad_state_list) {
     value->BeginDictionary();
     shared_quad_state->AsValueInto(value);
     value->EndDictionary();
   }
@@ skipping 66 matching lines @@
     // RenderPass quads need to use specific CopyFrom function.
     case DrawQuad::RENDER_PASS:
     case DrawQuad::INVALID:
       LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
       break;
   }
   quad_list.back()->shared_quad_state = shared_quad_state;
   return quad_list.back();
 }
 
+gfx::Rect RenderPass::GetFullDamageRect() {
+  return gfx::UnionRects(damage_rect, overlay_rect);
+}
+
+void RenderPass::RecalculateOverlayDamage() {

[danakj, 2015/04/03 22:10:17]

I don't like us computing damage inside RenderPass. I think all damage should be
computed during via DamageTracker. If it needs to output multiple damage rects
(surface_damage_rect, overlay_damage_rects[]) that's okay, but I want them to
all be computed there.

From looking at this code, it sounds like one overlay rect would be enough so
damage tracker would just need to output 2 rects?

This could also remove the overlay_damage_rect from LayerImpl? DamageTracker
would get some bools from layers about overlays as needed and put rects in the
right places. Duplicating the damage rect on LayerImpl seems like the wrong
place too.

[achaulk, 2015/04/03 23:41:28]

We would at least need to be able to do it after modifying the quad list during
the overlay path. This plus the initial call to calculate it are the only places
its done.

If we have lists of damage rects then we need to associate quads with the
specific damage rect in the renderpass which feels awkward too

+  gfx::Rect new_rect;
+  for (const auto* draw_quad : quad_list) {
+    if (draw_quad->damaged) {
+      gfx::RectF rect = gfx::RectF(draw_quad->visible_rect);
+      draw_quad->quadTransform().TransformRect(&rect);
+      new_rect.Union(gfx::ToEnclosingRect(rect));
+    }
+  }
+  overlay_rect = gfx::IntersectRects(output_rect, new_rect);
+}
+
+void RenderPass::UnionOverlayDamage() {
+  damage_rect.Union(overlay_rect);

[danakj, 2015/04/03 22:10:17]

Not a fan of mutating RenderPass after construction like this. But I think this
falls into the above comment.

[achaulk, 2015/04/07 18:53:00]

I'll see how much of it I can put into the damage tracker

+  overlay_rect = gfx::Rect();
+}
+
 }  // namespace cc