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 GetImageLoader().GetImage();
 }
 
-const Element& CanvasImageElementSource::GetElement() const {
+const Element& HTMLAndSVGImageElementSource::GetElement() const {
   return *GetImageLoader().GetElement();
 }
 
-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& default_object_size) const {
   if (!GetImageLoader().ImageComplete() || !CachedImage()) {
     *status = kIncompleteSourceImageStatus;
     return nullptr;
   }
 
   if (CachedImage()->ErrorOccurred()) {
@@ skipping 11 matching lines @@
         svg_image, image_size, 1,
         GetElement().GetDocument().CompleteURL(GetElement().ImageSourceURL()));
   } else {
     source_image = CachedImage()->GetImage();
   }
 
   *status = kNormalSourceImageStatus;
   return source_image->ImageForDefaultFrame();
 }
 
-bool CanvasImageElementSource::WouldTaintOrigin(
+bool HTMLAndSVGImageElementSource::WouldTaintOrigin(
     SecurityOrigin* destination_security_origin) const {
   return CachedImage() &&
          !CachedImage()->IsAccessAllowed(destination_security_origin);
 }
 
-FloatSize CanvasImageElementSource::ElementSize(
+FloatSize HTMLAndSVGImageElementSource::ElementSize(
     const FloatSize& default_object_size) const {
   ImageResourceContent* image = CachedImage();
   if (!image)
     return FloatSize();
 
   if (image->GetImage() && image->GetImage()->IsSVGImage()) {
     return ToSVGImage(CachedImage()->GetImage())
         ->ConcreteObjectSize(default_object_size);
   }
 
   return FloatSize(image->ImageSize(LayoutObject::ShouldRespectImageOrientation(
                                         GetElement().GetLayoutObject()),
                                     1.0f));
 }
 
-FloatSize CanvasImageElementSource::DefaultDestinationSize(
+FloatSize HTMLAndSVGImageElementSource::DefaultDestinationSize(
     const FloatSize& default_object_size) const {
   ImageResourceContent* image = CachedImage();
   if (!image)
     return FloatSize();
 
   if (image->GetImage() && image->GetImage()->IsSVGImage()) {
     return ToSVGImage(CachedImage()->GetImage())
         ->ConcreteObjectSize(default_object_size);
   }
 
   LayoutSize size;
   size = image->ImageSize(LayoutObject::ShouldRespectImageOrientation(
                               GetElement().GetLayoutObject()),
                           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()->GetResponse().Url();
 }
 
-int CanvasImageElementSource::SourceWidth() {
+int HTMLAndSVGImageElementSource::SourceWidth() {
   SourceImageStatus status;
   RefPtr<Image> image = GetSourceImageForCanvas(&status, kPreferNoAcceleration,
                                                 kSnapshotReasonUnknown,
                                                 SourceDefaultObjectSize());
   return image->width();
 }
 
-int CanvasImageElementSource::SourceHeight() {
+int HTMLAndSVGImageElementSource::SourceHeight() {
   SourceImageStatus status;
   RefPtr<Image> image = GetSourceImageForCanvas(&status, kPreferNoAcceleration,
                                                 kSnapshotReasonUnknown,
                                                 SourceDefaultObjectSize());
   return image->height();
 }
 
-bool CanvasImageElementSource::IsOpaque() const {
+bool HTMLAndSVGImageElementSource::IsOpaque() const {
   Image* image = const_cast<Element&>(GetElement()).ImageContents();
   return image && image->CurrentFrameKnownToBeOpaque();
 }
 
+IntSize HTMLAndSVGImageElementSource::BitmapSourceSize() const {
+  ImageResourceContent* image = CachedImage();
+  if (!image)
+    return IntSize();
+  LayoutSize lSize =
+      image->ImageSize(LayoutObject::ShouldRespectImageOrientation(
+                           GetElement().GetLayoutObject()),
+                       1.0f);
+  DCHECK(lSize.Fraction().IsZero());
+  return IntSize(lSize.Width().ToInt(), lSize.Height().ToInt());
+}
+
+ScriptPromise HTMLAndSVGImageElementSource::CreateImageBitmap(
+    ScriptState* script_state,
+    EventTarget& event_target,
+    Optional<IntRect> crop_rect,
+    const ImageBitmapOptions& options,
+    ExceptionState& exception_state) {
+  DCHECK(event_target.ToLocalDOMWindow());
+  if ((crop_rect &&
+       !ImageBitmap::IsSourceSizeValid(crop_rect->Width(), crop_rect->Height(),
+                                       exception_state)) ||
+      !ImageBitmap::IsSourceSizeValid(BitmapSourceSize().Width(),
+                                      BitmapSourceSize().Height(),
+                                      exception_state))
+    return ScriptPromise();
+  if (!ImageBitmap::IsResizeOptionValid(options, exception_state))
+    return ScriptPromise();
+  return ImageBitmapSource::FulfillImageBitmap(
+      script_state, ImageBitmap::Create(
+                        this, crop_rect,
+                        event_target.ToLocalDOMWindow()->document(), options));
+}
+
 }  // namespace blink