NOT FOR LANDING Pass URL to Image::draw

Source/platform/graphics/Image.cpp

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.  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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 21 matching lines @@
 #include "platform/PlatformInstrumentation.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "platform/TraceEvent.h"
 #include "platform/geometry/FloatPoint.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/FloatSize.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/DeferredImageDecoder.h"
 #include "platform/graphics/GraphicsContext.h"
+#include "platform/weborigin/KURL.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebData.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "wtf/MainThread.h"
 #include "wtf/StdLibExtras.h"
 
 #include <math.h>
 
@@ skipping 37 matching lines @@
     if (!m_encodedImageData.get())
         return true;
 
     int length = m_encodedImageData->size();
     if (!length)
         return true;
 
     return dataChanged(allDataReceived);
 }
 
-void Image::drawTiled(GraphicsContext* ctxt, const FloatRect& destRect, const FloatPoint& srcPoint, const FloatSize& scaledTileSize, SkXfermode::Mode op, const IntSize& repeatSpacing)
+void Image::drawTiled(GraphicsContext* ctxt, const FloatRect& destRect, const FloatPoint& srcPoint, const FloatSize& scaledTileSize,
+    const KURL& url, SkXfermode::Mode op, const IntSize& repeatSpacing)
 {
     FloatSize intrinsicTileSize = size();
     if (hasRelativeWidth())
         intrinsicTileSize.setWidth(scaledTileSize.width());
     if (hasRelativeHeight())
         intrinsicTileSize.setHeight(scaledTileSize.height());
 
     FloatSize scale(scaledTileSize.width() / intrinsicTileSize.width(),
                     scaledTileSize.height() / intrinsicTileSize.height());
 
     FloatSize actualTileSize(scaledTileSize.width() + repeatSpacing.width(), scaledTileSize.height() + repeatSpacing.height());
     FloatRect oneTileRect;
     oneTileRect.setX(destRect.x() + fmodf(fmodf(-srcPoint.x(), actualTileSize.width()) - actualTileSize.width(), actualTileSize.width()));
     oneTileRect.setY(destRect.y() + fmodf(fmodf(-srcPoint.y(), actualTileSize.height()) - actualTileSize.height(), actualTileSize.height()));
     oneTileRect.setSize(scaledTileSize);
 
     // Check and see if a single draw of the image can cover the entire area we are supposed to tile.
     if (oneTileRect.contains(destRect)) {
         FloatRect visibleSrcRect;
         visibleSrcRect.setX((destRect.x() - oneTileRect.x()) / scale.width());
         visibleSrcRect.setY((destRect.y() - oneTileRect.y()) / scale.height());
         visibleSrcRect.setWidth(destRect.width() / scale.width());
         visibleSrcRect.setHeight(destRect.height() / scale.height());
-        ctxt->drawImage(this, destRect, visibleSrcRect, op, DoNotRespectImageOrientation);
+        ctxt->drawImage(this, destRect, visibleSrcRect, url, op, DoNotRespectImageOrientation);
         return;
     }
 
     FloatRect tileRect(FloatPoint(), intrinsicTileSize);
-    drawPattern(ctxt, tileRect, scale, oneTileRect.location(), op, destRect, repeatSpacing);
+    drawPattern(ctxt, tileRect, scale, oneTileRect.location(), url, op, destRect, repeatSpacing);
 
     startAnimation();
 }
 
 // FIXME: Merge with the other drawTiled eventually, since we need a combination of both for some things.
 void Image::drawTiled(GraphicsContext* ctxt, const FloatRect& dstRect, const FloatRect& srcRect,
-    const FloatSize& providedTileScaleFactor, TileRule hRule, TileRule vRule, SkXfermode::Mode op)
+    const FloatSize& providedTileScaleFactor, const KURL& url, TileRule hRule, TileRule vRule, SkXfermode::Mode op)
 {
     // FIXME: We do not support 'space' yet. For now just map it to 'repeat'.
     if (hRule == SpaceTile)
         hRule = RepeatTile;
     if (vRule == SpaceTile)
         vRule = RepeatTile;
 
     // FIXME: if this code is used for background-repeat: round (in addition to
     // border-image-repeat), then add logic to deal with the background-size: auto
     // special case. The aspect ratio should be maintained in this case.
@@ skipping 22 matching lines @@
     float scaledTileHeight = tileScaleFactor.height() * srcRect.height();
     if (hRule == Image::RepeatTile)
         hPhase -= (dstRect.width() - scaledTileWidth) / 2;
     if (vRule == Image::RepeatTile)
         vPhase -= (dstRect.height() - scaledTileHeight) / 2;
     FloatPoint patternPhase(dstRect.x() - hPhase, dstRect.y() - vPhase);
 
     if (useLowInterpolationQuality) {
         InterpolationQuality previousInterpolationQuality = ctxt->imageInterpolationQuality();
         ctxt->setImageInterpolationQuality(InterpolationLow);
-        drawPattern(ctxt, srcRect, tileScaleFactor, patternPhase, op, dstRect);
+        drawPattern(ctxt, srcRect, tileScaleFactor, patternPhase, KURL(), op, dstRect); // TODO(davve): empty url
         ctxt->setImageInterpolationQuality(previousInterpolationQuality);
     } else {
-        drawPattern(ctxt, srcRect, tileScaleFactor, patternPhase, op, dstRect);
+        drawPattern(ctxt, srcRect, tileScaleFactor, patternPhase, KURL(), op, dstRect); // TODO(davve): empty url
     }
 
     startAnimation();
 }
 
 namespace {
 
 PassRefPtr<SkShader> createPatternShader(const SkImage* image, const SkMatrix& shaderMatrix,
     const SkPaint& paint, const FloatSize& spacing)
 {
@@ skipping 11 matching lines @@
     canvas->drawImage(image, 0, 0, &paint);
     RefPtr<const SkPicture> picture = adoptRef(recorder.endRecordingAsPicture());
 
     return adoptRef(SkShader::CreatePictureShader(
         picture.get(), SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &shaderMatrix, nullptr));
 }
 
 } // anonymous namespace
 
 void Image::drawPattern(GraphicsContext* context, const FloatRect& floatSrcRect, const FloatSize& scale,
-    const FloatPoint& phase, SkXfermode::Mode compositeOp, const FloatRect& destRect, const IntSize& repeatSpacing)
+    const FloatPoint& phase, const KURL& url, SkXfermode::Mode compositeOp, const FloatRect& destRect, const IntSize& repeatSpacing)
 {
     TRACE_EVENT0("skia", "Image::drawPattern");
 
     RefPtr<SkImage> image = imageForCurrentFrame();
     if (!image)
         return;
 
     FloatRect normSrcRect = floatSrcRect;
 
     normSrcRect.intersect(FloatRect(0, 0, image->width(), image->height()));
@@ skipping 52 matching lines @@
 }
 
 bool Image::deprecatedBitmapForCurrentFrame(SkBitmap* bitmap)
 {
     RefPtr<SkImage> image = imageForCurrentFrame();
 
     return image && image->asLegacyBitmap(bitmap, SkImage::kRO_LegacyBitmapMode);
 }
 
 } // namespace blink