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;
 }
 
+gfx::Rect SafeIntersectRects(const SkRect& paint_rect,
+                             const gfx::Rect& max_bounds) {
+  DCHECK_EQ(0, max_bounds.x());

[enne (OOO), 2016/08/08 21:54:01]

How about just passing a gfx::Size? If that makes SafeIntersectRects confusing
what about just "SafeClampPaintRectToSize"

[vmpstr, 2016/08/08 22:25:14]

Done.

+  DCHECK_EQ(0, max_bounds.y());
+
+  // 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_bounds.width() - bounds_rect.x()));

[enne (OOO), 2016/08/08 21:54:01]

Can this be negative if the paint offset is outside the max_bounds / canvas
rect?

[vmpstr, 2016/08/08 22:25:14]

That shouldn't be possible since there's an early out where we reject any rects
that fall outside of canvas bounds already. I've added a comment to this
function to make this clear. 

+  bounds_rect.set_height(
+      std::min(bounds_rect.height(), max_bounds.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)),
+        int_canvas_bounds_(
+            gfx::ToEnclosingRect(gfx::SkRectToRectF(canvas_bounds_))) {}
 
  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))));
+        SafeIntersectRects(paint_rect, int_canvas_bounds_)));
   }
 
   std::vector<std::pair<DrawImage, gfx::Rect>>* image_set_;
   const SkRect canvas_bounds_;
+  const gfx::Rect int_canvas_bounds_;
   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