cc: Handle overflow/underflow in MathUtil::RoundUp/RoundDown functions.

cc/playback/pixel_ref_map.cc

 // Copyright 2015 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/playback/pixel_ref_map.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "cc/base/math_util.h"
@@ skipping 15 matching lines @@
 
   int min_x = std::numeric_limits<int>::max();
   int min_y = std::numeric_limits<int>::max();
   int max_x = 0;
   int max_y = 0;
 
   skia::DiscardablePixelRefList pixel_refs;
   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture, &pixel_refs);
   for (skia::DiscardablePixelRefList::const_iterator it = pixel_refs.begin();
        it != pixel_refs.end(); ++it) {
-    gfx::Point min(MathUtil::RoundDown(static_cast<int>(it->pixel_ref_rect.x()),
-                                       cell_size_.width()),
-                   MathUtil::RoundDown(static_cast<int>(it->pixel_ref_rect.y()),
-                                       cell_size_.height()));
-    gfx::Point max(MathUtil::RoundDown(
+    gfx::Point min(
+        MathUtil::UncheckedRoundDown(static_cast<int>(it->pixel_ref_rect.x()),
+                                     cell_size_.width()),
+        MathUtil::UncheckedRoundDown(static_cast<int>(it->pixel_ref_rect.y()),
+                                     cell_size_.height()));
+    gfx::Point max(MathUtil::UncheckedRoundDown(
                        static_cast<int>(std::ceil(it->pixel_ref_rect.right())),
                        cell_size_.width()),
-                   MathUtil::RoundDown(
+                   MathUtil::UncheckedRoundDown(
                        static_cast<int>(std::ceil(it->pixel_ref_rect.bottom())),
                        cell_size_.height()));
 
     for (int y = min.y(); y <= max.y(); y += cell_size_.height()) {
       for (int x = min.x(); x <= max.x(); x += cell_size_.width()) {
         PixelRefMapKey key(x, y);
         data_hash_map_[key].push_back(it->pixel_ref);
       }
     }
 
@@ skipping 87 matching lines @@
     return;
   }
 
   // First, subtract the layer origin as cells are stored in layer space.
   query_rect.Offset(-map_layer_rect_.OffsetFromOrigin());
 
   DCHECK(!target_pixel_ref_map_->cell_size_.IsEmpty());
   gfx::Size cell_size(target_pixel_ref_map_->cell_size_);
   // We have to find a cell_size aligned point that corresponds to
   // query_rect. Point is a multiple of cell_size.
-  min_point_ =
-      gfx::Point(MathUtil::RoundDown(query_rect.x(), cell_size.width()),
-                 MathUtil::RoundDown(query_rect.y(), cell_size.height()));
+  min_point_ = gfx::Point(
+      MathUtil::UncheckedRoundDown(query_rect.x(), cell_size.width()),
+      MathUtil::UncheckedRoundDown(query_rect.y(), cell_size.height()));
   max_point_ = gfx::Point(
-      MathUtil::RoundDown(query_rect.right() - 1, cell_size.width()),
-      MathUtil::RoundDown(query_rect.bottom() - 1, cell_size.height()));
+      MathUtil::UncheckedRoundDown(query_rect.right() - 1, cell_size.width()),
+      MathUtil::UncheckedRoundDown(query_rect.bottom() - 1,
+                                   cell_size.height()));
 
   // Limit the points to known pixel ref boundaries.
   min_point_ = gfx::Point(
       std::max(min_point_.x(), target_pixel_ref_map_->min_pixel_cell_.x()),
       std::max(min_point_.y(), target_pixel_ref_map_->min_pixel_cell_.y()));
   max_point_ = gfx::Point(
       std::min(max_point_.x(), target_pixel_ref_map_->max_pixel_cell_.x()),
       std::min(max_point_.y(), target_pixel_ref_map_->max_pixel_cell_.y()));
 
   // Make the current x be cell_size.width() less than min point, so that
   // the first increment will point at min_point_.
   current_x_ = min_point_.x() - cell_size.width();
   current_y_ = min_point_.y();
   if (current_y_ <= max_point_.y())
     ++(*this);
 }
 
 }  // namespace cc