cc: Partial tile update for one-copy raster.

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>
 
+#include "base/containers/hash_tables.h"
+#include "base/containers/small_map.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
 #include "cc/resources/prioritized_tile.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
@@ skipping 198 matching lines @@
         tiling_data_.TileXIndexFromSrcCoord(live_tiles_rect_.right() - 1);
     after_bottom =
         tiling_data_.TileYIndexFromSrcCoord(live_tiles_rect_.bottom() - 1);
   }
 
   // There is no recycled twin since this is run on the pending tiling
   // during commit, and on the active tree during activate.
   // 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);
+      RemoveTileAt(i, j, nullptr);
   }
   for (int i = before_left; i <= after_right; ++i) {
     for (int j = after_bottom + 1; j <= before_bottom; ++j)
-      RemoveTileAt(i, j);
+      RemoveTileAt(i, j, nullptr);
   }
 
   if (after_right > before_right) {
     DCHECK_EQ(after_right, before_right + 1);
     for (int j = before_top; j <= after_bottom; ++j) {
       if (ShouldCreateTileAt(after_right, j))
         CreateTile(after_right, j);
     }
   }
   if (after_bottom > before_bottom) {
@@ skipping 10 matching lines @@
                  !client_->GetPendingOrActiveTwinTiling(this));
   RemoveTilesInRegion(layer_invalidation, true /* recreate tiles */);
 }
 
 void PictureLayerTiling::RemoveTilesInRegion(const Region& layer_invalidation,
                                              bool recreate_tiles) {
   // We only invalidate the active tiling when it's orphaned: it has no pending
   // twin, so it's slated for removal in the future.
   if (live_tiles_rect_.IsEmpty())
     return;
-  std::vector<TileMapKey> new_tile_keys;
+  struct RemoveTileData {
+    gfx::Rect invalid_content_rect;
+    Tile::Id invalid_id;
+  };
+  base::SmallMap<base::hash_map<TileMapKey, RemoveTileData>, 16> remove_tiles;
   gfx::Rect expanded_live_tiles_rect =
       tiling_data_.ExpandRectIgnoringBordersToTileBounds(live_tiles_rect_);
   for (Region::Iterator iter(layer_invalidation); 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 (RemoveTileAt(iter.index_x(), iter.index_y())) {
-        if (recreate_tiles)
-          new_tile_keys.push_back(iter.index());
-      }
+      RemoveTileData& remove_tile_data = remove_tiles[iter.index()];

[vmpstr, 2015/05/14 22:28:27]

At a first glance, this seems to be changing behaviour:

- We should only be recreating tiles if recreate_tiles is true.
- We should only be creating tiles in regions where we removed tiles.

^ those two are no longer true. 

I'd prefer to keep old behaviour. I think you had a right thing before where you
moved RemoveTileAt to be in the second loop. The first loop just need to
accumulate rects (so the small map can be Key -> Rect, I think). The second loop
would do something like

if (RemoveTile(...) && recreate_tile) {
  CreateTile(...);
  tile->set_stuff(...);
}

[danakj, 2015/05/14 22:35:00]

Ya you're very right and your suggestion is spot on. Fixed this.

+      remove_tile_data.invalid_content_rect.Union(content_rect);
+      Tile::Id old_id;
+      if (RemoveTileAt(iter.index_x(), iter.index_y(), &old_id))
+        remove_tile_data.invalid_id = old_id;
     }
   }
 
-  for (const auto& key : new_tile_keys)
-    CreateTile(key.first, key.second);
+  for (const auto& pair : remove_tiles) {
+    const TileMapKey& key = pair.first;
+    const RemoveTileData& remove_tile_data = pair.second;
+    Tile* tile = CreateTile(key.first, key.second);
+    tile->SetInvalidatedRect(remove_tile_data.invalid_content_rect);
+    tile->SetInvalidatedId(remove_tile_data.invalid_id);
+  }
 }
 
 void PictureLayerTiling::SetRasterSourceOnTiles() {
   if (tree_ == PENDING_TREE)
     return;
 
   for (TileMap::value_type& tile_pair : tiles_)
     tile_pair.second->set_raster_source(raster_source_.get());
 }
 
@@ skipping 185 matching lines @@
   texture_rect.Scale(dest_to_content_scale_,
                      dest_to_content_scale_);
   texture_rect.Intersect(gfx::Rect(tiling_->tiling_size()));
   if (texture_rect.IsEmpty())
     return texture_rect;
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
 
   return texture_rect;
 }
 
-bool PictureLayerTiling::RemoveTileAt(int i, int j) {
+bool PictureLayerTiling::RemoveTileAt(int i, int j, Tile::Id* id) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
   if (found == tiles_.end())
     return false;
+  if (id)
+    *id = found->second->id();
   tiles_.erase(found);
   return true;
 }
 
 void PictureLayerTiling::Reset() {
   live_tiles_rect_ = gfx::Rect();
   tiles_.clear();
 }
 
 gfx::Rect PictureLayerTiling::ComputeSkewport(
@@ skipping 137 matching lines @@
          gfx::Rect(tiling_size()).Contains(new_live_tiles_rect))
       << "tiling_size: " << tiling_size().ToString()
       << " new_live_tiles_rect: " << new_live_tiles_rect.ToString();
   if (live_tiles_rect_ == new_live_tiles_rect)
     return;
 
   // Iterate to delete all tiles outside of our new live_tiles rect.
   for (TilingData::DifferenceIterator iter(&tiling_data_, live_tiles_rect_,
                                            new_live_tiles_rect);
        iter; ++iter) {
-    RemoveTileAt(iter.index_x(), iter.index_y());
+    RemoveTileAt(iter.index_x(), iter.index_y(), nullptr);
   }
 
   // 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; ++iter) {
     TileMapKey key(iter.index());
     if (ShouldCreateTileAt(key.first, key.second))
       CreateTile(key.first, key.second);
   }
@@ skipping 378 matching lines @@
       break;
   }
 
   gfx::Rect result(origin_x, origin_y, width, height);
   if (cache)
     cache->previous_result = result;
   return result;
 }
 
 }  // namespace cc