Fixing tile grid size used by cc:Picture to make it respect current tile configuration

cc/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/tiling_data.h"
 
 #include <algorithm>
 
 #include "ui/gfx/rect.h"
 #include "ui/gfx/vector2d.h"
@@ skipping 50 matching lines @@
 
 void TilingData::SetBorderTexels(int border_texels) {
   border_texels_ = border_texels;
   RecomputeNumTiles();
 }
 
 int TilingData::TileXIndexFromSrcCoord(int src_position) const {
   if (num_tiles_x_ <= 1)
     return 0;
 
-  DCHECK_GT(max_texture_size_.width() - 2 * border_texels_, 0);
+  DCHECK_GT(inner_tile_size_.width(), 0);
   int x = (src_position - border_texels_) /
-      (max_texture_size_.width() - 2 * border_texels_);
+      (inner_tile_size_.width());
   return std::min(std::max(x, 0), num_tiles_x_ - 1);
 }
 
 int TilingData::TileYIndexFromSrcCoord(int src_position) const {
   if (num_tiles_y_ <= 1)
     return 0;
 
-  DCHECK_GT(max_texture_size_.height() - 2 * border_texels_, 0);
+  DCHECK_GT(inner_tile_size_.height(), 0);
   int y = (src_position - border_texels_) /
-      (max_texture_size_.height() - 2 * border_texels_);
+      (inner_tile_size_.height());
   return std::min(std::max(y, 0), num_tiles_y_ - 1);
 }
 
 int TilingData::FirstBorderTileXIndexFromSrcCoord(int src_position) const {
   if (num_tiles_x_ <= 1)
     return 0;
 
-  DCHECK_GT(max_texture_size_.width() - 2 * border_texels_, 0);
-  int inner_tile_size = max_texture_size_.width() - 2 * border_texels_;
-  int x = (src_position - 2 * border_texels_) / inner_tile_size;
+  DCHECK_GT(inner_tile_size_.width(), 0);
+  int x = (src_position - 2 * border_texels_) / inner_tile_size_.width();
   return std::min(std::max(x, 0), num_tiles_x_ - 1);
 }
 
 int TilingData::FirstBorderTileYIndexFromSrcCoord(int src_position) const {
   if (num_tiles_y_ <= 1)
     return 0;
 
-  DCHECK_GT(max_texture_size_.height() - 2 * border_texels_, 0);
-  int inner_tile_size = max_texture_size_.height() - 2 * border_texels_;
-  int y = (src_position - 2 * border_texels_) / inner_tile_size;
+  DCHECK_GT(inner_tile_size_.height(), 0);
+  int y = (src_position - 2 * border_texels_) / inner_tile_size_.height();
   return std::min(std::max(y, 0), num_tiles_y_ - 1);
 }
 
 int TilingData::LastBorderTileXIndexFromSrcCoord(int src_position) const {
   if (num_tiles_x_ <= 1)
     return 0;
 
-  DCHECK_GT(max_texture_size_.width() - 2 * border_texels_, 0);
-  int inner_tile_size = max_texture_size_.width() - 2 * border_texels_;
-  int x = src_position / inner_tile_size;
+  DCHECK_GT(inner_tile_size_.width(), 0);
+  int x = src_position / inner_tile_size_.width();
   return std::min(std::max(x, 0), num_tiles_x_ - 1);
 }
 
 int TilingData::LastBorderTileYIndexFromSrcCoord(int src_position) const {
   if (num_tiles_y_ <= 1)
     return 0;
 
-  DCHECK_GT(max_texture_size_.height() - 2 * border_texels_, 0);
-  int inner_tile_size = max_texture_size_.height() - 2 * border_texels_;
-  int y = src_position / inner_tile_size;
+  DCHECK_GT(inner_tile_size_.height(), 0);
+  int y = src_position / inner_tile_size_.height();
   return std::min(std::max(y, 0), num_tiles_y_ - 1);
 }
 
 gfx::Rect TilingData::TileBounds(int i, int j) const {
   AssertTile(i, j);
-  int max_texture_size_x = max_texture_size_.width() - 2 * border_texels_;
-  int max_texture_size_y = max_texture_size_.height() - 2 * border_texels_;
+  int max_texture_size_x = inner_tile_size_.width();
+  int max_texture_size_y = inner_tile_size_.height();
   int total_size_x = total_size_.width();
   int total_size_y = total_size_.height();
 
   int lo_x = max_texture_size_x * i;
   if (i != 0)
     lo_x += border_texels_;
 
   int lo_y = max_texture_size_y * j;
   if (j != 0)
     lo_y += border_texels_;
@@ skipping 44 matching lines @@
     bounds = gfx::Rect(x1, y1, x2 - x1, y2 - y1);
   }
 
   return bounds;
 }
 
 int TilingData::TilePositionX(int x_index) const {
   DCHECK_GE(x_index, 0);
   DCHECK_LT(x_index, num_tiles_x_);
 
-  int pos = (max_texture_size_.width() - 2 * border_texels_) * x_index;
+  int pos = inner_tile_size_.width() * x_index;
   if (x_index != 0)
     pos += border_texels_;
 
   return pos;
 }
 
 int TilingData::TilePositionY(int y_index) const {
   DCHECK_GE(y_index, 0);
   DCHECK_LT(y_index, num_tiles_y_);
 
-  int pos = (max_texture_size_.height() - 2 * border_texels_) * y_index;
+  int pos = inner_tile_size_.height() * y_index;
   if (y_index != 0)
     pos += border_texels_;
 
   return pos;
 }
 
 int TilingData::TileSizeX(int x_index) const {
   DCHECK_GE(x_index, 0);
   DCHECK_LT(x_index, num_tiles_x_);
 
   if (!x_index && num_tiles_x_ == 1)
     return total_size_.width();
   if (!x_index && num_tiles_x_ > 1)
     return max_texture_size_.width() - border_texels_;

[danakj, 2013/02/07 20:40:01]

I'm not sure about the inner_tile_size concept because it obscures lines like
this. Not all tiles are sized to be inner_tile_size.

I assumed inner meant inside border texels. But it's only true on "inner" tiles,
meaning they are not on the edge of the tiling.

   if (x_index < num_tiles_x_ - 1)
-    return max_texture_size_.width() - 2 * border_texels_;
+    return inner_tile_size_.width();
   if (x_index == num_tiles_x_ - 1)
     return total_size_.width() - TilePositionX(x_index);
 
   NOTREACHED();
   return 0;
 }
 
 int TilingData::TileSizeY(int y_index) const {
   DCHECK_GE(y_index, 0);
   DCHECK_LT(y_index, num_tiles_y_);
 
   if (!y_index && num_tiles_y_ == 1)
     return total_size_.height();
   if (!y_index && num_tiles_y_ > 1)
     return max_texture_size_.height() - border_texels_;
   if (y_index < num_tiles_y_ - 1)
-    return max_texture_size_.height() - 2 * border_texels_;
+    return inner_tile_size_.height();
   if (y_index == num_tiles_y_ - 1)
     return total_size_.height() - TilePositionY(y_index);
 
   NOTREACHED();
   return 0;
 }
 
 gfx::Vector2d TilingData::TextureOffset(int x_index, int y_index) const {
   int left = (!x_index || num_tiles_x_ == 1) ? 0 : border_texels_;
   int top = (!y_index || num_tiles_y_ == 1) ? 0 : border_texels_;
 
   return gfx::Vector2d(left, top);
 }
 
 void TilingData::RecomputeNumTiles() {
+  inner_tile_size_ = max_texture_size_;
+  inner_tile_size_.Enlarge(- 2 * border_texels_, - 2 * border_texels_);
   num_tiles_x_ = ComputeNumTiles(max_texture_size_.width(), total_size_.width(), border_texels_);
   num_tiles_y_ = ComputeNumTiles(max_texture_size_.height(), total_size_.height(), border_texels_);
 }
 
 TilingData::BaseIterator::BaseIterator(const TilingData* tiling_data)
     : tiling_data_(tiling_data),
       index_x_(-1),
       index_y_(-1) {
 }
 
@@ skipping 124 matching lines @@
     }
 
     if (index_y_ > consider_bottom_)
       done();
   }
 
   return *this;
 }
 
 }  // namespace cc