Tile Compression

cc/resources/picture_layer_tiling.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_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 38 matching lines @@
     // Or if a is farther away from visible.
     return a_priority.distance_to_visible > b_priority.distance_to_visible;
   }
 
  private:
   TreePriority tree_priority_;
 };
 
 }  // namespace
 
+const int
+    PictureLayerTiling::TileInvalidationState::kFrequentInvalidationThreshold =
+        2;
+
+PictureLayerTiling::TileInvalidationState::TileInvalidationState()
+    : frame_count_(0) {
+}
+
+void PictureLayerTiling::TileInvalidationState::Invalidate(
+    base::TimeTicks current_frame_time) {
+  if (current_frame_time == last_frame_time_)
+    return;
+
+  // Check the time intervals between consecutive invalidations:
+  // - If the intervals are shorter than kIntervalMin for a number of
+  //   consecutive invalidations, it's a "frequently invalidated" tile.
+  // - If the interval between two invalidations is longer than kIntervalMax,
+  //   it's not a "frequently invalidated" tile anymore.
+  base::TimeDelta time_since = current_frame_time - last_frame_time_;
+  const base::TimeDelta kIntervalMin = base::TimeDelta::FromMilliseconds(700);
+  const base::TimeDelta kIntervalMax = base::TimeDelta::FromMilliseconds(2000);
+  const base::TimeDelta interval =
+      FrequentlyInvalidated() ? kIntervalMax : kIntervalMin;
+  frame_count_ =
+      time_since < interval
+          ? std::min(frame_count_ + 1, kFrequentInvalidationThreshold)
+          : 0;
+  last_frame_time_ = current_frame_time;
+}
+
+bool PictureLayerTiling::TileInvalidationState::FrequentlyInvalidated() const {
+  return frame_count_ >= kFrequentInvalidationThreshold;
+}
+
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
     float contents_scale,
     const gfx::Size& layer_bounds,
     PictureLayerTilingClient* client) {
   return make_scoped_ptr(new PictureLayerTiling(contents_scale,
                                                 layer_bounds,
                                                 client));
 }
 
 PictureLayerTiling::PictureLayerTiling(float contents_scale,
@@ skipping 62 matching lines @@
         DCHECK(!candidate_tile->is_shared());
         DCHECK_EQ(i, candidate_tile->tiling_i_index());
         DCHECK_EQ(j, candidate_tile->tiling_j_index());
         candidate_tile->set_shared(true);
         tiles_[key] = candidate_tile;
         return candidate_tile;
       }
     }
   }
 
+  int flags = 0;
+  auto found = tile_invalidation_states_.find(key);
+  if (found != tile_invalidation_states_.end()) {
+    if (found->second.FrequentlyInvalidated())
+      flags |= Tile::FREQUENTLY_INVALIDATED;
+  }
+
   // Create a new tile because our twin didn't have a valid one.
-  scoped_refptr<Tile> tile = client_->CreateTile(this, tile_rect);
+  scoped_refptr<Tile> tile = client_->CreateTile(this, tile_rect, flags);
   if (tile.get()) {
     DCHECK(!tile->is_shared());
     tile->set_tiling_index(i, j);
     tiles_[key] = tile;
   }
   eviction_tiles_cache_valid_ = false;
   return tile.get();
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
@@ skipping 10 matching lines @@
       continue;
     CreateTile(key.first, key.second, twin_tiling);
   }
 
   VerifyLiveTilesRect();
 }
 
 void PictureLayerTiling::UpdateTilesToCurrentRasterSource(
     RasterSource* raster_source,
     const Region& layer_invalidation,
-    const gfx::Size& new_layer_bounds) {
+    const gfx::Size& new_layer_bounds,
+    base::TimeTicks frame_time) {
   DCHECK(!new_layer_bounds.IsEmpty());
 
   gfx::Size content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(new_layer_bounds, contents_scale_));
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
 
   if (new_layer_bounds != layer_bounds_) {
     if (tile_size.IsEmpty()) {
       layer_bounds_ = gfx::Size();
       content_bounds = gfx::Size();
@@ skipping 27 matching lines @@
     }
 
     // There is no recycled twin since this is run on the pending tiling.
     PictureLayerTiling* recycled_twin = NULL;
     DCHECK_EQ(recycled_twin, client_->GetRecycledTwinTiling(this));
     DCHECK_EQ(PENDING_TREE, client_->GetTree());
 
     // Drop tiles outside the new layer bounds if the layer shrank.
     for (int i = after_right + 1; i <= before_right; ++i) {
       for (int j = before_top; j <= before_bottom; ++j)
-        RemoveTileAt(i, j, recycled_twin);
+        RemoveTileAt(i, j, recycled_twin, true);
     }
     for (int i = before_left; i <= after_right; ++i) {
       for (int j = after_bottom + 1; j <= before_bottom; ++j)
-        RemoveTileAt(i, j, recycled_twin);
+        RemoveTileAt(i, j, recycled_twin, true);
     }
 
     // If the layer grew, the live_tiles_rect_ is not changed, but a new row
     // and/or column of tiles may now exist inside the same live_tiles_rect_.
     const PictureLayerTiling* twin_tiling =
         client_->GetPendingOrActiveTwinTiling(this);
     if (after_right > before_right) {
       DCHECK_EQ(after_right, before_right + 1);
       for (int j = before_top; j <= after_bottom; ++j)
         CreateTile(after_right, j, twin_tiling);
     }
     if (after_bottom > before_bottom) {
       DCHECK_EQ(after_bottom, before_bottom + 1);
       for (int i = before_left; i <= before_right; ++i)
         CreateTile(i, after_bottom, twin_tiling);
     }
   }
 
   if (tile_size != tiling_data_.max_texture_size()) {
     tiling_data_.SetMaxTextureSize(tile_size);
     // When the tile size changes, the TilingData positions no longer work
     // as valid keys to the TileMap, so just drop all tiles.
     Reset();
   } else {
-    Invalidate(layer_invalidation);
+    Invalidate(layer_invalidation, frame_time);
   }
 
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
     it->second->set_raster_source(raster_source);
   VerifyLiveTilesRect();
 }
 
 void PictureLayerTiling::RemoveTilesInRegion(const Region& layer_region) {
   bool recreate_invalidated_tiles = false;
-  DoInvalidate(layer_region, recreate_invalidated_tiles);
+  DoInvalidate(layer_region, recreate_invalidated_tiles, base::TimeTicks());
 }
 
-void PictureLayerTiling::Invalidate(const Region& layer_region) {
+void PictureLayerTiling::Invalidate(const Region& layer_region,
+                                    base::TimeTicks frame_time) {
   bool recreate_invalidated_tiles = true;
-  DoInvalidate(layer_region, recreate_invalidated_tiles);
+  DoInvalidate(layer_region, recreate_invalidated_tiles, frame_time);
 }
 
 void PictureLayerTiling::DoInvalidate(const Region& layer_region,
-                                      bool recreate_invalidated_tiles) {
+                                      bool recreate_invalidated_tiles,
+                                      base::TimeTicks frame_time) {
+  bool update_invalidation_states = frame_time != base::TimeTicks();
   std::vector<TileMapKey> new_tile_keys;
   gfx::Rect expanded_live_tiles_rect =
       tiling_data_.ExpandRectIgnoringBordersToTileBounds(live_tiles_rect_);
   for (Region::Iterator iter(layer_region); iter.has_rect(); iter.next()) {
     gfx::Rect layer_rect = iter.rect();
     gfx::Rect content_rect =
         gfx::ScaleToEnclosingRect(layer_rect, contents_scale_);
     // Consider tiles inside the live tiles rect even if only their border
     // pixels intersect the invalidation. But don't consider tiles outside
     // the live tiles rect with the same conditions, as they won't exist.
     int border_pixels = tiling_data_.border_texels();
     content_rect.Inset(-border_pixels, -border_pixels);
     // Avoid needless work by not bothering to invalidate where there aren't
     // tiles.
     content_rect.Intersect(expanded_live_tiles_rect);
     if (content_rect.IsEmpty())
       continue;
     // Since the content_rect includes border pixels already, don't include
     // borders when iterating to avoid double counting them.
     bool include_borders = false;
     for (TilingData::Iterator iter(
              &tiling_data_, content_rect, include_borders);
          iter;
          ++iter) {
+      if (update_invalidation_states)
+        tile_invalidation_states_[iter.index()].Invalidate(frame_time);
+
       // There is no recycled twin since this is run on the pending tiling.
       PictureLayerTiling* recycled_twin = NULL;
       DCHECK_EQ(recycled_twin, client_->GetRecycledTwinTiling(this));
       DCHECK_EQ(PENDING_TREE, client_->GetTree());
-      if (RemoveTileAt(iter.index_x(), iter.index_y(), recycled_twin))
+      if (RemoveTileAt(iter.index_x(), iter.index_y(), recycled_twin, false))
         new_tile_keys.push_back(iter.index());
     }
   }
 
   if (recreate_invalidated_tiles && !new_tile_keys.empty()) {
     for (size_t i = 0; i < new_tile_keys.size(); ++i) {
       // Don't try to share a tile with the twin layer, it's been invalidated so
       // we have to make our own tile here.
       const PictureLayerTiling* twin_tiling = NULL;
       CreateTile(new_tile_keys[i].first, new_tile_keys[i].second, twin_tiling);
@@ skipping 146 matching lines @@
 
   return texture_rect;
 }
 
 gfx::Size PictureLayerTiling::CoverageIterator::texture_size() const {
   return tiling_->tiling_data_.max_texture_size();
 }
 
 bool PictureLayerTiling::RemoveTileAt(int i,
                                       int j,
-                                      PictureLayerTiling* recycled_twin) {
+                                      PictureLayerTiling* recycled_twin,
+                                      bool remove_invalidation_state) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
   if (found == tiles_.end())
     return false;
   found->second->set_shared(false);
   tiles_.erase(found);
   eviction_tiles_cache_valid_ = false;
+
+  if (remove_invalidation_state) {
+    auto found = tile_invalidation_states_.find(TileMapKey(i, j));
+    if (found != tile_invalidation_states_.end())
+      tile_invalidation_states_.erase(found);
+  }
+
   if (recycled_twin) {
     // Recycled twin does not also have a recycled twin, so pass NULL.
-    recycled_twin->RemoveTileAt(i, j, NULL);
+    recycled_twin->RemoveTileAt(i, j, NULL, remove_invalidation_state);
   }
   return true;
 }
 
 void PictureLayerTiling::Reset() {
   live_tiles_rect_ = gfx::Rect();
   PictureLayerTiling* recycled_twin = client_->GetRecycledTwinTiling(this);
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     it->second->set_shared(false);
-    if (recycled_twin)
-      recycled_twin->RemoveTileAt(it->first.first, it->first.second, NULL);
+    if (recycled_twin) {
+      recycled_twin->RemoveTileAt(it->first.first, it->first.second, NULL,
+                                  true);
+    }
   }
   tiles_.clear();
+  tile_invalidation_states_.clear();
   eviction_tiles_cache_valid_ = false;
 }
 
 gfx::Rect PictureLayerTiling::ComputeSkewport(
     double current_frame_time_in_seconds,
     const gfx::Rect& visible_rect_in_content_space) const {
   gfx::Rect skewport = visible_rect_in_content_space;
   if (last_impl_frame_time_in_seconds_ == 0.0)
     return skewport;
 
@@ skipping 123 matching lines @@
   if (live_tiles_rect_ == new_live_tiles_rect)
     return;
 
   // Iterate to delete all tiles outside of our new live_tiles rect.
   PictureLayerTiling* recycled_twin = client_->GetRecycledTwinTiling(this);
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            live_tiles_rect_,
                                            new_live_tiles_rect);
        iter;
        ++iter) {
-    RemoveTileAt(iter.index_x(), iter.index_y(), recycled_twin);
+    RemoveTileAt(iter.index_x(), iter.index_y(), recycled_twin, true);
   }
 
   const PictureLayerTiling* twin_tiling =
       client_->GetPendingOrActiveTwinTiling(this);
 
   // Iterate to allocate new tiles for all regions with newly exposed area.
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            new_live_tiles_rect,
                                            live_tiles_rect_);
        iter;
@@ skipping 568 matching lines @@
     }
     current_tile_ = tiling_->TileAt(next_index.first, next_index.second);
   }
 
   if (current_tile_)
     tiling_->UpdateTileAndTwinPriority(current_tile_);
   return *this;
 }
 
 }  // namespace cc