Refactoring source image usage in CanvasRenderingContext2D

Source/core/html/HTMLImageElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 13 matching lines @@
 #include "core/html/HTMLImageElement.h"
 
 #include "CSSPropertyNames.h"
 #include "HTMLNames.h"
 #include "RuntimeEnabledFeatures.h"
 #include "bindings/v8/ScriptEventListener.h"
 #include "core/dom/Attribute.h"
 #include "core/events/ThreadLocalEventNames.h"
 #include "core/fetch/ImageResource.h"
 #include "core/html/HTMLAnchorElement.h"
+#include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLFormElement.h"
+#include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/html/parser/HTMLSrcsetParser.h"
 #include "core/rendering/RenderImage.h"
 
 using namespace std;
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
@@ skipping 358 matching lines @@
         return 0;
 
     return m_imageLoader.image()->image();
 }
 
 bool HTMLImageElement::isInteractiveContent() const
 {
     return fastHasAttribute(usemapAttr);
 }
 
+PassRefPtr<Image> HTMLImageElement::getSourceImageForCanvas(HTMLCanvasElement* canvas, ExceptionState& exceptionState, CanvasImageSourceUsage usage, bool* isVolatile) const
+{
+    if (isVolatile)
+        *isVolatile = false;
+    if (cachedImage() && cachedImage()->errorOccurred()) {
+        exceptionState.throwDOMException(InvalidStateError, "The HTMLImageElement provided is in the 'broken' state.");
+        return nullptr;
+    }
+
+    if (!complete()) {
+        return nullptr;
+    }
+
+    if (!cachedImage()) {
+        return usage == DrawCanvasImageSourceUsage ? Image::nullImage() : PassRefPtr<Image>();
+    }
+
+    RefPtr<Image> sourceImage = cachedImage()->imageForRenderer(renderer());
+
+    // We need to synthesize a container size if a renderer is not available to provide one.
+    if (!renderer() && sourceImage->usesContainerSize())
+        sourceImage->setContainerSize(sourceImage->size());
+
+    return sourceImage.release();
 }
+
+bool HTMLImageElement::wouldTaintOrigin(CanvasRenderingContext* dst) const

[Stephen White, 2014/02/27 18:53:41]

It seems unfortunate to add a dependency on CanvasRenderingContext (and
HTMLCanvasElement) here. Could we just pass the security origin, and possibly an
interface for querying back the origin by URL instead? (or move the latter up to
a different common class, as you suggested.)

+{
+    ImageResource* image = cachedImage();
+    if (!image)
+        return false;
+    return !image->isAccessAllowed(dst->canvas()->securityOrigin());
+}
+
+FloatSize HTMLImageElement::sourceSize() const
+{
+    ImageResource* image = cachedImage();
+    if (!image)
+        return FloatSize();
+    LayoutSize size;
+    size = image->imageSizeForRenderer(renderer(), 1.0f); // FIXME: Not sure about this.
+
+    return size;
+}
+
+FloatSize HTMLImageElement::defaultDestinationSize() const
+{
+    ImageResource* image = cachedImage();
+    if (!image)
+        return FloatSize();
+    LayoutSize size;
+    size = image->imageSizeForRenderer(renderer(), 1.0f); // FIXME: Not sure about this.
+    if (renderer() && renderer()->isRenderImage() && image->image() && !image->image()->hasRelativeWidth())
+        size.scale(toRenderImage(renderer())->imageDevicePixelRatio());
+    return size;
+}
+
+}