Use SkImage as a backing store for copying 2d Contexts to ImageBitmaps.

Source/core/html/canvas/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 1173 matching lines @@
 }
 
 static inline FloatRect normalizeRect(const FloatRect& rect)
 {
     return FloatRect(min(rect.x(), rect.maxX()),
         min(rect.y(), rect.maxY()),
         max(rect.width(), -rect.width()),
         max(rect.height(), -rect.height()));
 }
 
-void CanvasRenderingContext2D::drawImageInternal(Image* image, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator& op, const BlendMode& blendMode)
+template<class T> void CanvasRenderingContext2D::drawImageInternal(T* image, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator& op, const BlendMode& blendMode)
 {
     if (!image)
         return;
 
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
 
@@ skipping 48 matching lines @@
     FloatRect dstRect(dx, dy, dw, dh);
 
     if (!std::isfinite(dstRect.x()) || !std::isfinite(dstRect.y()) || !std::isfinite(dstRect.width()) || !std::isfinite(dstRect.height())
         || !std::isfinite(srcRect.x()) || !std::isfinite(srcRect.y()) || !std::isfinite(srcRect.width()) || !std::isfinite(srcRect.height()))
         return;
 
     if (!dstRect.width() || !dstRect.height())
         return;
 
     ASSERT(bitmap->height() && bitmap->width());
-
     FloatRect normalizedSrcRect = normalizeRect(srcRect);
     FloatRect normalizedDstRect = normalizeRect(dstRect);
-    FloatRect actualDstRect(FloatPoint(bitmap->bitmapOffset()), bitmap->bitmapSize());
-    actualDstRect.scale(normalizedDstRect.width() / bitmap->width(), normalizedDstRect.height() / bitmap->height());
-    actualDstRect.moveBy(normalizedDstRect.location());
 
     FloatRect imageRect = FloatRect(FloatPoint(), bitmap->bitmapSize());
     if (!srcRect.width() || !srcRect.height()) {
         ec = IndexSizeError;
         return;
     }
     if (!imageRect.contains(normalizedSrcRect))
         return;
 
-    Image* imageForRendering = bitmap->bitmapImage();
-
-    drawImageInternal(imageForRendering, normalizedSrcRect, actualDstRect, state().m_globalComposite, state().m_globalBlend);
+    if (bitmap->canvasImage()) {
+        FloatRect originalCropRect(bitmap->cropRect());
+        normalizedSrcRect.moveBy(originalCropRect.location());
+        FloatRect actualSrcRect = intersection(originalCropRect, normalizedSrcRect);
+        drawImageInternal(bitmap->canvasImage(), actualSrcRect, normalizedDstRect, state().m_globalComposite, state().m_globalBlend);
+    } else {
+        FloatRect actualDstRect(FloatPoint(bitmap->bitmapOffset()), bitmap->bitmapSize());
+        actualDstRect.scale(normalizedDstRect.width() / bitmap->width(), normalizedDstRect.height() / bitmap->height());
+        actualDstRect.moveBy(normalizedDstRect.location());
+        drawImageInternal(bitmap->bitmapImage().get(), normalizedSrcRect, actualDstRect, state().m_globalComposite, state().m_globalBlend);
+    }
 }
 
 void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, float x, float y, ExceptionCode& ec)
 {
     if (!image) {
         ec = TypeMismatchError;
         return;
     }
     LayoutSize s = size(image);
     drawImage(image, x, y, s.width(), s.height(), ec);
@@ skipping 313 matching lines @@
 
     c->drawImageBuffer(buffer, bufferRect.location(), state().m_globalComposite);
     c->restore();
 }
 
 static void drawImageToContext(Image* image, GraphicsContext* context, FloatRect& dest, const FloatRect& src, CompositeOperator op)
 {
     context->drawImage(image, dest, src, op);
 }
 
+static void drawImageToContext(SkImage* image, GraphicsContext* context, FloatRect& dest, const FloatRect& src, CompositeOperator op)

[Justin Novosad, 2013/07/22 15:35:41]

Don't use skia classes outside of core/platform/ unless there is no other way. 
Here we could take an ImageBitmap instead of SkImage.  Extracting the SkImage
should be taken care of in GraphicsContext.

+{
+    context->drawImage(image, dest, src, op);
+}
+
 static void drawImageToContext(ImageBuffer* imageBuffer, GraphicsContext* context, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
 {
     context->drawImageBuffer(imageBuffer, dest, src, op);
 }
 
 template<class T> void  CanvasRenderingContext2D::fullCanvasCompositedDrawImage(T* image, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
 {
     ASSERT(isFullCanvasCompositeMode(op));
 
     IntSize croppedOffset;
@@ skipping 677 matching lines @@
 }
 
 PassRefPtr<Canvas2DContextAttributes> CanvasRenderingContext2D::getContextAttributes() const
 {
     RefPtr<Canvas2DContextAttributes> attributes = Canvas2DContextAttributes::create();
     attributes->setAlpha(m_hasAlpha);
     return attributes.release();
 }
 
 } // namespace WebCore