Preliminary compositor disabling patch.

cc/surfaces/surface_aggregator.cc

 // Copyright 2014 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/surfaces/surface_aggregator.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 225 matching lines @@
   for (size_t j = 0; j < passes_to_copy; ++j) {
     const RenderPass& source = *referenced_passes[j];
 
     size_t sqs_size = source.shared_quad_state_list.size();
     size_t dq_size = source.quad_list.size();
     scoped_ptr<RenderPass> copy_pass(RenderPass::Create(sqs_size, dq_size));
 
     RenderPassId remapped_pass_id = RemapPassId(source.id, surface_id);
 
     copy_pass->SetAll(remapped_pass_id, source.output_rect, gfx::Rect(),
-                      source.transform_to_root_target,
+                      gfx::Rect(), source.transform_to_root_target,
                       source.has_transparent_background);
 
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
     // Contributing passes aggregated in to the pass list need to take the
     // transform of the surface quad into account to update their transform to
     // the root surface.
     copy_pass->transform_to_root_target.ConcatTransform(
         surface_quad->quadTransform());
     copy_pass->transform_to_root_target.ConcatTransform(
@@ skipping 21 matching lines @@
     // Intersect the transformed visible rect and the clip rect to create a
     // smaller cliprect for the quad.
     ClipData surface_quad_clip_rect(
         true, MathUtil::MapEnclosingClippedRect(surface_quad->quadTransform(),
                                                 surface_quad->visible_rect));
     if (surface_quad->isClipped())
       surface_quad_clip_rect.rect.Intersect(surface_quad->clipRect());
 
     ClipData quads_clip = CalculateClipRect(clip_rect, surface_quad_clip_rect,
                                             content_to_target_transform);
+    dest_pass->overlay_rect = MathUtil::MapEnclosingClippedRect(
+        surface_quad->quadTransform(), last_pass.overlay_rect);
 
     CopyQuadsToPass(quads, last_pass.shared_quad_state_list, surface_transform,
                     quads_clip, dest_pass, surface_id);
   } else {
     RenderPassId remapped_pass_id = RemapPassId(last_pass.id, surface_id);
 
     CopySharedQuadState(surface_quad->shared_quad_state,
                         content_to_target_transform, clip_rect, dest_pass);
 
     SharedQuadState* shared_quad_state =
@@ skipping 122 matching lines @@
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
     RenderPassId remapped_pass_id =
         RemapPassId(source.id, surface->surface_id());
 
     gfx::Rect damage_rect =
         (i < source_pass_list.size() - 1)
             ? gfx::Rect()
             : DamageRectForSurface(surface, source, source.output_rect);
     copy_pass->SetAll(remapped_pass_id, source.output_rect, damage_rect,
-                      source.transform_to_root_target,
+                      source.overlay_rect, source.transform_to_root_target,
                       source.has_transparent_background);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
                     gfx::Transform(), ClipData(), copy_pass.get(),
                     surface->surface_id());
 
     dest_pass_list_->push_back(copy_pass.Pass());
   }
 }
 
@@ skipping 63 matching lines @@
 void SurfaceAggregator::ReleaseResources(SurfaceId surface_id) {
   SurfaceToResourceChildIdMap::iterator it =
       surface_id_to_resource_child_id_.find(surface_id);
   if (it != surface_id_to_resource_child_id_.end()) {
     provider_->DestroyChild(it->second);
     surface_id_to_resource_child_id_.erase(it);
   }
 }
 
 }  // namespace cc