Take NativeImageSkia out behind the woodshed.

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 11 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/graphics/Image.h"
 
 #include "platform/Length.h"
 #include "platform/MIMETypeRegistry.h"
+#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/graphics/GraphicsContextStateSaver.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 "wtf/MainThread.h"
 #include "wtf/StdLibExtras.h"
 
 #include <math.h>
 
 namespace blink {
 
 Image::Image(ImageObserver* observer)
     : m_imageObserver(observer)
@@ skipping 163 matching lines @@
         drawPattern(ctxt, srcRect, tileScaleFactor, patternPhase, op, dstRect);
     }
 
     startAnimation();
 }
 
 void Image::drawPattern(GraphicsContext* context, const FloatRect& floatSrcRect, const FloatSize& scale,
     const FloatPoint& phase, SkXfermode::Mode op, const FloatRect& destRect, const IntSize& repeatSpacing)
 {
     TRACE_EVENT0("skia", "Image::drawPattern");
-    if (RefPtr<NativeImageSkia> bitmap = nativeImageForCurrentFrame())
-        bitmap->drawPattern(context, adjustForNegativeSize(floatSrcRect), scale, phase, op, destRect, repeatSpacing);
+    SkBitmap bitmap = bitmapForCurrentFrame();
+    if (!bitmap.isNull()) {
+        drawBitmapPattern(context, bitmap, adjustForNegativeSize(floatSrcRect), scale, phase, op, destRect, repeatSpacing);

[f(malita), 2015/03/15 00:32:45]

I think we could inline drawBitmapPattern here - I don't see any other callers.

[Stephen White, 2015/03/15 16:49:31]

Done. Also inlined drawBitmap() into BitmapImage, since that's its only caller.

+    }
+}
+
+void Image::drawBitmap(
+    GraphicsContext* context,
+    const SkBitmap& bitmap,
+    const SkRect& srcRect,
+    const SkRect& destRect,
+    SkXfermode::Mode op)
+{
+    TRACE_EVENT0("skia", "Image::drawBitmap");
+
+    bool isLazyDecoded = DeferredImageDecoder::isLazyDecoded(bitmap);
+    bool isOpaque = bitmap.isOpaque();
+
+    {
+        SkPaint paint;
+        int initialSaveCount = context->preparePaintForDrawRectToRect(&paint, srcRect, destRect, op, !isOpaque, isLazyDecoded, bitmap.isImmutable());
+        // We want to filter it if we decided to do interpolation above, or if
+        // there is something interesting going on with the matrix (like a rotation).
+        // Note: for serialization, we will want to subset the bitmap first so we
+        // don't send extra pixels.
+        context->drawBitmapRect(bitmap, &srcRect, destRect, &paint);
+        context->canvas()->restoreToCount(initialSaveCount);
+    }
+
+    if (isLazyDecoded)
+        PlatformInstrumentation::didDrawLazyPixelRef(bitmap.getGenerationID());
+}
+
+static SkBitmap createBitmapWithSpace(const SkBitmap& bitmap, int spaceWidth, int spaceHeight)
+{
+    SkImageInfo info = bitmap.info();
+    info = SkImageInfo::Make(info.width() + spaceWidth, info.height() + spaceHeight, info.colorType(), kPremul_SkAlphaType);
+
+    SkBitmap result;
+    result.allocPixels(info);
+    result.eraseColor(SK_ColorTRANSPARENT);
+    bitmap.copyPixelsTo(reinterpret_cast<uint8_t*>(result.getPixels()), result.rowBytes() * result.height(), result.rowBytes());
+
+    return result;
+}
+
+void Image::drawBitmapPattern(
+    GraphicsContext* context,
+    const SkBitmap& bitmap,
+    const FloatRect& floatSrcRect,
+    const FloatSize& scale,
+    const FloatPoint& phase,
+    SkXfermode::Mode compositeOp,
+    const FloatRect& destRect,
+    const IntSize& repeatSpacing)
+{
+    FloatRect normSrcRect = floatSrcRect;
+    normSrcRect.intersect(FloatRect(0, 0, bitmap.width(), bitmap.height()));
+    if (destRect.isEmpty() || normSrcRect.isEmpty())
+        return; // nothing to draw
+
+    SkMatrix localMatrix;
+    // We also need to translate it such that the origin of the pattern is the
+    // origin of the destination rect, which is what WebKit expects. Skia uses
+    // the coordinate system origin as the base for the pattern. If WebKit wants
+    // a shifted image, it will shift it from there using the localMatrix.
+    const float adjustedX = phase.x() + normSrcRect.x() * scale.width();
+    const float adjustedY = phase.y() + normSrcRect.y() * scale.height();
+    localMatrix.setTranslate(SkFloatToScalar(adjustedX), SkFloatToScalar(adjustedY));
+
+    // Because no resizing occurred, the shader transform should be
+    // set to the pattern's transform, which just includes scale.
+    localMatrix.preScale(scale.width(), scale.height());
+
+    SkBitmap bitmapToPaint;
+    bitmap.extractSubset(&bitmapToPaint, enclosingIntRect(normSrcRect));
+    if (!repeatSpacing.isZero()) {
+        SkScalar ctmScaleX = 1.0;
+        SkScalar ctmScaleY = 1.0;
+
+        if (!RuntimeEnabledFeatures::slimmingPaintEnabled()) {
+            AffineTransform ctm = context->getCTM();
+            ctmScaleX = ctm.xScale();
+            ctmScaleY = ctm.yScale();
+        }
+
+        bitmapToPaint = createBitmapWithSpace(
+            bitmapToPaint,
+            repeatSpacing.width() * ctmScaleX / scale.width(),
+            repeatSpacing.height() * ctmScaleY / scale.height());
+    }
+    RefPtr<SkShader> shader = adoptRef(SkShader::CreateBitmapShader(bitmapToPaint, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix));
+
+    bool isLazyDecoded = DeferredImageDecoder::isLazyDecoded(bitmap);
+    {
+        SkPaint paint;
+        int initialSaveCount = context->preparePaintForDrawRectToRect(&paint, floatSrcRect,
+            destRect, compositeOp, !bitmap.isOpaque(), isLazyDecoded, bitmap.isImmutable());
+        paint.setShader(shader.get());
+        context->drawRect(destRect, paint);
+        context->canvas()->restoreToCount(initialSaveCount);
+    }
+
+    if (isLazyDecoded)
+        PlatformInstrumentation::didDrawLazyPixelRef(bitmap.getGenerationID());
 }
 
 void Image::computeIntrinsicDimensions(Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio)
 {
     intrinsicRatio = size();
     intrinsicWidth = Length(intrinsicRatio.width(), Fixed);
     intrinsicHeight = Length(intrinsicRatio.height(), Fixed);
 }
 
 PassRefPtr<Image> Image::imageForDefaultFrame()
 {
     RefPtr<Image> image(this);
 
     return image.release();
 }
 
 PassRefPtr<SkImage> Image::skImage()
 {
     return nullptr;
 }
 
 } // namespace blink