cc: Remove and Create the correct tiles when resizing live tiles rect

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>
 
@@ skipping 487 matching lines @@
 
   last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
   last_visible_rect_in_content_space_ = visible_rect_in_content_space;
 
   eviction_tiles_cache_valid_ = false;
 
   TilePriority now_priority(resolution_, TilePriority::NOW, 0);
   float content_to_screen_scale = ideal_contents_scale / contents_scale_;
 
   // Assign now priority to all visible tiles.
   bool include_borders = true;

[enne (OOO), 2014/08/26 18:56:45]

I guess really it's a question of why we include borders when prioritizing
visible tiles.  If a tile's non-border pixels are not in the visible rect, that
tile is not going to get drawn.  It seems like this is wrong, and if this flips,
then the other uses below of include_borders should also flip (I think).

[danakj, 2014/08/26 19:29:34]

Ok I am happy to make this false everywhere then. I agree doing it to all the
places below is correct.

   has_visible_rect_tiles_ = false;
   for (TilingData::Iterator iter(
            &tiling_data_, visible_rect_in_content_space, include_borders);
        iter;
        ++iter) {
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
     has_visible_rect_tiles_ = true;
     Tile* tile = find->second.get();
 
     tile->SetPriority(tree, now_priority);
 
     // Set whether tile is occluded or not.
     bool is_occluded = false;
     if (occlusion_tracker) {
       gfx::Rect tile_query_rect = ScaleToEnclosingRect(
           IntersectRects(tile->content_rect(), visible_rect_in_content_space),
           1.0f / contents_scale_);
       // TODO(vmpstr): Remove render_target and draw_transform from the
       // parameters so they can be hidden from the tiling.
       is_occluded = occlusion_tracker->Occluded(
           render_target, tile_query_rect, draw_transform);
     }
     tile->set_is_occluded(tree, is_occluded);
   }
 
-  // Assign soon priority to skewport tiles.
+  // Assign soon priority to skewport tiles. Include borders to also prioritize
+  // tiles whose borders are in the skewport, and to exclude tiles whose borders
+  // are in the visible rect, since those are handled above.
   has_skewport_rect_tiles_ = false;
-  for (TilingData::DifferenceIterator iter(
-           &tiling_data_, skewport, visible_rect_in_content_space);
+  for (TilingData::DifferenceIterator iter(&tiling_data_,
+                                           skewport,
+                                           visible_rect_in_content_space,
+                                           include_borders);
        iter;
        ++iter) {
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
     has_skewport_rect_tiles_ = true;
     Tile* tile = find->second.get();
 
     gfx::Rect tile_bounds =
         tiling_data_.TileBounds(iter.index_x(), iter.index_y());
 
     float distance_to_visible =
         visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
         content_to_screen_scale;
 
     TilePriority priority(resolution_, TilePriority::SOON, distance_to_visible);
     tile->SetPriority(tree, priority);
   }
 
-  // Assign eventually priority to interest rect tiles.
+  // Assign eventually priority to interest rect tiles. Include borders to
+  // also prioritize tiles whose borders are in the eventually rect and exclude
+  // tiles whose borders are in the skewport, as those are handled above.
   has_eventually_rect_tiles_ = false;
   for (TilingData::DifferenceIterator iter(
-           &tiling_data_, eventually_rect, skewport);
+           &tiling_data_, eventually_rect, skewport, include_borders);
        iter;
        ++iter) {
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
     has_eventually_rect_tiles_ = true;
     Tile* tile = find->second.get();
 
     gfx::Rect tile_bounds =
         tiling_data_.TileBounds(iter.index_x(), iter.index_y());
 
     float distance_to_visible =
         visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
         content_to_screen_scale;
     TilePriority priority(
         resolution_, TilePriority::EVENTUALLY, distance_to_visible);
     tile->SetPriority(tree, priority);
   }
 
-  // Upgrade the priority on border tiles to be SOON.
+  // Upgrade the priority on border tiles to be SOON. Include borders to include
+  // tiles whose borders are in the soon_border_rect and exclude those with
+  // borders in the skewport, as those are handled above.
   gfx::Rect soon_border_rect = visible_rect_in_content_space;
   float border = kSoonBorderDistanceInScreenPixels / content_to_screen_scale;
   soon_border_rect.Inset(-border, -border, -border, -border);
   has_soon_border_rect_tiles_ = false;
   for (TilingData::DifferenceIterator iter(
-           &tiling_data_, soon_border_rect, skewport);
+           &tiling_data_, soon_border_rect, skewport, include_borders);
        iter;
        ++iter) {
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
     has_soon_border_rect_tiles_ = true;
     Tile* tile = find->second.get();
 
     TilePriority priority(resolution_,
                           TilePriority::SOON,
@@ skipping 10 matching lines @@
 
 void PictureLayerTiling::SetLiveTilesRect(
     const gfx::Rect& new_live_tiles_rect) {
   DCHECK(new_live_tiles_rect.IsEmpty() ||
          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.
+  // Iterate to delete all tiles outside of our new live_tiles rect. Iterate
+  // without borders to avoid including tiles that have only border pixels
+  // outside the new live tiles rect.
+  bool include_borders = false;
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            live_tiles_rect_,
-                                           new_live_tiles_rect);
+                                           new_live_tiles_rect,
+                                           include_borders);
        iter;
        ++iter) {
     TileMapKey key(iter.index());
     TileMap::iterator found = tiles_.find(key);
     // If the tile was outside of the recorded region, it won't exist even
     // though it was in the live rect.
     if (found != tiles_.end()) {
       ReleaseTile(found->second.get(), client_->GetTree());
       tiles_.erase(found);
     }
   }
 
   const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
 
   // Iterate to allocate new tiles for all regions with newly exposed area.
+  // Do the iteration without borders to avoid adding tiles that already exist
+  // for tiles whose border pixels are in the new live tiles rect.
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            new_live_tiles_rect,
-                                           live_tiles_rect_);
+                                           live_tiles_rect_,
+                                           include_borders);
        iter;
        ++iter) {
     TileMapKey key(iter.index());
     CreateTile(key.first, key.second, twin_tiling);
   }
 
   live_tiles_rect_ = new_live_tiles_rect;
 }
 
 void PictureLayerTiling::DidBecomeRecycled() {
@@ skipping 438 matching lines @@
   DCHECK(*this);
   do {
     ++current_eviction_tiles_index_;
   } while (current_eviction_tiles_index_ != eviction_tiles_->size() &&
            !(*eviction_tiles_)[current_eviction_tiles_index_]->HasResources());
 
   return *this;
 }
 
 }  // namespace cc