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) {}
+    : mailboxId_(0),
+      has_property_change_on_contributing_render_surface_(false) {}
 
 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 211 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_property_change_on_contributing_render_surface_ = 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 143 matching lines @@
 
   bool surface_is_new = false;
   SurfaceRectMapData& data =
       RectDataForSurface(render_surface->id(), &surface_is_new);
   gfx::Rect old_surface_rect = data.rect_;
 
   gfx::Rect surface_rect_in_target_space =
       gfx::ToEnclosingRect(render_surface->DrawableContentRect());
   data.Update(surface_rect_in_target_space, mailboxId_);
 
+  has_property_change_on_contributing_render_surface_ |=

[weiliangc, 2017/06/07 21:19:01]

The flag for not able to use the texture should be damage that comes from
contributing layers or contributing surfaces. The damage coming from
contributing layers and contributing render surfaces should just be the
damage_rect on the render surface. Since the damage rect is later set to
output_rect, we should keep track of whether that is empty after damage
calculating and before it is set to output rect.

[wutao, 2017/06/09 02:31:32]

This is a very good point.
Do you mean damage_for_this_update_? I can update
has_damage_from_contributing_render_surface_or_layer at last in
AccumulateDamageFromLayer and AccumulateDamageFromRenderSurface, where all
damage from contributing render surfaces or layers must already have been added
to damage_for_this_update_.

+      render_surface->SurfacePropertyChanged() ||

[weiliangc, 2017/06/07 21:19:01]

SurfacePropertyChanged() seems to be ok for reusing texture, since it's the
surface's own property and ancestor property change.

SUrfacePropertyChanged() is true if there are changes in clip_rect (should be
able to apply to texture), content_rect (shouldn't change in the
force_render_surface state), or changes from ancestor (should be able to handle
in direct renderer when drawing the texture).

[wutao, 2017/06/09 02:31:32]

Acknowledged.

+      render_surface->ContributingRenderSurfacePropertyChanged();
+
   if (surface_is_new || render_surface->SurfacePropertyChanged()) {
     // The entire surface contributes damage.
     damage_for_this_update_.Union(surface_rect_in_target_space);
 
     // The surface's old region is now exposed on the target surface, too.
     damage_for_this_update_.Union(old_surface_rect);
   } else {
     // Only the surface's damage_rect will damage the target surface.
     gfx::Rect damage_rect_in_local_space;
     bool is_valid_rect = render_surface->damage_tracker()->GetDamageRectIfValid(
@@ skipping 38 matching lines @@
   }
 
   rect->set_x(x_);
   rect->set_y(y_);
   rect->set_width(width.ValueOrDie());
   rect->set_height(height.ValueOrDie());
   return true;
 }
 
 }  // namespace cc