Adds SVGImageElement as a ImageBitmapSource

third_party/WebKit/Source/core/html/canvas/HTMLAndSVGImageElementSource.cpp

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "core/html/canvas/CanvasImageElementSource.h"
+#include "core/html/canvas/HTMLAndSVGImageElementSource.h"
 
+#include "core/frame/ImageBitmap.h"
+#include "core/frame/LocalDOMWindow.h"
 #include "core/layout/LayoutObject.h"
 #include "core/loader/ImageLoader.h"
 #include "core/svg/graphics/SVGImageForContainer.h"
 
 namespace blink {
 
-ImageResourceContent* CanvasImageElementSource::cachedImage() const {
+ImageResourceContent* HTMLAndSVGImageElementSource::cachedImage() const {
   return imageLoader().image();
 }
 
-const Element& CanvasImageElementSource::element() const {
+const Element& HTMLAndSVGImageElementSource::element() const {
   return *imageLoader().element();
 }
 
-bool CanvasImageElementSource::isSVGSource() const {
+bool HTMLAndSVGImageElementSource::isSVGSource() const {
   return cachedImage() && cachedImage()->getImage()->isSVGImage();
 }
 
-PassRefPtr<Image> CanvasImageElementSource::getSourceImageForCanvas(
+PassRefPtr<Image> HTMLAndSVGImageElementSource::getSourceImageForCanvas(
     SourceImageStatus* status,
     AccelerationHint,
     SnapshotReason,
     const FloatSize& defaultObjectSize) const {
   if (!imageLoader().imageComplete() || !cachedImage()) {
     *status = IncompleteSourceImageStatus;
     return nullptr;
   }
 
   if (cachedImage()->errorOccurred()) {
@@ skipping 11 matching lines @@
         svgImage, imageSize, 1,
         element().document().completeURL(element().imageSourceURL()));
   } else {
     sourceImage = cachedImage()->getImage();
   }
 
   *status = NormalSourceImageStatus;
   return sourceImage->imageForDefaultFrame();
 }
 
-bool CanvasImageElementSource::wouldTaintOrigin(
+bool HTMLAndSVGImageElementSource::wouldTaintOrigin(
     SecurityOrigin* destinationSecurityOrigin) const {
   return cachedImage() &&
          !cachedImage()->isAccessAllowed(destinationSecurityOrigin);
 }
 
-FloatSize CanvasImageElementSource::elementSize(
+FloatSize HTMLAndSVGImageElementSource::elementSize(
     const FloatSize& defaultObjectSize) const {
   ImageResourceContent* image = cachedImage();
   if (!image)
     return FloatSize();
 
   if (image->getImage() && image->getImage()->isSVGImage()) {
     return toSVGImage(cachedImage()->getImage())
         ->concreteObjectSize(defaultObjectSize);
   }
 
   return FloatSize(image->imageSize(
       LayoutObject::shouldRespectImageOrientation(element().layoutObject()),
       1.0f));
 }
 
-FloatSize CanvasImageElementSource::defaultDestinationSize(
+FloatSize HTMLAndSVGImageElementSource::defaultDestinationSize(
     const FloatSize& defaultObjectSize) const {
   ImageResourceContent* image = cachedImage();
   if (!image)
     return FloatSize();
 
   if (image->getImage() && image->getImage()->isSVGImage()) {
     return toSVGImage(cachedImage()->getImage())
         ->concreteObjectSize(defaultObjectSize);
   }
 
   LayoutSize size;
   size = image->imageSize(
       LayoutObject::shouldRespectImageOrientation(element().layoutObject()),
       1.0f);
   return FloatSize(size);
 }
 
-bool CanvasImageElementSource::isAccelerated() const {
+bool HTMLAndSVGImageElementSource::isAccelerated() const {
   return false;
 }
 
-const KURL& CanvasImageElementSource::sourceURL() const {
+const KURL& HTMLAndSVGImageElementSource::sourceURL() const {
   return cachedImage()->response().url();
 }
 
-int CanvasImageElementSource::sourceWidth() {
+int HTMLAndSVGImageElementSource::sourceWidth() {
   SourceImageStatus status;
   RefPtr<Image> image =
       getSourceImageForCanvas(&status, PreferNoAcceleration,
                               SnapshotReasonUnknown, sourceDefaultObjectSize());
   return image->width();
 }
 
-int CanvasImageElementSource::sourceHeight() {
+int HTMLAndSVGImageElementSource::sourceHeight() {
   SourceImageStatus status;
   RefPtr<Image> image =
       getSourceImageForCanvas(&status, PreferNoAcceleration,
                               SnapshotReasonUnknown, sourceDefaultObjectSize());
   return image->height();
 }
 
-bool CanvasImageElementSource::isOpaque() const {
+bool HTMLAndSVGImageElementSource::isOpaque() const {
   Image* image = const_cast<Element&>(element()).imageContents();
   return image && image->currentFrameKnownToBeOpaque();
 }
 
+IntSize HTMLAndSVGImageElementSource::bitmapSourceSize() const {
+  ImageResourceContent* image = cachedImage();
+  if (!image)
+    return IntSize();
+  LayoutSize lSize = image->imageSize(
+      LayoutObject::shouldRespectImageOrientation(element().layoutObject()),
+      1.0f);
+  DCHECK(lSize.fraction().isZero());
+  return IntSize(lSize.width().toInt(), lSize.height().toInt());
+}
+
+ScriptPromise HTMLAndSVGImageElementSource::createImageBitmap(
+    ScriptState* scriptState,
+    EventTarget& eventTarget,
+    Optional<IntRect> cropRect,
+    const ImageBitmapOptions& options,
+    ExceptionState& exceptionState) {
+  DCHECK(eventTarget.toLocalDOMWindow());
+  if ((cropRect &&
+       !ImageBitmap::isSourceSizeValid(cropRect->width(), cropRect->height(),
+                                       exceptionState)) ||
+      !ImageBitmap::isSourceSizeValid(bitmapSourceSize().width(),
+                                      bitmapSourceSize().height(),
+                                      exceptionState))
+    return ScriptPromise();
+  if (!ImageBitmap::isResizeOptionValid(options, exceptionState))
+    return ScriptPromise();
+  return ImageBitmapSource::fulfillImageBitmap(
+      scriptState,
+      ImageBitmap::create(this, cropRect,
+                          eventTarget.toLocalDOMWindow()->document(), options));
+}
+
 }  // namespace blink