Force use of and cache render surface.

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 <stddef.h>
 
 #include <algorithm>
 
 #include "base/memory/ptr_util.h"
 #include "cc/base/filter_operations.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 std::unique_ptr<DamageTracker> DamageTracker::Create() {
   return base::WrapUnique(new DamageTracker());
 }
 
-DamageTracker::DamageTracker()
-  : mailboxId_(0) {}
+DamageTracker::DamageTracker() : mailboxId_(0) {}
 
 DamageTracker::~DamageTracker() {}
 
 void DamageTracker::UpdateDamageTracking(
     LayerTreeImpl* layer_tree_impl,
     const RenderSurfaceList& render_surface_list) {
   //
   // This function computes the "damage rect" of each target surface, and
   // updates the state that is used to correctly track damage across frames. The
   // damage rect is the region of the surface that may have changed and needs to
@@ skipping 128 matching lines @@
   // All damage from contributing layers and surfaces must already have been
   // added to damage_for_this_update_ through calls to AccumulateDamageFromLayer
   // and AccumulateDamageFromRenderSurface.
 
   // 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.
   DamageAccumulator damage_from_surface_mask =
       TrackDamageFromSurfaceMask(render_surface->MaskLayer());
   DamageAccumulator damage_from_leftover_rects = TrackDamageFromLeftoverRects();
+  // True if any layer is removed.
+  has_damage_from_contributing_content_ |=
+      !damage_from_leftover_rects.IsEmpty();
 
   if (render_surface->SurfacePropertyChangedOnlyFromDescendant()) {
     damage_for_this_update_ = DamageAccumulator();
     damage_for_this_update_.Union(render_surface->content_rect());
+    // True if there is surface property change from descendant.
+    has_damage_from_contributing_content_ |= !damage_for_this_update_.IsEmpty();
   } else {
     // TODO(shawnsingh): can we clamp this damage to the surface's content rect?
     // (affects performance, but not correctness)
     damage_for_this_update_.Union(damage_from_surface_mask);
     damage_for_this_update_.Union(damage_from_leftover_rects);
 
     gfx::Rect damage_rect;
     bool is_rect_valid = damage_for_this_update_.GetAsRect(&damage_rect);
     if (is_rect_valid) {
       damage_rect = render_surface->Filters().MapRect(
@@ skipping 59 matching lines @@
       !target_surface_mask_layer->update_rect().IsEmpty()) {
     damage.Union(gfx::Rect(target_surface_mask_layer->bounds()));
   }
 
   return damage;
 }
 
 void DamageTracker::PrepareForUpdate() {
   mailboxId_++;
   damage_for_this_update_ = DamageAccumulator();
+  has_damage_from_contributing_content_ = false;
 }
 
 DamageTracker::DamageAccumulator DamageTracker::TrackDamageFromLeftoverRects() {
   // After computing damage for all active layers, any leftover items in the
   // current rect history correspond to layers/surfaces that no longer exist.
   // So, these regions are now exposed on the target surface.
 
   DamageAccumulator damage;
   SortedRectMapForLayers::iterator layer_cur_pos =
       rect_history_for_layers_.begin();
@@ skipping 86 matching lines @@
   //
   //   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;
   LayerRectMapData& 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_);
 
   if (layer_is_new || layer->LayerPropertyChanged()) {
     // If a layer is new or has changed, then its entire layer rect affects the
     // target surface.
     damage_for_this_update_.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.
     damage_for_this_update_.Union(old_rect_in_target_space);
-    return;
+  } else {
+    // If the layer properties haven't changed, then the the target surface is
+    // only affected by the layer's damaged area, which could be empty.
+    gfx::Rect damage_rect =
+        gfx::UnionRects(layer->update_rect(), layer->damage_rect());
+    damage_rect.Intersect(gfx::Rect(layer->bounds()));
+
+    if (!damage_rect.IsEmpty()) {
+      gfx::Rect damage_rect_in_target_space = MathUtil::MapEnclosingClippedRect(
+          layer->DrawTransform(), damage_rect);
+      damage_for_this_update_.Union(damage_rect_in_target_space);
+    }
   }
 
-  // If the layer properties haven't changed, then the the target surface is
-  // only affected by the layer's damaged area, which could be empty.
-  gfx::Rect damage_rect =
-      gfx::UnionRects(layer->update_rect(), layer->damage_rect());
-  damage_rect.Intersect(gfx::Rect(layer->bounds()));
-  if (!damage_rect.IsEmpty()) {
-    gfx::Rect damage_rect_in_target_space =
-        MathUtil::MapEnclosingClippedRect(layer->DrawTransform(), damage_rect);
-    damage_for_this_update_.Union(damage_rect_in_target_space);
+  // Property changes from animaiton will not be considered as damage from
+  // contributing content.
+  if (layer_is_new || layer->LayerPropertyChangedNotFromPropertyTrees() ||
+      !layer->update_rect().IsEmpty() || !layer->damage_rect().IsEmpty()) {
+    has_damage_from_contributing_content_ |= !damage_for_this_update_.IsEmpty();
   }
 }
 
 void DamageTracker::AccumulateDamageFromRenderSurface(
     RenderSurfaceImpl* render_surface) {
   // There are two ways a "descendant surface" can damage regions of the "target
   // surface":
   //   1. Property change:
   //        - a surface's geometry can change because of
   //            - changes to descendants (i.e. the subtree) that affect the
@@ skipping 44 matching lines @@
   // layer. We expand the damage from this layer too, as we need to readback
   // those pixels from the surface with only the contents of layers below this
   // one in them. This means we need to redraw any pixels in the surface being
   // used for the blur in this layer this frame.
   const FilterOperations& background_filters =
       render_surface->BackgroundFilters();
   if (background_filters.HasFilterThatMovesPixels()) {
     ExpandDamageInsideRectWithFilters(surface_rect_in_target_space,
                                       background_filters);
   }
+
+  // True if any changes from contributing render surface.
+  has_damage_from_contributing_content_ |= !damage_for_this_update_.IsEmpty();
 }
 
 bool DamageTracker::DamageAccumulator::GetAsRect(gfx::Rect* rect) {
   if (!is_valid_rect_)
     return false;
 
   base::CheckedNumeric<int> width = right_;
   width -= x_;
   base::CheckedNumeric<int> height = bottom_;
   height -= y_;
   if (!width.IsValid() || !height.IsValid()) {
     is_valid_rect_ = false;
     return false;
   }
 
   rect->set_x(x_);
   rect->set_y(y_);
   rect->set_width(width.ValueOrDie());
   rect->set_height(height.ValueOrDie());
   return true;
 }
 
 }  // namespace cc