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

cc/tiles/picture_layer_tiling_set.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/tiles/picture_layer_tiling_set.h"
 
 #include <limits>
 #include <set>
 #include <vector>
 
@@ skipping 367 matching lines @@
 }
 
 PictureLayerTilingSet::CoverageIterator::CoverageIterator(
     const PictureLayerTilingSet* set,
     float contents_scale,
     const gfx::Rect& content_rect,
     float ideal_contents_scale)
     : 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_) {
       if (ideal_tiling_ > 0)
         ideal_tiling_--;
       break;
     }
   }
 
-  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);
 }
 
 PictureLayerTilingSet::CoverageIterator::~CoverageIterator() {
 }
 
 gfx::Rect PictureLayerTilingSet::CoverageIterator::geometry_rect() const {
   if (!tiling_iter_) {
@@ skipping 23 matching lines @@
 }
 
 TileResolution PictureLayerTilingSet::CoverageIterator::resolution() const {
   const PictureLayerTiling* tiling = CurrentTiling();
   DCHECK(tiling);
   return tiling->resolution();
 }
 
 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;
   else if (current_tiling_)
     return current_tiling_ - 1;
   else
     return ideal_tiling_ + 1;
 }
 
 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;
 
   if (tiling_iter_)
     ++tiling_iter_;
 
   // Loop until we find a valid place to stop.
   while (true) {
     while (tiling_iter_ &&
@@ skipping 13 matching lines @@
       missing_region_.Clear();
       region_iter_ = Region::Iterator(current_region_);
 
       // All done and all filled.
       if (!region_iter_.has_rect()) {
         current_tiling_ = set_->tilings_.size();
         return *this;
       }
 
       // 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;
     }
 
     // Pop a rect off.  If there are no more tilings, then these will be
     // treated as geometry with null tiles that the caller can checkerboard.
     gfx::Rect last_rect = region_iter_.rect();
     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
     // again until we get to a valid one.
     tiling_iter_ = PictureLayerTiling::CoverageIterator(
         set_->tilings_[current_tiling_],
         contents_scale_,
         last_rect);
   }
 
   return *this;
 }
 
 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(
     base::trace_event::TracedValue* state) const {
   for (size_t i = 0; i < tilings_.size(); ++i) {
     state->BeginDictionary();
     tilings_[i]->AsValueInto(state);
     state->EndDictionary();
   }
 }
 
 size_t PictureLayerTilingSet::GPUMemoryUsageInBytes() const {
   size_t amount = 0;
   for (size_t i = 0; i < tilings_.size(); ++i)
     amount += tilings_[i]->GPUMemoryUsageInBytes();
   return amount;
 }
 
 PictureLayerTilingSet::TilingRange PictureLayerTilingSet::GetTilingRange(
     TilingRangeType type) const {
   // 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);
     if (tiling->resolution() == LOW_RESOLUTION)
       low_res_range = TilingRange(i, i + 1);
   }
 
   TilingRange range(0, 0);
   switch (type) {
     case HIGHER_THAN_HIGH_RES:
@@ skipping 11 matching lines @@
       // tiling discussion/fixes.
       if (high_res_range.start <= low_res_range.start)
         range = TilingRange(high_res_range.end, low_res_range.start);
       else
         range = TilingRange(low_res_range.end, high_res_range.start);
       break;
     case LOW_RES:
       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;
   }
 
   DCHECK_LE(range.start, range.end);
   return range;
 }
 
 }  // namespace cc