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

cc/base/tiling_data.cc

 // Copyright 2010 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/base/tiling_data.h"
 
 #include <algorithm>
 
 #include "ui/gfx/rect.h"
 #include "ui/gfx/vector2d.h"
@@ skipping 295 matching lines @@
                                bool include_borders)
     : BaseIterator(tiling_data), left_(-1), right_(-1), bottom_(-1) {
   if (tiling_data_->num_tiles_x() <= 0 || tiling_data_->num_tiles_y() <= 0) {
     done();
     return;
   }
 
   gfx::Rect tiling_bounds_rect(tiling_data_->tiling_size());
   gfx::Rect rect(consider_rect);
   rect.Intersect(tiling_bounds_rect);
+  if (rect.IsEmpty()) {
+    done();
+    return;
+  }
 
   gfx::Rect top_left_tile;
   if (include_borders) {
     index_x_ = tiling_data_->FirstBorderTileXIndexFromSrcCoord(rect.x());
     index_y_ = tiling_data_->FirstBorderTileYIndexFromSrcCoord(rect.y());
     right_ = tiling_data_->LastBorderTileXIndexFromSrcCoord(rect.right() - 1);
     bottom_ = tiling_data_->LastBorderTileYIndexFromSrcCoord(rect.bottom() - 1);
     top_left_tile = tiling_data_->TileBoundsWithBorder(index_x_, index_y_);
   } else {
     index_x_ = tiling_data_->TileXIndexFromSrcCoord(rect.x());
@@ skipping 21 matching lines @@
     if (index_y_ > bottom_)
       done();
   }
 
   return *this;
 }
 
 TilingData::DifferenceIterator::DifferenceIterator(
     const TilingData* tiling_data,
     const gfx::Rect& consider_rect,
-    const gfx::Rect& ignore_rect)
+    const gfx::Rect& ignore_rect,
+    bool include_borders)
     : BaseIterator(tiling_data),
       consider_left_(-1),
       consider_top_(-1),
       consider_right_(-1),
       consider_bottom_(-1),
       ignore_left_(-1),
       ignore_top_(-1),
       ignore_right_(-1),
       ignore_bottom_(-1) {
   if (tiling_data_->num_tiles_x() <= 0 || tiling_data_->num_tiles_y() <= 0) {
     done();
     return;
   }
 
   gfx::Rect tiling_bounds_rect(tiling_data_->tiling_size());
   gfx::Rect consider(consider_rect);
   gfx::Rect ignore(ignore_rect);
   consider.Intersect(tiling_bounds_rect);
   ignore.Intersect(tiling_bounds_rect);
   if (consider.IsEmpty()) {
     done();
     return;
   }
 
-  consider_left_ =
-      tiling_data_->FirstBorderTileXIndexFromSrcCoord(consider.x());
-  consider_top_ =
-      tiling_data_->FirstBorderTileYIndexFromSrcCoord(consider.y());
-  consider_right_ =
-      tiling_data_->LastBorderTileXIndexFromSrcCoord(consider.right() - 1);
-  consider_bottom_ =
-      tiling_data_->LastBorderTileYIndexFromSrcCoord(consider.bottom() - 1);
+  if (include_borders) {
+    consider_left_ =
+        tiling_data_->FirstBorderTileXIndexFromSrcCoord(consider.x());
+    consider_top_ =
+        tiling_data_->FirstBorderTileYIndexFromSrcCoord(consider.y());
+    consider_right_ =
+        tiling_data_->LastBorderTileXIndexFromSrcCoord(consider.right() - 1);
+    consider_bottom_ =
+        tiling_data_->LastBorderTileYIndexFromSrcCoord(consider.bottom() - 1);
+  } else {
+    consider_left_ = tiling_data_->TileXIndexFromSrcCoord(consider.x());
+    consider_top_ = tiling_data_->TileYIndexFromSrcCoord(consider.y());
+    consider_right_ =
+        tiling_data_->TileXIndexFromSrcCoord(consider.right() - 1);
+    consider_bottom_ =
+        tiling_data_->TileYIndexFromSrcCoord(consider.bottom() - 1);
+  }
 
   if (!ignore.IsEmpty()) {
-    ignore_left_ =
-        tiling_data_->FirstBorderTileXIndexFromSrcCoord(ignore.x());
-    ignore_top_ =
-        tiling_data_->FirstBorderTileYIndexFromSrcCoord(ignore.y());
-    ignore_right_ =
-        tiling_data_->LastBorderTileXIndexFromSrcCoord(ignore.right() - 1);
-    ignore_bottom_ =
-        tiling_data_->LastBorderTileYIndexFromSrcCoord(ignore.bottom() - 1);
+    if (include_borders) {
+      ignore_left_ =
+          tiling_data_->FirstBorderTileXIndexFromSrcCoord(ignore.x());
+      ignore_top_ = tiling_data_->FirstBorderTileYIndexFromSrcCoord(ignore.y());
+      ignore_right_ =
+          tiling_data_->LastBorderTileXIndexFromSrcCoord(ignore.right() - 1);
+      ignore_bottom_ =
+          tiling_data_->LastBorderTileYIndexFromSrcCoord(ignore.bottom() - 1);
+    } else {
+      ignore_left_ = tiling_data_->TileXIndexFromSrcCoord(ignore.x());
+      ignore_top_ = tiling_data_->TileYIndexFromSrcCoord(ignore.y());
+      ignore_right_ = tiling_data_->TileXIndexFromSrcCoord(ignore.right() - 1);
+      ignore_bottom_ =
+          tiling_data_->TileYIndexFromSrcCoord(ignore.bottom() - 1);
+    }
 
     // Clamp ignore indices to consider indices.
     ignore_left_ = std::max(ignore_left_, consider_left_);
     ignore_top_ = std::max(ignore_top_, consider_top_);
     ignore_right_ = std::min(ignore_right_, consider_right_);
     ignore_bottom_ = std::min(ignore_bottom_, consider_bottom_);
   }
 
   if (ignore_left_ == consider_left_ && ignore_right_ == consider_right_ &&
       ignore_top_ == consider_top_ && ignore_bottom_ == consider_bottom_) {
@@ skipping 262 matching lines @@
   current_step_ = 0;
   direction_ = static_cast<Direction>((direction_ + 1) % 4);
 
   if (direction_ == RIGHT || direction_ == LEFT) {
     ++vertical_step_count_;
     ++horizontal_step_count_;
   }
 }
 
 }  // namespace cc