cc: Clean up tilings in UpdateTiles as well as in AppendQuads.

cc/layers/picture_layer_impl.cc

 // Copyright 2012 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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 66 matching lines @@
       ideal_contents_scale_(0.f),
       raster_page_scale_(0.f),
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
       raster_contents_scale_(0.f),
       low_res_raster_contents_scale_(0.f),
       raster_source_scale_is_fixed_(false),
       was_screen_space_transform_animating_(false),
       only_used_low_res_last_append_quads_(false),
       is_mask_(is_mask),
-      nearest_neighbor_(false) {
+      nearest_neighbor_(false),
+      need_tiling_cleanup_(false) {
   layer_tree_impl()->RegisterPictureLayerImpl(this);
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
   if (twin_layer_)
     twin_layer_->twin_layer_ = nullptr;
   layer_tree_impl()->UnregisterPictureLayerImpl(this);
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
@@ skipping 171 matching lines @@
       debug_border_quad->SetNew(shared_quad_state,
                                 geometry_rect,
                                 visible_geometry_rect,
                                 color,
                                 width);
     }
   }
 
   // Keep track of the tilings that were used so that tilings that are
   // unused can be considered for removal.
-  std::vector<PictureLayerTiling*> seen_tilings;
+  last_append_quads_tilings_.clear();
 
   // Ignore missing tiles outside of viewport for tile priority. This is
   // normally the same as draw viewport but can be independently overridden by
   // embedders like Android WebView with SetExternalDrawConstraints.
   gfx::Rect scaled_viewport_for_tile_priority = gfx::ScaleToEnclosingRect(
       viewport_rect_for_tile_priority_in_content_space_, max_contents_scale);
 
   size_t missing_tile_count = 0u;
   size_t on_demand_missing_tile_count = 0u;
   only_used_low_res_last_append_quads_ = true;
@@ skipping 106 matching lines @@
     if (iter.resolution() != HIGH_RESOLUTION) {
       append_quads_data->approximated_visible_content_area +=
           visible_geometry_rect.width() * visible_geometry_rect.height();
     }
 
     // If we have a draw quad, but it's not low resolution, then
     // mark that we've used something other than low res to draw.
     if (iter.resolution() != LOW_RESOLUTION)
       only_used_low_res_last_append_quads_ = false;
 
-    if (seen_tilings.empty() || seen_tilings.back() != iter.CurrentTiling())
-      seen_tilings.push_back(iter.CurrentTiling());
+    if (last_append_quads_tilings_.empty() ||
+        last_append_quads_tilings_.back() != iter.CurrentTiling()) {
+      last_append_quads_tilings_.push_back(iter.CurrentTiling());
+    }
   }
 
   if (missing_tile_count) {
     TRACE_EVENT_INSTANT2("cc",
                          "PictureLayerImpl::AppendQuads checkerboard",
                          TRACE_EVENT_SCOPE_THREAD,
                          "missing_tile_count",
                          missing_tile_count,
                          "on_demand_missing_tile_count",
                          on_demand_missing_tile_count);
   }
 
   // Aggressively remove any tilings that are not seen to save memory. Note
   // that this is at the expense of doing cause more frequent re-painting. A
   // better scheme would be to maintain a tighter visible_content_rect for the
   // finer tilings.
-  CleanUpTilingsOnActiveLayer(seen_tilings);
+  CleanUpTilingsOnActiveLayer(last_append_quads_tilings_);
 }
 
 bool PictureLayerImpl::UpdateTiles(const Occlusion& occlusion_in_content_space,
                                    bool resourceless_software_draw) {
   DCHECK_EQ(1.f, contents_scale_x());
   DCHECK_EQ(1.f, contents_scale_y());
 
   if (!resourceless_software_draw) {
     visible_rect_for_tile_priority_ = visible_content_rect();
   }
 
   if (!CanHaveTilings()) {
     ideal_page_scale_ = 0.f;
     ideal_device_scale_ = 0.f;
     ideal_contents_scale_ = 0.f;
     ideal_source_scale_ = 0.f;
     SanityCheckTilingState();
     return false;
   }
 
+  // Remove any non-ideal tilings that were not used last time we generated
+  // quads to save memory and processing time. Note that pending tree should
+  // only have one or two tilings (high and low res), so only clean up the
+  // active layer. Additionally, only clean up if AppendQuads didn't have

[danakj, 2015/01/27 23:02:28]

This is just an optimization because it wouldn't actually remove anything then
right? Sorry I was hoping for a more "why" than an explanation about
need_tiling_cleanup_, which I think is clear.

+  // a chance to do so, as inidicated by |need_tiling_cleanup_|. That is to say,
+  // if AppendQuads cleaned up tilings, then |need_tiling_cleanup_| would be set
+  // to false.
+  if (need_tiling_cleanup_ && GetTree() == ACTIVE_TREE)
+    CleanUpTilingsOnActiveLayer(last_append_quads_tilings_);
+
   UpdateIdealScales();
 
   if (!raster_contents_scale_ || ShouldAdjustRasterScale()) {
     RecalculateRasterScales();
     AddTilingsForRasterScale();
   }
 
   DCHECK(raster_page_scale_);
   DCHECK(raster_device_scale_);
   DCHECK(raster_source_scale_);
   DCHECK(raster_contents_scale_);
   DCHECK(low_res_raster_contents_scale_);
 
   was_screen_space_transform_animating_ =
       draw_properties().screen_space_transform_is_animating;
 
   if (draw_transform_is_animating())
     raster_source_->SetShouldAttemptToUseDistanceFieldText();
-
   return UpdateTilePriorities(occlusion_in_content_space);
 }
 
 bool PictureLayerImpl::UpdateTilePriorities(
     const Occlusion& occlusion_in_content_space) {
   DCHECK_IMPLIES(raster_source_->IsSolidColor(), tilings_->num_tilings() == 0);
 
   double current_frame_time_in_seconds =
       (layer_tree_impl()->CurrentBeginFrameArgs().frame_time -
        base::TimeTicks()).InSecondsF();
@@ skipping 298 matching lines @@
 
   nearest_neighbor_ = nearest_neighbor;
   NoteLayerPropertyChanged();
 }
 
 PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   DCHECK(CanHaveTilings());
   DCHECK_GE(contents_scale, MinimumContentsScale());
   DCHECK_LE(contents_scale, MaximumContentsScale());
   DCHECK(raster_source_->HasRecordings());
+  need_tiling_cleanup_ = true;

[danakj, 2015/01/27 23:02:28]

What about when we UpdateRasterSource and clone the tiling from the active tree?
That makes a tiling here but doesn't set need_tiling_cleanup_. But then you
wouldn't want to cleanup after UpdateRasterSource until after AppendQuads had a
chance to go. (I a-little-bit feel like this bool is making things more
complicated than it's worth worrying about? Or maybe we could just set this to
true in UpdateTiles after it attempts to do the cleanup?)

   return tilings_->AddTiling(contents_scale, raster_source_);
 }
 
 void PictureLayerImpl::RemoveAllTilings() {
   tilings_->RemoveAllTilings();
   // If there are no tilings, then raster scales are no longer meaningful.
   ResetRasterScale();
 }
 
 void PictureLayerImpl::AddTilingsForRasterScale() {
@@ skipping 193 matching lines @@
   float low_res_factor =
       layer_tree_impl()->settings().low_res_contents_scale_factor;
   low_res_raster_contents_scale_ =
       std::max(raster_contents_scale_ * low_res_factor, MinimumContentsScale());
   DCHECK_LE(low_res_raster_contents_scale_, raster_contents_scale_);
   DCHECK_GE(low_res_raster_contents_scale_, MinimumContentsScale());
   DCHECK_LE(low_res_raster_contents_scale_, MaximumContentsScale());
 }
 
 void PictureLayerImpl::CleanUpTilingsOnActiveLayer(
-    std::vector<PictureLayerTiling*> used_tilings) {
+    const std::vector<PictureLayerTiling*>& used_tilings) {
   DCHECK(layer_tree_impl()->IsActiveTree());
   if (tilings_->num_tilings() == 0)
     return;
 
   float min_acceptable_high_res_scale = std::min(
       raster_contents_scale_, ideal_contents_scale_);
   float max_acceptable_high_res_scale = std::max(
       raster_contents_scale_, ideal_contents_scale_);
 
   PictureLayerImpl* twin = GetPendingOrActiveTwinLayer();
@@ skipping 11 matching lines @@
   PictureLayerTilingSet* recycled_twin_set =
       recycled_twin ? recycled_twin->tilings_.get() : nullptr;
 
   tilings_->CleanUpTilings(min_acceptable_high_res_scale,
                            max_acceptable_high_res_scale, used_tilings,
                            layer_tree_impl()->create_low_res_tiling(), twin_set,
                            recycled_twin_set);
 
   if (recycled_twin_set && recycled_twin_set->num_tilings() == 0)
     recycled_twin->ResetRasterScale();
+  need_tiling_cleanup_ = false;
 
   DCHECK_GT(tilings_->num_tilings(), 0u);
   SanityCheckTilingState();
 }
 
 float PictureLayerImpl::MinimumContentsScale() const {
   float setting_min = layer_tree_impl()->settings().minimum_contents_scale;
 
   // If the contents scale is less than 1 / width (also for height),
   // then it will end up having less than one pixel of content in that
@@ skipping 243 matching lines @@
 
 bool PictureLayerImpl::AllTilesRequiredForDrawAreReadyToDraw() const {
   if (!layer_tree_impl()->IsActiveTree())
     return true;
 
   return AllTilesRequiredAreReadyToDraw(
       &PictureLayerTiling::IsTileRequiredForDrawIfVisible);
 }
 
 }  // namespace cc