cc: Do a safe intersect when gathering images.

cc/playback/discardable_image_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/discardable_image_map.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/adapters.h"
 #include "cc/base/math_util.h"
 #include "cc/playback/display_item_list.h"
 #include "third_party/skia/include/utils/SkNWayCanvas.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 
 SkRect MapRect(const SkMatrix& matrix, const SkRect& src) {
   SkRect dst;
   matrix.mapRect(&dst, src);
   return dst;
 }
 
+// Returns a rect clamped to |max_size|. Note that |paint_rect| should intersect

[enne (OOO), 2016/08/09 18:23:42]

Can you DCHECK this too just for sanity's sake?

Also, I think you mean "|paint_rect| should be contained by..." and not "should
intersect"

+// a rect defined by (0, 0) and |max_size|.
+gfx::Rect SafeClampPaintRectToSize(const SkRect& paint_rect,
+                                   const gfx::Size& max_size) {
+  // bounds_rect.x() + bounds_rect.width() (aka bounds_rect.right()) might
+  // overflow integer bounds, so do custom intersect, since gfx::Rect::Intersect
+  // uses bounds_rect.right().
+  gfx::RectF bounds_rect = gfx::SkRectToRectF(paint_rect);
+  bounds_rect.set_x(std::max(0.f, bounds_rect.x()));
+  bounds_rect.set_y(std::max(0.f, bounds_rect.y()));
+  bounds_rect.set_width(
+      std::min(bounds_rect.width(), max_size.width() - bounds_rect.x()));
+  bounds_rect.set_height(
+      std::min(bounds_rect.height(), max_size.height() - bounds_rect.y()));
+  return gfx::ToEnclosingRect(bounds_rect);
+}
+
 namespace {
 
 // We're using an NWay canvas with no added canvases, so in effect
 // non-overridden functions are no-ops.
 class DiscardableImagesMetadataCanvas : public SkNWayCanvas {
  public:
   DiscardableImagesMetadataCanvas(
       int width,
       int height,
       std::vector<std::pair<DrawImage, gfx::Rect>>* image_set)
       : SkNWayCanvas(width, height),
         image_set_(image_set),
-        canvas_bounds_(SkRect::MakeIWH(width, height)) {}
+        canvas_bounds_(SkRect::MakeIWH(width, height)),
+        canvas_size_(width, height) {}
 
  protected:
   // we need to "undo" the behavior of SkNWayCanvas, which will try to forward
   // it.
   void onDrawPicture(const SkPicture* picture,
                      const SkMatrix* matrix,
                      const SkPaint* paint) override {
     SkCanvas::onDrawPicture(picture, matrix, paint);
   }
 
@@ skipping 89 matching lines @@
 
     SkFilterQuality filter_quality = kNone_SkFilterQuality;
     if (paint) {
       filter_quality = paint->getFilterQuality();
     }
 
     SkIRect src_irect;
     src_rect.roundOut(&src_irect);
     image_set_->push_back(std::make_pair(
         DrawImage(std::move(image), src_irect, filter_quality, matrix),
-        gfx::ToEnclosingRect(gfx::SkRectToRectF(paint_rect))));
+        SafeClampPaintRectToSize(paint_rect, canvas_size_)));
   }
 
   std::vector<std::pair<DrawImage, gfx::Rect>>* image_set_;
   const SkRect canvas_bounds_;
+  const gfx::Size canvas_size_;
   std::vector<SkPaint> saved_paints_;
 };
 
 }  // namespace
 
 DiscardableImageMap::DiscardableImageMap() {}
 
 DiscardableImageMap::~DiscardableImageMap() {}
 
 sk_sp<SkCanvas> DiscardableImageMap::BeginGeneratingMetadata(
@@ skipping 24 matching lines @@
     DiscardableImageMap* image_map,
     const gfx::Size& bounds)
     : image_map_(image_map),
       metadata_canvas_(image_map->BeginGeneratingMetadata(bounds)) {}
 
 DiscardableImageMap::ScopedMetadataGenerator::~ScopedMetadataGenerator() {
   image_map_->EndGeneratingMetadata();
 }
 
 }  // namespace cc