Preliminary compositor disabling patch.

cc/quads/render_pass.cc

Index: cc/quads/render_pass.cc
diff --git a/cc/quads/render_pass.cc b/cc/quads/render_pass.cc
index 567145a82d6d12565c6a835aef264d32ba94ab9c..4a7dc53a000e1c0a969641ccbaa8b3f658cb0027 100644
--- a/cc/quads/render_pass.cc
+++ b/cc/quads/render_pass.cc
@@ -25,6 +25,7 @@
 #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;
@@ -86,11 +87,8 @@ RenderPass::~RenderPass() {
 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();
 }
 
@@ -106,10 +104,8 @@ void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
 
     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 =
@@ -165,6 +161,7 @@ void RenderPass::SetNew(RenderPassId id,
 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);
@@ -173,6 +170,7 @@ void RenderPass::SetAll(RenderPassId id,
   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;
 
@@ -183,6 +181,7 @@ void RenderPass::SetAll(RenderPassId id,
 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());
@@ -269,4 +268,25 @@ DrawQuad* RenderPass::CopyFromAndAppendDrawQuad(
   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