cc: Move computing borderless max texture size to function.

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/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
 
 namespace cc {
+namespace {
 
-static int ComputeNumTiles(int max_texture_size,
-                           int total_size,
-                           int border_texels) {
+int ComputeNumTiles(int max_texture_size, int total_size, int border_texels) {
   if (max_texture_size - 2 * border_texels <= 0)
     return total_size > 0 && max_texture_size >= total_size ? 1 : 0;
 
   int num_tiles = std::max(1,
                            1 + (total_size - 1 - 2 * border_texels) /
                            (max_texture_size - 2 * border_texels));
   return total_size > 0 ? num_tiles : 0;
 }
 
+}  // namespace
+
 TilingData::TilingData()
     : border_texels_(0) {
   RecomputeNumTiles();
 }
 
 TilingData::TilingData(const gfx::Size& max_texture_size,
                        const gfx::Size& tiling_size,
                        bool has_border_texels)
     : max_texture_size_(max_texture_size),
       tiling_size_(tiling_size),
       border_texels_(has_border_texels ? 1 : 0) {
   RecomputeNumTiles();
 }
 
 TilingData::TilingData(const gfx::Size& max_texture_size,
                        const gfx::Size& tiling_size,
                        int border_texels)
     : max_texture_size_(max_texture_size),
       tiling_size_(tiling_size),
       border_texels_(border_texels) {
   RecomputeNumTiles();
 }
 
+TilingData::TilingData(const TilingData& other) = default;
+
+TilingData::~TilingData() = default;
+
 void TilingData::SetTilingSize(const gfx::Size& tiling_size) {
   tiling_size_ = tiling_size;
   RecomputeNumTiles();
 }
 
 void TilingData::SetMaxTextureSize(const gfx::Size& max_texture_size) {
   max_texture_size_ = max_texture_size;
   RecomputeNumTiles();
 }
 
 void TilingData::SetHasBorderTexels(bool has_border_texels) {
   border_texels_ = has_border_texels ? 1 : 0;
   RecomputeNumTiles();
 }
 
 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);
-  int x = (src_position - border_texels_) /
-      (max_texture_size_.width() - 2 * border_texels_);
+  int x =
+      (src_position - border_texels_) / borderless_max_texture_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);
-  int y = (src_position - border_texels_) /
-      (max_texture_size_.height() - 2 * border_texels_);
+  int y =
+      (src_position - border_texels_) / borderless_max_texture_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;
+  int x = (src_position - 2 * border_texels_) /
+          borderless_max_texture_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;
+  int y = (src_position - 2 * border_texels_) /
+          borderless_max_texture_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;
+  int x = src_position / borderless_max_texture_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;
+  int y = src_position / borderless_max_texture_size_.height();
   return std::min(std::max(y, 0), num_tiles_y_ - 1);
 }
 
 gfx::Rect TilingData::ExpandRectIgnoringBordersToTileBounds(
     const gfx::Rect& rect) const {
   if (rect.IsEmpty() || has_empty_bounds())
     return gfx::Rect();
   if (rect.x() > tiling_size_.width() || rect.y() > tiling_size_.height())
     return gfx::Rect();
   int index_x = TileXIndexFromSrcCoord(rect.x());
@@ skipping 18 matching lines @@
   int index_bottom = LastBorderTileYIndexFromSrcCoord(rect.bottom() - 1);
 
   gfx::Rect rect_top_left(TileBounds(index_x, index_y));
   gfx::Rect rect_bottom_right(TileBounds(index_right, index_bottom));
 
   return gfx::UnionRects(rect_top_left, rect_bottom_right);
 }
 
 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 lo_x = max_texture_size_x * i;
+  int lo_x = borderless_max_texture_size_.width() * i;
   if (i != 0)
     lo_x += border_texels_;
 
-  int lo_y = max_texture_size_y * j;
+  int lo_y = borderless_max_texture_size_.height() * j;
   if (j != 0)
     lo_y += border_texels_;
 
-  int hi_x = max_texture_size_x * (i + 1) + border_texels_;
+  int hi_x = borderless_max_texture_size_.width() * (i + 1) + border_texels_;
   if (i + 1 == num_tiles_x_)
     hi_x += border_texels_;
 
-  int hi_y = max_texture_size_y * (j + 1) + border_texels_;
+  int hi_y = borderless_max_texture_size_.height() * (j + 1) + border_texels_;
   if (j + 1 == num_tiles_y_)
     hi_y += border_texels_;
 
   hi_x = std::min(hi_x, tiling_size_.width());
   hi_y = std::min(hi_y, tiling_size_.height());
 
   int x = lo_x;
   int y = lo_y;
   int width = hi_x - lo_x;
   int height = hi_y - lo_y;
   DCHECK_GE(x, 0);
   DCHECK_GE(y, 0);
   DCHECK_GE(width, 0);
   DCHECK_GE(height, 0);
   DCHECK_LE(x, tiling_size_.width());
   DCHECK_LE(y, tiling_size_.height());
   return gfx::Rect(x, y, width, height);
 }
 
 gfx::Rect TilingData::TileBoundsWithBorder(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 lo_x = max_texture_size_x * i;
-  int lo_y = max_texture_size_y * j;
+  int lo_x = borderless_max_texture_size_.width() * i;
+  int lo_y = borderless_max_texture_size_.height() * j;
 
-  int hi_x = lo_x + max_texture_size_x + 2 * border_texels_;
-  int hi_y = lo_y + max_texture_size_y + 2 * border_texels_;
+  int hi_x = lo_x + borderless_max_texture_size_.width() + 2 * border_texels_;
+  int hi_y = lo_y + borderless_max_texture_size_.height() + 2 * border_texels_;
 
   hi_x = std::min(hi_x, tiling_size_.width());
   hi_y = std::min(hi_y, tiling_size_.height());
 
   int x = lo_x;
   int y = lo_y;
   int width = hi_x - lo_x;
   int height = hi_y - lo_y;
   DCHECK_GE(x, 0);
   DCHECK_GE(y, 0);
   DCHECK_GE(width, 0);
   DCHECK_GE(height, 0);
   DCHECK_LE(x, tiling_size_.width());
   DCHECK_LE(y, tiling_size_.height());
   return gfx::Rect(x, y, width, height);
 }
 
 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 = (borderless_max_texture_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 = (borderless_max_texture_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 tiling_size_.width();
   if (!x_index && num_tiles_x_ > 1)
     return max_texture_size_.width() - border_texels_;
   if (x_index < num_tiles_x_ - 1)
-    return max_texture_size_.width() - 2 * border_texels_;
+    return borderless_max_texture_size_.width();
   if (x_index == num_tiles_x_ - 1)
     return tiling_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 tiling_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 borderless_max_texture_size_.height();
   if (y_index == num_tiles_y_ - 1)
     return tiling_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() {
   num_tiles_x_ = ComputeNumTiles(
       max_texture_size_.width(), tiling_size_.width(), border_texels_);
   num_tiles_y_ = ComputeNumTiles(
       max_texture_size_.height(), tiling_size_.height(), border_texels_);
+
+  borderless_max_texture_size_.set_width(max_texture_size_.width() -
+                                         2 * border_texels_);
+  borderless_max_texture_size_.set_height(max_texture_size_.height() -
+                                          2 * border_texels_);
+  DCHECK_GE(borderless_max_texture_size_.width(), 0);
+  DCHECK_GE(borderless_max_texture_size_.height(), 0);
 }
 
 TilingData::BaseIterator::BaseIterator() : index_x_(-1), index_y_(-1) {
 }
 
 TilingData::Iterator::Iterator() {
   done();
 }
 
 TilingData::Iterator::Iterator(const TilingData* tiling_data,
@@ skipping 554 matching lines @@
 
     // We should always end up in an around rect at some point.
     // Since the direction is now vertical, we have to ensure that we will
     // advance.
     DCHECK_GE(horizontal_step_count_, 1);
     DCHECK_GE(vertical_step_count_, 1);
   }
 }
 
 }  // namespace cc