cc: Remove invalidation history

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>
 
 #include "cc/base/region.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "skia/ext/analysis_canvas.h"
 
 namespace {
 // Layout pixel buffer around the visible layer rect to record.  Any base
 // picture that intersects the visible layer rect expanded by this distance
 // will be recorded.
 const int kPixelDistanceToRecord = 8000;
 // We don't perform solid color analysis on images that have more than 10 skia
 // operations.
 const int kOpCountThatIsOkToAnalyze = 10;
 
 // Dimensions of the tiles in this picture pile as well as the dimensions of
 // the base picture in each tile.
 const int kBasePictureSize = 512;
 
-// Invalidation frequency settings. kInvalidationFrequencyThreshold is a value
-// between 0 and 1 meaning invalidation frequency between 0% and 100% that
-// indicates when to stop invalidating offscreen regions.
-// kFrequentInvalidationDistanceThreshold defines what it means to be
-// "offscreen" in terms of distance to visible in css pixels.
-// TODO(vmpstr): Remove invalidation frequency after frequently invalidated
-// content is not painted at a higher level.
-const float kInvalidationFrequencyThreshold = 0.75f;
-const int kFrequentInvalidationDistanceThreshold = 1024;
-
 // TODO(humper): The density threshold here is somewhat arbitrary; need a
 // way to set // this from the command line so we can write a benchmark
 // script and find a sweet spot.
 const float kDensityThreshold = 0.5f;
 
 bool rect_sort_y(const gfx::Rect& r1, const gfx::Rect& r2) {
   return r1.y() < r2.y() || (r1.y() == r2.y() && r1.x() < r2.x());
 }
 
 bool rect_sort_x(const gfx::Rect& r1, const gfx::Rect& r2) {
@@ skipping 161 matching lines @@
 
   CreatePictures(painter, recording_mode, record_rects);
 
   DetermineIfSolidColor();
 
   has_any_recordings_ = true;
   DCHECK(CanRasterSlowTileCheck(recorded_viewport_));
   return true;
 }
 
-void PicturePile::DidMoveToNewCompositor() {
-  for (auto& map_pair : picture_map_)
-    map_pair.second.ResetInvalidationHistory();
-}
-
 bool PicturePile::ApplyInvalidationAndResize(const gfx::Rect& interest_rect,
                                              Region* invalidation,
                                              const gfx::Size& layer_size,
                                              int frame_number) {
   bool updated = false;
 
   Region synthetic_invalidation;
   gfx::Size old_tiling_size = GetSize();
   if (old_tiling_size != layer_size) {
     tiling_.SetTilingSize(layer_size);
@@ skipping 24 matching lines @@
           tiling_.FirstBorderTileXIndexFromSrcCoord(min_tiling_size.width());
     }
     int min_toss_y = tiling_.num_tiles_y();
     if (max_tiling_size.height() > min_tiling_size.height()) {
       min_toss_y =
           tiling_.FirstBorderTileYIndexFromSrcCoord(min_tiling_size.height());
     }
     for (const auto& key_picture_pair : picture_map_) {
       const PictureMapKey& key = key_picture_pair.first;
       if (key.first < min_toss_x && key.second < min_toss_y) {
-        has_any_recordings_ |= !!key_picture_pair.second.GetPicture();
+        has_any_recordings_ |= true;

[vmpstr, 2015/04/07 17:43:14]

nit: = true

         continue;
       }
       to_erase.push_back(key);
     }
 
     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
@@ skipping 151 matching lines @@
       synthetic_invalidation.Union(top_rect);
       synthetic_invalidation.Union(bottom_rect);
       synthetic_invalidation.Union(exposed_rect);
     }
   }
 
   // Detect cases where the full pile is invalidated, in this situation we
   // can just drop/invalidate everything.
   if (invalidation->Contains(gfx::Rect(old_tiling_size)) ||
       invalidation->Contains(gfx::Rect(GetSize()))) {
-    for (auto& it : picture_map_)
-      updated = it.second.Invalidate(frame_number) || updated;
+    updated = !picture_map_.empty();
+    picture_map_.clear();
   } else {
     // Expand invalidation that is on tiles that aren't in the interest rect and
     // will not be re-recorded below. 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.
     Region invalidation_expanded_to_full_tiles;
 
     for (Region::Iterator i(*invalidation); i.has_rect(); i.next()) {
       gfx::Rect invalid_rect = i.rect();
 
@@ skipping 19 matching lines @@
       bool include_borders = true;
       for (TilingData::Iterator iter(&tiling_, invalid_rect, include_borders);
            iter;
            ++iter) {
         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;
+        updated = true;
+        picture_map_.erase(key);
+
         // 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)));
       }
     }
     invalidation->Union(invalidation_expanded_to_full_tiles);
   }
 
   invalidation->Union(synthetic_invalidation);
   return updated;
 }
 
 void PicturePile::GetInvalidTileRects(const gfx::Rect& interest_rect,
                                       Region* invalidation,
                                       const gfx::Rect& visible_layer_rect,
                                       int frame_number,
                                       std::vector<gfx::Rect>* invalid_tiles) {
   // Make a list of all invalid tiles; we will attempt to
   // cluster these into multiple invalidation regions.
   bool include_borders = true;
   for (TilingData::Iterator it(&tiling_, interest_rect, include_borders); it;
        ++it) {
     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()));
-    }
+    if (picture_map_.find(key) == picture_map_.end())
+      invalid_tiles->push_back(tiling_.TileBounds(key.first, key.second));
   }
 }
 
 void PicturePile::CreatePictures(ContentLayerClient* painter,
                                  RecordingSource::RecordingMode recording_mode,
                                  const std::vector<gfx::Rect>& record_rects) {
   for (const auto& record_rect : record_rects) {
     gfx::Rect padded_record_rect = PadRect(record_rect);
 
     int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
@@ skipping 21 matching lines @@
     }
 
     bool found_tile_for_recorded_picture = false;
 
     bool include_borders = true;
     for (TilingData::Iterator it(&tiling_, padded_record_rect, include_borders);
          it; ++it) {
       const PictureMapKey& key = it.index();
       gfx::Rect tile = PaddedRect(key);
       if (padded_record_rect.Contains(tile)) {
-        PictureInfo& info = picture_map_[key];
-        info.SetPicture(picture);
+        picture_map_[key] = picture;
         found_tile_for_recorded_picture = true;
       }
     }
     DCHECK(found_tile_for_recorded_picture);
   }
 }
 
 scoped_refptr<RasterSource> PicturePile::CreateRasterSource(
     bool can_use_lcd_text) const {
   return scoped_refptr<RasterSource>(
@@ skipping 65 matching lines @@
   return tile_grid_size_;
 }
 
 bool PicturePile::CanRasterSlowTileCheck(const gfx::Rect& layer_rect) const {
   bool include_borders = false;
   for (TilingData::Iterator tile_iter(&tiling_, layer_rect, include_borders);
        tile_iter; ++tile_iter) {
     PictureMap::const_iterator map_iter = picture_map_.find(tile_iter.index());
     if (map_iter == picture_map_.end())
       return false;
-    if (!map_iter->second.GetPicture())
-      return false;
   }
   return true;
 }
 
 void PicturePile::DetermineIfSolidColor() {
   is_solid_color_ = false;
   solid_color_ = SK_ColorTRANSPARENT;
 
   if (picture_map_.empty()) {
     return;
   }
 
   PictureMap::const_iterator it = picture_map_.begin();
-  const Picture* picture = it->second.GetPicture();
+  const Picture* picture = it->second.get();
 
   // Missing recordings due to frequent invalidations or being too far away
   // from the interest rect will cause the a null picture to exist.
   if (!picture)
     return;
 
   // Don't bother doing more work if the first image is too complicated.
   if (picture->ApproximateOpCount() > kOpCountThatIsOkToAnalyze)
     return;
 
   // Make sure all of the mapped images point to the same picture.
   for (++it; it != picture_map_.end(); ++it) {
-    if (it->second.GetPicture() != picture)
+    if (it->second.get() != picture)
       return;
   }
 
   gfx::Size layer_size = GetSize();
   skia::AnalysisCanvas canvas(layer_size.width(), layer_size.height());
 
   picture->Raster(&canvas, nullptr, Region(), 1.0f);
   is_solid_color_ = canvas.GetColorIfSolid(&solid_color_);
 }
 
 gfx::Rect PicturePile::PaddedRect(const PictureMapKey& key) const {
   gfx::Rect tile = tiling_.TileBounds(key.first, key.second);
   return PadRect(tile);
 }
 
 gfx::Rect PicturePile::PadRect(const gfx::Rect& rect) const {
   gfx::Rect padded_rect = rect;
   padded_rect.Inset(-buffer_pixels(), -buffer_pixels(), -buffer_pixels(),
                     -buffer_pixels());
   return padded_rect;
 }
 
 void PicturePile::Clear() {
   picture_map_.clear();
   recorded_viewport_ = gfx::Rect();
   has_any_recordings_ = false;
   is_solid_color_ = false;
 }
 
-PicturePile::PictureInfo::PictureInfo() : last_frame_number_(0) {
-}
-
-PicturePile::PictureInfo::~PictureInfo() {
-}
-
-void PicturePile::PictureInfo::AdvanceInvalidationHistory(int frame_number) {
-  DCHECK_GE(frame_number, last_frame_number_);
-  if (frame_number == last_frame_number_)
-    return;
-
-  invalidation_history_ <<= (frame_number - last_frame_number_);
-  last_frame_number_ = frame_number;
-}
-
-bool PicturePile::PictureInfo::Invalidate(int frame_number) {
-  AdvanceInvalidationHistory(frame_number);
-  invalidation_history_.set(0);
-
-  bool did_invalidate = !!picture_.get();
-  picture_ = NULL;
-  return did_invalidate;
-}
-
-bool PicturePile::PictureInfo::NeedsRecording(int frame_number,
-                                              int distance_to_visible) {
-  AdvanceInvalidationHistory(frame_number);
-
-  // We only need recording if we don't have a picture. Furthermore, we only
-  // need a recording if we're within frequent invalidation distance threshold
-  // or the invalidation is not frequent enough (below invalidation frequency
-  // threshold).
-  return !picture_.get() &&
-         ((distance_to_visible <= kFrequentInvalidationDistanceThreshold) ||
-          (GetInvalidationFrequency() < kInvalidationFrequencyThreshold));
-}
-
-void PicturePile::PictureInfo::ResetInvalidationHistory() {
-  invalidation_history_.reset();
-  last_frame_number_ = 0;
-}
-
 void PicturePile::SetBufferPixels(int new_buffer_pixels) {
   if (new_buffer_pixels == buffer_pixels())
     return;
 
   Clear();
   tiling_.SetBorderTexels(new_buffer_pixels);
 }
 
-void PicturePile::PictureInfo::SetPicture(scoped_refptr<Picture> picture) {
-  picture_ = picture;
-}
-
-const Picture* PicturePile::PictureInfo::GetPicture() const {
-  return picture_.get();
-}
-
-float PicturePile::PictureInfo::GetInvalidationFrequency() const {
-  return invalidation_history_.count() /
-         static_cast<float>(INVALIDATION_FRAMES_TRACKED);
-}
-
 }  // namespace cc