Revert of Remove cullRect() from PaintOpBuffer.

third_party/WebKit/Source/core/svg/graphics/SVGImage.cpp

 /*
  * Copyright (C) 2006 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 325 matching lines @@
     DrawForContainer(builder.Context().Canvas(), flags, container_size, zoom,
                      tile, src_rect, url);
   }
   sk_sp<PaintRecord> record = builder.EndRecording();
 
   SkMatrix pattern_transform;
   pattern_transform.setTranslate(phase.X() + spaced_tile.X(),
                                  phase.Y() + spaced_tile.Y());
 
   PaintFlags flags;
-  flags.setShader(
-      MakePaintShaderRecord(record, spaced_tile, SkShader::kRepeat_TileMode,
-                            SkShader::kRepeat_TileMode, &pattern_transform));
+  flags.setShader(MakePaintShaderRecord(record, SkShader::kRepeat_TileMode,
+                                        SkShader::kRepeat_TileMode,
+                                        &pattern_transform, nullptr));
   // If the shader could not be instantiated (e.g. non-invertible matrix),
   // draw transparent.
   // Note: we can't simply bail, because of arbitrary blend mode.
   if (!flags.getShader())
     flags.setColor(SK_ColorTRANSPARENT);
 
   flags.setBlendMode(composite_op);
   flags.setColorFilter(sk_ref_sp(context.GetColorFilter()));
   context.DrawRect(dst_rect, flags);
 }
 
 sk_sp<SkImage> SVGImage::ImageForCurrentFrameForContainer(
     const KURL& url,
     const IntSize& container_size) {
   if (!page_)
     return nullptr;
 
   const FloatRect container_rect((FloatPoint()), FloatSize(container_size));
 
   PaintRecorder recorder;
   PaintCanvas* canvas = recorder.beginRecording(container_rect);
   DrawForContainer(canvas, PaintFlags(), container_rect.Size(), 1,
                    container_rect, container_rect, url);
 
   return SkImage::MakeFromPicture(
-      ToSkPicture(recorder.finishRecordingAsPicture(), container_rect),
+      ToSkPicture(recorder.finishRecordingAsPicture()),
       SkISize::Make(container_size.Width(), container_size.Height()), nullptr,
       nullptr, SkImage::BitDepth::kU8, SkColorSpace::MakeSRGB());
 }
 
 static bool DrawNeedsLayer(const PaintFlags& flags) {
   if (SkColorGetA(flags.getColor()) < 255)
     return true;
   return !flags.isSrcOver();
 }
 
 bool SVGImage::ApplyShaderInternal(PaintFlags& flags,
                                    const SkMatrix& local_matrix,
                                    const KURL& url) {
-  const IntSize size(ContainerSize());
+  const FloatSize size(ContainerSize());
   if (size.IsEmpty())
     return false;
 
-  IntRect bounds(IntPoint(), size);
+  FloatRect float_bounds(FloatPoint(), size);
+  const SkRect bounds(float_bounds);
 
   flags.setShader(MakePaintShaderRecord(
-      PaintRecordForCurrentFrame(bounds, url), bounds,
-      SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &local_matrix));
+      PaintRecordForCurrentFrame(float_bounds, url), SkShader::kRepeat_TileMode,
+      SkShader::kRepeat_TileMode, &local_matrix, &bounds));
 
   // Animation is normally refreshed in draw() impls, which we don't reach when
   // painting via shaders.
   StartAnimation();
 
   return true;
 }
 
 bool SVGImage::ApplyShader(PaintFlags& flags, const SkMatrix& local_matrix) {
   return ApplyShaderInternal(flags, local_matrix, KURL());
@@ skipping 24 matching lines @@
     const FloatRect& src_rect,
     RespectImageOrientationEnum should_respect_image_orientation,
     ImageClampingMode clamp_mode) {
   if (!page_)
     return;
 
   DrawInternal(canvas, flags, dst_rect, src_rect,
                should_respect_image_orientation, clamp_mode, KURL());
 }
 
-sk_sp<PaintRecord> SVGImage::PaintRecordForCurrentFrame(const IntRect& bounds,
+sk_sp<PaintRecord> SVGImage::PaintRecordForCurrentFrame(const FloatRect& bounds,
                                                         const KURL& url,
                                                         PaintCanvas* canvas) {
   DCHECK(page_);
   FrameView* view = ToLocalFrame(page_->MainFrame())->View();
   view->Resize(ContainerSize());
 
   // Always call processUrlFragment, even if the url is empty, because
   // there may have been a previous url/fragment that needs to be reset.
   view->ProcessUrlFragment(url);
 
   // If the image was reset, we need to rewind the timeline back to 0. This
   // needs to be done before painting, or else we wouldn't get the correct
   // reset semantics (we'd paint the "last" frame rather than the one at
   // time=0.) The reason we do this here and not in resetAnimation() is to
   // avoid setting timers from the latter.
   FlushPendingTimelineRewind();
 
-  PaintRecordBuilder builder(bounds, nullptr, nullptr, paint_controller_.get());
+  IntRect int_bounds(EnclosingIntRect(bounds));
+  PaintRecordBuilder builder(int_bounds, nullptr, nullptr,
+                             paint_controller_.get());
 
   view->UpdateAllLifecyclePhasesExceptPaint();
-  view->Paint(builder.Context(), CullRect(bounds));
+  view->Paint(builder.Context(), CullRect(int_bounds));
   DCHECK(!view->NeedsLayout());
 
   if (canvas) {
     builder.EndRecording(*canvas);
     return nullptr;
   }
   return builder.EndRecording();
 }
 
 void SVGImage::DrawInternal(PaintCanvas* canvas,
@@ skipping 17 matching lines @@
     FloatSize top_left_offset(src_rect.Location().X() * scale.Width(),
                               src_rect.Location().Y() * scale.Height());
     FloatPoint dest_offset = dst_rect.Location() - top_left_offset;
     AffineTransform transform =
         AffineTransform::Translation(dest_offset.X(), dest_offset.Y());
     transform.Scale(scale.Width(), scale.Height());
 
     canvas->save();
     canvas->clipRect(EnclosingIntRect(dst_rect));
     canvas->concat(AffineTransformToSkMatrix(transform));
-    PaintRecordForCurrentFrame(EnclosingIntRect(src_rect), url, canvas);
+    PaintRecordForCurrentFrame(src_rect, url, canvas);
     canvas->restore();
   }
 
   // Start any (SMIL) animations if needed. This will restart or continue
   // animations if preceded by calls to resetAnimation or stopAnimation
   // respectively.
   StartAnimation();
 }
 
 LayoutReplaced* SVGImage::EmbeddedReplacedContent() const {
@@ skipping 245 matching lines @@
 
   NOTREACHED();
   return kSizeAvailable;
 }
 
 String SVGImage::FilenameExtension() const {
   return "svg";
 }
 
 }  // namespace blink