cc: Fix size_t to int truncations in tiles/ and trees/

cc/tiles/picture_layer_tiling_set.cc

Index: cc/tiles/picture_layer_tiling_set.cc
diff --git a/cc/tiles/picture_layer_tiling_set.cc b/cc/tiles/picture_layer_tiling_set.cc
index 416eefc5ab507599ab5abdf8393c3c2734c5f145..dcb7759c34fa3097e04bf630c13d9e9fed8c2d76 100644
--- a/cc/tiles/picture_layer_tiling_set.cc
+++ b/cc/tiles/picture_layer_tiling_set.cc
@@ -385,11 +385,10 @@ PictureLayerTilingSet::CoverageIterator::CoverageIterator(
     : set_(set),
       contents_scale_(contents_scale),
       ideal_contents_scale_(ideal_contents_scale),
-      current_tiling_(-1) {
+      current_tiling_(std::numeric_limits<size_t>::max()) {
   missing_region_.Union(content_rect);
 
-  for (ideal_tiling_ = 0;
-       static_cast<size_t>(ideal_tiling_) < set_->tilings_.size();
+  for (ideal_tiling_ = 0; ideal_tiling_ < set_->tilings_.size();

[danakj, 2015/06/09 17:39:49]

can you cache the size up here so we only call it once?

[vmpstr, 2015/06/09 18:37:17]

Done.

        ++ideal_tiling_) {
     PictureLayerTiling* tiling = set_->tilings_[ideal_tiling_];
     if (tiling->contents_scale() < ideal_contents_scale_) {
@@ -399,11 +398,7 @@ PictureLayerTilingSet::CoverageIterator::CoverageIterator(
     }
   }
 
-  DCHECK_LE(set_->tilings_.size(),
-            static_cast<size_t>(std::numeric_limits<int>::max()));
-
-  int num_tilings = set_->tilings_.size();
-  if (ideal_tiling_ == num_tilings && ideal_tiling_ > 0)
+  if (ideal_tiling_ == set->tilings_.size() && ideal_tiling_ > 0)
     ideal_tiling_--;
 
   ++(*this);
@@ -447,20 +442,20 @@ TileResolution PictureLayerTilingSet::CoverageIterator::resolution() const {
 
 PictureLayerTiling* PictureLayerTilingSet::CoverageIterator::CurrentTiling()
     const {
-  if (current_tiling_ < 0)
+  if (current_tiling_ == std::numeric_limits<size_t>::max())
     return NULL;
   if (static_cast<size_t>(current_tiling_) >= set_->tilings_.size())
     return NULL;
   return set_->tilings_[current_tiling_];
 }
 
-int PictureLayerTilingSet::CoverageIterator::NextTiling() const {
+size_t PictureLayerTilingSet::CoverageIterator::NextTiling() const {
   // Order returned by this method is:
   // 1. Ideal tiling index
   // 2. Tiling index < Ideal in decreasing order (higher res than ideal)
   // 3. Tiling index > Ideal in increasing order (lower res than ideal)
   // 4. Tiling index > tilings.size() (invalid index)
-  if (current_tiling_ < 0)
+  if (current_tiling_ == std::numeric_limits<size_t>::max())
     return ideal_tiling_;
   else if (current_tiling_ > ideal_tiling_)
     return current_tiling_ + 1;
@@ -472,7 +467,7 @@ int PictureLayerTilingSet::CoverageIterator::NextTiling() const {
 
 PictureLayerTilingSet::CoverageIterator&
 PictureLayerTilingSet::CoverageIterator::operator++() {
-  bool first_time = current_tiling_ < 0;
+  bool first_time = current_tiling_ == std::numeric_limits<size_t>::max();
 
   if (!*this && !first_time)
     return *this;
@@ -506,7 +501,7 @@ PictureLayerTilingSet::CoverageIterator::operator++() {
       }
 
       // No more valid tiles, return this checkerboard rect.
-      if (current_tiling_ >= static_cast<int>(set_->tilings_.size()))
+      if (current_tiling_ >= set_->tilings_.size())
         return *this;
     }
 
@@ -516,7 +511,7 @@ PictureLayerTilingSet::CoverageIterator::operator++() {
     region_iter_.next();
 
     // Done, found next checkerboard rect to return.
-    if (current_tiling_ >= static_cast<int>(set_->tilings_.size()))
+    if (current_tiling_ >= set_->tilings_.size())
       return *this;
 
     // Construct a new iterator for the next tiling, but we need to loop
@@ -531,8 +526,7 @@ PictureLayerTilingSet::CoverageIterator::operator++() {
 }
 
 PictureLayerTilingSet::CoverageIterator::operator bool() const {
-  return current_tiling_ < static_cast<int>(set_->tilings_.size()) ||
-      region_iter_.has_rect();
+  return current_tiling_ < set_->tilings_.size() || region_iter_.has_rect();
 }
 
 void PictureLayerTilingSet::AsValueInto(
@@ -556,9 +550,12 @@ PictureLayerTilingSet::TilingRange PictureLayerTilingSet::GetTilingRange(
   // Doesn't seem to be the case right now but if it ever becomes a performance
   // problem to compute these ranges each time this function is called, we can
   // compute them only when the tiling set has changed instead.
+  DCHECK_LE(tilings_.size(),

[danakj, 2015/06/09 17:39:49]

Wat. You went to all the trouble to use size_t everywhere, then DCHECK the size
is small here? How come?

[vmpstr, 2015/06/09 18:37:17]

I have fixed this.

+            static_cast<size_t>(std::numeric_limits<int>::max()));
+  int tilings_size = static_cast<int>(tilings_.size());
   TilingRange high_res_range(0, 0);
   TilingRange low_res_range(tilings_.size(), tilings_.size());
-  for (size_t i = 0; i < tilings_.size(); ++i) {
+  for (int i = 0; i < tilings_size; ++i) {
     const PictureLayerTiling* tiling = tilings_[i];
     if (tiling->resolution() == HIGH_RESOLUTION)
       high_res_range = TilingRange(i, i + 1);
@@ -590,7 +587,7 @@ PictureLayerTilingSet::TilingRange PictureLayerTilingSet::GetTilingRange(
       range = low_res_range;
       break;
     case LOWER_THAN_LOW_RES:
-      range = TilingRange(low_res_range.end, tilings_.size());
+      range = TilingRange(low_res_range.end, tilings_size);
       break;
   }