Preliminary compositor disabling patch.

cc/trees/damage_tracker.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/trees/damage_tracker.h"
 
 #include <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
@@ skipping 107 matching lines @@
   //
   //      3. After the damage rect is computed, the leftover not marked regions
   //         in a map are used to compute are damaged by deleted layers and
   //         erased from map.
   //
 
   PrepareRectHistoryForUpdate();
   // These functions cannot be bypassed with early-exits, even if we know what
   // the damage will be for this frame, because we need to update the damage
   // tracker state to correctly track the next frame.
-  gfx::Rect damage_from_active_layers =
-      TrackDamageFromActiveLayers(layer_list, target_surface_layer_id);
+  gfx::Rect damage_from_active_layers;
+  TrackDamageFromActiveLayers(layer_list, target_surface_layer_id,
+                              &damage_from_active_layers,
+                              &current_overlay_rect_);
   gfx::Rect damage_from_surface_mask =
       TrackDamageFromSurfaceMask(target_surface_mask_layer);
   gfx::Rect damage_from_leftover_rects = TrackDamageFromLeftoverRects();
 
   gfx::Rect damage_rect_for_this_update;
 
   if (target_surface_property_changed_only_from_descendant) {
     damage_rect_for_this_update = target_surface_content_rect;
   } else {
     // TODO(shawnsingh): can we clamp this damage to the surface's content rect?
@@ skipping 26 matching lines @@
     rect_history_.end(), data);
 
   if (it == rect_history_.end() || it->layer_id_ != layer_id) {
     *layer_is_new = true;
     it = rect_history_.insert(it, data);
   }
 
   return *it;
 }
 
-gfx::Rect DamageTracker::TrackDamageFromActiveLayers(
-    const LayerImplList& layer_list,
-    int target_surface_layer_id) {
+void DamageTracker::TrackDamageFromActiveLayers(const LayerImplList& layer_list,
+                                                int target_surface_layer_id,
+                                                gfx::Rect* damage,
+                                                gfx::Rect* overlay) {
   gfx::Rect damage_rect;
 
   for (size_t layer_index = 0; layer_index < layer_list.size(); ++layer_index) {
     // Visit layers in back-to-front order.
     LayerImpl* layer = layer_list[layer_index];
 
     // We skip damage from the HUD layer because (a) the HUD layer damages the
     // whole frame and (b) we don't want HUD layer damage to be shown by the
     // HUD damage rect visualization.
     if (layer == layer->layer_tree_impl()->hud_layer())
       continue;
     if (LayerTreeHostCommon::RenderSurfaceContributesToTarget<LayerImpl>(
             layer, target_surface_layer_id))
-      ExtendDamageForRenderSurface(layer, &damage_rect);
+      ExtendDamageForRenderSurface(layer, damage);
     else
-      ExtendDamageForLayer(layer, &damage_rect);
+      ExtendDamageForLayer(layer, damage, overlay);
   }
-
-  return damage_rect;
 }
 
 gfx::Rect DamageTracker::TrackDamageFromSurfaceMask(
     LayerImpl* target_surface_mask_layer) {
   gfx::Rect damage_rect;
 
   if (!target_surface_mask_layer)
     return damage_rect;
 
   // Currently, if there is any change to the mask, we choose to damage the
@@ skipping 45 matching lines @@
     rect_history_.erase(copy_pos, rect_history_.end());
 
   // If the vector has excessive storage, shrink it
   if (rect_history_.capacity() > rect_history_.size() * 4)
     SortedRectMap(rect_history_).swap(rect_history_);
 
   return damage_rect;
 }
 
 void DamageTracker::ExtendDamageForLayer(LayerImpl* layer,
-                                         gfx::Rect* target_damage_rect) {
+                                         gfx::Rect* target_damage_rect,
+                                         gfx::Rect* target_overlay_rect) {
   // There are two ways that a layer can damage a region of the target surface:
   //   1. Property change (e.g. opacity, position, transforms):
   //        - the entire region of the layer itself damages the surface.
   //        - the old layer region also damages the surface, because this region
   //          is now exposed.
   //        - note that in many cases the old and new layer rects may overlap,
   //          which is fine.
   //
   //   2. Repaint/update: If a region of the layer that was repainted/updated,
   //      that region damages the surface.
   //
   // Property changes take priority over update rects.
   //
   // This method is called when we want to consider how a layer contributes to
   // its target RenderSurface, even if that layer owns the target RenderSurface
   // itself. To consider how a layer's target surface contributes to the
   // ancestor surface, ExtendDamageForRenderSurface() must be called instead.
 
   bool layer_is_new = false;
   RectMapData& data = RectDataForLayer(layer->id(), &layer_is_new);
   gfx::Rect old_rect_in_target_space = data.rect_;
 
   gfx::Rect rect_in_target_space = layer->GetEnclosingRectInTargetSpace();
   data.Update(rect_in_target_space, mailboxId_);
 
   gfx::RectF damage_rect =
       gfx::UnionRects(layer->update_rect(), layer->damage_rect());
 
+  target_overlay_rect->Union(layer->overlay_update_rect());
   if (layer_is_new || layer->LayerPropertyChanged()) {
     // If a layer is new or has changed, then its entire layer rect affects the
     // target surface.
     target_damage_rect->Union(rect_in_target_space);
 
     // The layer's old region is now exposed on the target surface, too.
     // Note old_rect_in_target_space is already in target space.
     target_damage_rect->Union(old_rect_in_target_space);
   } else if (!damage_rect.IsEmpty()) {
     // If the layer properties haven't changed, then the the target surface is
@@ skipping 93 matching lines @@
   // one in them. This means we need to redraw any pixels in the surface being
   // used for the blur in this layer this frame.
   if (layer->background_filters().HasFilterThatMovesPixels()) {
     ExpandDamageRectInsideRectWithFilters(target_damage_rect,
                                           surface_rect_in_target_space,
                                           layer->background_filters());
   }
 }
 
 }  // namespace cc