cc: Make PictureLayerImpl use a better choice for animated raster scale.

cc/resources/picture_pile.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/resources/picture_pile.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 148 matching lines @@
     ContentLayerClient* painter,
     Region* invalidation,
     SkColor background_color,
     bool contents_opaque,
     bool contents_fill_bounds_completely,
     const gfx::Size& layer_size,
     const gfx::Rect& visible_layer_rect,
     int frame_number,
     Picture::RecordingMode recording_mode,
     RenderingStatsInstrumentation* stats_instrumentation) {
+  TRACE_EVENT0("cc", "PicturePile::UpdateAndExpandInvalidation");

[ajuma, 2014/10/10 15:43:03]

Did you mean to add these trace events, or is this left-over debugging code?

[danakj, 2014/10/10 16:07:15]

Oh thanks that's from debugging the next bug, they slipped in overnight.

   background_color_ = background_color;
   contents_opaque_ = contents_opaque;
   contents_fill_bounds_completely_ = contents_fill_bounds_completely;
 
   bool updated = false;
 
   Region resize_invalidation;
   gfx::Size old_tiling_size = tiling_size();
   if (old_tiling_size != layer_size) {
     tiling_.SetTilingSize(layer_size);
     updated = true;
   }
 
   gfx::Rect interest_rect = visible_layer_rect;
   interest_rect.Inset(
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord);
   recorded_viewport_ = interest_rect;
   recorded_viewport_.Intersect(gfx::Rect(tiling_size()));
 
   gfx::Rect interest_rect_over_tiles =
       tiling_.ExpandRectToTileBounds(interest_rect);
 
   if (old_tiling_size != layer_size) {
+    TRACE_EVENT0("cc", "PicturePile::SizeChanged");
     has_any_recordings_ = false;
 
     // Drop recordings that are outside the new layer bounds or that changed
     // size.
     std::vector<PictureMapKey> to_erase;
     int min_toss_x = tiling_.num_tiles_x();
     if (tiling_size().width() > old_tiling_size.width()) {
       min_toss_x =
           tiling_.FirstBorderTileXIndexFromSrcCoord(old_tiling_size.width());
     }
     int min_toss_y = tiling_.num_tiles_y();
     if (tiling_size().height() > old_tiling_size.height()) {
       min_toss_y =
           tiling_.FirstBorderTileYIndexFromSrcCoord(old_tiling_size.height());
     }
+    {
+      TRACE_EVENT0("cc", "PicturePile::FindingKeys");
     for (PictureMap::const_iterator it = picture_map_.begin();
          it != picture_map_.end();
          ++it) {
       const PictureMapKey& key = it->first;
       if (key.first < min_toss_x && key.second < min_toss_y) {
         has_any_recordings_ |= !!it->second.GetPicture();
         continue;
       }
       to_erase.push_back(key);
     }
+    }
 
+    {
+      TRACE_EVENT0("cc", "PicturePile::DeletingKeys");
     for (size_t i = 0; i < to_erase.size(); ++i)
       picture_map_.erase(to_erase[i]);
+    }
 
     // If a recording is dropped and not re-recorded below, invalidate that
     // full recording to cause any raster tiles that would use it to be
     // dropped.
     // If the recording will be replaced below, just invalidate newly exposed
     // areas to force raster tiles that include the old recording to know
     // there is new recording to display.
     gfx::Rect old_tiling_rect_over_tiles =
         tiling_.ExpandRectToTileBounds(gfx::Rect(old_tiling_size));
     if (min_toss_x < tiling_.num_tiles_x()) {
@@ skipping 141 matching lines @@
       resize_invalidation.Union(right_rect);
       resize_invalidation.Union(top_rect);
       resize_invalidation.Union(bottom_rect);
       resize_invalidation.Union(exposed_rect);
     }
   }
 
   Region invalidation_expanded_to_full_tiles;
   for (Region::Iterator i(*invalidation); i.has_rect(); i.next()) {
     gfx::Rect invalid_rect = i.rect();
+    TRACE_EVENT1(
+        "cc", "PicturePile::Invalidating", "rect", invalid_rect.ToString());
 
     // Expand invalidation that is outside tiles that intersect the interest
     // rect. These tiles are no longer valid and should be considerered fully
     // invalid, so we can know to not keep around raster tiles that intersect
     // with these recording tiles.
     gfx::Rect invalid_rect_outside_interest_rect_tiles = invalid_rect;
     // TODO(danakj): We should have a Rect-subtract-Rect-to-2-rects operator
     // instead of using Rect::Subtract which gives you the bounding box of the
     // subtraction.
     invalid_rect_outside_interest_rect_tiles.Subtract(interest_rect_over_tiles);
     invalidation_expanded_to_full_tiles.Union(tiling_.ExpandRectToTileBounds(
         invalid_rect_outside_interest_rect_tiles));
 
     // Split this inflated invalidation across tile boundaries and apply it
     // to all tiles that it touches.
     bool include_borders = true;
+    int n = 0;
     for (TilingData::Iterator iter(&tiling_, invalid_rect, include_borders);
          iter;
          ++iter) {
+      ++n;
       const PictureMapKey& key = iter.index();
 
       PictureMap::iterator picture_it = picture_map_.find(key);
       if (picture_it == picture_map_.end())
         continue;
 
       // Inform the grid cell that it has been invalidated in this frame.
       updated = picture_it->second.Invalidate(frame_number) || updated;
       // Invalidate drops the picture so the whole tile better be invalidated if
       // it won't be re-recorded below.
       DCHECK_IMPLIES(!tiling_.TileBounds(key.first, key.second)
                           .Intersects(interest_rect_over_tiles),
                      invalidation_expanded_to_full_tiles.Contains(
                          tiling_.TileBounds(key.first, key.second)));
     }
+    TRACE_EVENT1("cc", "PicturePile::InvalidatingTiles", "tiles", n);
   }
 
+  {
+    TRACE_EVENT0("cc", "PicturePile::Unioning");
   invalidation->Union(invalidation_expanded_to_full_tiles);
   invalidation->Union(resize_invalidation);
+  }
 
   // Make a list of all invalid tiles; we will attempt to
   // cluster these into multiple invalidation regions.
   std::vector<gfx::Rect> invalid_tiles;
   bool include_borders = true;
   for (TilingData::Iterator it(&tiling_, interest_rect, include_borders); it;
        ++it) {
+    TRACE_EVENT0("cc", "PicturePile::ListingTiles");
     const PictureMapKey& key = it.index();
     PictureInfo& info = picture_map_[key];
 
     gfx::Rect rect = PaddedRect(key);
     int distance_to_visible =
         rect.ManhattanInternalDistance(visible_layer_rect);
 
     if (info.NeedsRecording(frame_number, distance_to_visible)) {
       gfx::Rect tile = tiling_.TileBounds(key.first, key.second);
       invalid_tiles.push_back(tile);
     } else if (!info.GetPicture()) {
       if (recorded_viewport_.Intersects(rect)) {
         // Recorded viewport is just an optimization for a fully recorded
         // interest rect.  In this case, a tile in that rect has declined
         // to be recorded (probably due to frequent invalidations).
         // TODO(enne): Shrink the recorded_viewport_ rather than clearing.
         recorded_viewport_ = gfx::Rect();
       }
 
       // If a tile in the interest rect is not recorded, the entire tile needs
       // to be considered invalid, so that we know not to keep around raster
       // tiles that intersect this recording tile.
       invalidation->Union(tiling_.TileBounds(it.index_x(), it.index_y()));
     }
   }
 
   std::vector<gfx::Rect> record_rects;
+  {
+    TRACE_EVENT0("cc", "PicturePile::Clustering");
   ClusterTiles(invalid_tiles, &record_rects);
+  }
 
   if (record_rects.empty())
     return updated;
 
   for (std::vector<gfx::Rect>::iterator it = record_rects.begin();
        it != record_rects.end();
        it++) {
     gfx::Rect record_rect = *it;
     record_rect = PadRect(record_rect);
 
     int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
     scoped_refptr<Picture> picture;
 
     // Note: Currently, gathering of pixel refs when using a single
     // raster thread doesn't provide any benefit. This might change
     // in the future but we avoid it for now to reduce the cost of
     // Picture::Create.
     bool gather_pixel_refs = RasterWorkerPool::GetNumRasterThreads() > 1;
 
     {
+      TRACE_EVENT0("cc", "PicturePile::Record");
       base::TimeDelta best_duration = base::TimeDelta::Max();
       for (int i = 0; i < repeat_count; i++) {
         base::TimeTicks start_time = stats_instrumentation->StartRecording();
         picture = Picture::Create(record_rect,
                                   painter,
                                   tile_grid_info_,
                                   gather_pixel_refs,
                                   recording_mode);
         // Note the '&&' with previous is-suitable state.
         // This means that once a picture-pile becomes unsuitable for gpu
@@ skipping 19 matching lines @@
     for (TilingData::Iterator it(&tiling_, record_rect, include_borders); it;
          ++it) {
       const PictureMapKey& key = it.index();
       gfx::Rect tile = PaddedRect(key);
       if (record_rect.Contains(tile)) {
         PictureInfo& info = picture_map_[key];
         info.SetPicture(picture);
         found_tile_for_recorded_picture = true;
       }
     }
+    TRACE_EVENT0("cc", "PicturePile::DetermineIfSolidColor");
     DetermineIfSolidColor();
     DCHECK(found_tile_for_recorded_picture);
   }
 
   has_any_recordings_ = true;
   DCHECK(CanRasterSlowTileCheck(recorded_viewport_));
   return true;
 }
 
 void PicturePile::SetEmptyBounds() {
@@ skipping 28 matching lines @@
     if (it->second.GetPicture() != picture)
       return;
   }
   skia::AnalysisCanvas canvas(recorded_viewport_.width(),
                               recorded_viewport_.height());
   picture->Raster(&canvas, NULL, Region(), 1.0f);
   is_solid_color_ = canvas.GetColorIfSolid(&solid_color_);
 }
 
 }  // namespace cc