Add decode() functionality to image elements.

third_party/WebKit/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
@@ skipping 13 matching lines @@
 #include "core/html/HTMLImageElement.h"
 
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
 #include "core/MediaTypeNames.h"
 #include "core/css/MediaQueryMatcher.h"
 #include "core/css/MediaValuesDynamic.h"
 #include "core/css/parser/SizesAttributeParser.h"
 #include "core/dom/Attribute.h"
+#include "core/dom/DOMException.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/html/FormAssociated.h"
 #include "core/html/HTMLAnchorElement.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLImageFallbackHelper.h"
 #include "core/html/HTMLPictureElement.h"
 #include "core/html/HTMLSourceElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/html/parser/HTMLSrcsetParser.h"
 #include "core/imagebitmap/ImageBitmapOptions.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/api/LayoutImageItem.h"
 #include "core/loader/resource/ImageResourceContent.h"
+#include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/style/ContentData.h"
 #include "core/svg/graphics/SVGImageForContainer.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/network/mime/ContentType.h"
 #include "platform/network/mime/MIMETypeRegistry.h"
 #include "platform/weborigin/SecurityPolicy.h"
 
 namespace blink {
 
@@ skipping 24 matching lines @@
 
 HTMLImageElement::HTMLImageElement(Document& document, bool createdByParser)
     : HTMLElement(imgTag, document),
       m_imageLoader(HTMLImageLoader::create(this)),
       m_imageDevicePixelRatio(1.0f),
       m_source(nullptr),
       m_layoutDisposition(LayoutDisposition::PrimaryContent),
       m_formWasSetByParser(false),
       m_elementCreatedByParser(createdByParser),
       m_isFallbackImage(false),
-      m_referrerPolicy(ReferrerPolicyDefault) {
+      m_referrerPolicy(ReferrerPolicyDefault),
+      m_weakPtrFactory(this) {
   setHasCustomStyleCallbacks();
 }
 
 HTMLImageElement* HTMLImageElement::create(Document& document) {
   return new HTMLImageElement(document);
 }
 
 HTMLImageElement* HTMLImageElement::create(Document& document,
                                            bool createdByParser) {
   return new HTMLImageElement(document, createdByParser);
 }
 
-HTMLImageElement::~HTMLImageElement() {}
+HTMLImageElement::~HTMLImageElement() {
+  m_weakPtrFactory.revokeAll();
+}
 
 DEFINE_TRACE(HTMLImageElement) {
   visitor->trace(m_imageLoader);
   visitor->trace(m_listener);
   visitor->trace(m_form);
   visitor->trace(m_source);
+  visitor->trace(m_decodePromiseResolvers);
   HTMLElement::trace(visitor);
 }
 
 void HTMLImageElement::notifyViewportChanged() {
   // Re-selecting the source URL in order to pick a more fitting resource
   // And update the image's intrinsic dimensions when the viewport changes.
   // Picking of a better fitting resource is UA dependant, not spec required.
   selectSourceURL(ImageLoader::UpdateSizeChanged);
 }
 
+void HTMLImageElement::requestDecode() {
+  DCHECK(!m_decodePromiseResolvers.isEmpty());
+  if (!imageLoader().image() || !imageLoader().image()->getImage()) {
+    didDecode(false);
+    return;
+  }
+  Image* image = imageLoader().image()->getImage();
+  auto* page = document().page();
+  if (page) {
+    page->chromeClient().requestDecode(
+        image->imageForCurrentFrame(),
+        WTF::bind(&HTMLImageElement::didDecode,
+                  m_weakPtrFactory.createWeakPtr()));
+  }
+}
+
+void HTMLImageElement::didDecode(bool success) {
+  if (m_decodePromiseResolvers.isEmpty())
+    return;
+  static auto resolve = [](ScriptPromiseResolver* resolver) {
+    resolver->resolve();
+  };
+  static auto reject = [](ScriptPromiseResolver* resolver) {
+    resolver->reject(DOMException::create(
+        EncodingError, "The source image cannot be decoded"));
+  };
+  auto process = success ? resolve : reject;
+  for (auto& resolver : m_decodePromiseResolvers)
+    process(resolver);
+  m_decodePromiseResolvers.clear();
+}
+
 HTMLImageElement* HTMLImageElement::createForJSConstructor(Document& document) {
   HTMLImageElement* image = new HTMLImageElement(document);
   image->m_elementCreatedByParser = false;
   return image;
 }
 
 HTMLImageElement* HTMLImageElement::createForJSConstructor(Document& document,
                                                            unsigned width) {
   HTMLImageElement* image = new HTMLImageElement(document);
   image->setWidth(width);
@@ skipping 115 matching lines @@
   const QualifiedName& name = params.name;
   if (name == altAttr || name == titleAttr) {
     if (userAgentShadowRoot()) {
       Element* text = userAgentShadowRoot()->getElementById("alttext");
       String value = altText();
       if (text && text->textContent() != params.newValue)
         text->setTextContent(altText());
     }
   } else if (name == srcAttr || name == srcsetAttr || name == sizesAttr) {
     selectSourceURL(ImageLoader::UpdateIgnorePreviousError);
+    // Ensure to fail any pending decodes on possible source changes.
+    if (!m_decodePromiseResolvers.isEmpty() &&
+        params.oldValue != params.newValue) {
+      didDecode(false);
+      m_weakPtrFactory.revokeAll();
+    }
   } else if (name == usemapAttr) {
     setIsLink(!params.newValue.isNull());
   } else if (name == referrerpolicyAttr) {
     m_referrerPolicy = ReferrerPolicyDefault;
     if (!params.newValue.isNull()) {
       SecurityPolicy::referrerPolicyFromString(
           params.newValue, SupportReferrerPolicyLegacyKeywords,
           &m_referrerPolicy);
       UseCounter::count(document(),
                         UseCounter::HTMLImageElementReferrerPolicyAttribute);
@@ skipping 135 matching lines @@
   // our loader may have not fetched the image, so do it now.
   if ((insertionPoint->isConnected() && !imageLoader().image()) ||
       imageWasModified)
     imageLoader().updateFromElement(ImageLoader::UpdateNormal,
                                     m_referrerPolicy);
 
   return HTMLElement::insertedInto(insertionPoint);
 }
 
 void HTMLImageElement::removedFrom(ContainerNode* insertionPoint) {
-  if (!m_form ||
-      NodeTraversal::highestAncestorOrSelf(*m_form.get()) !=
-          NodeTraversal::highestAncestorOrSelf(*this))
+  if (!m_form || NodeTraversal::highestAncestorOrSelf(*m_form.get()) !=
+                     NodeTraversal::highestAncestorOrSelf(*this))
     resetFormOwner();
   if (m_listener) {
     document().mediaQueryMatcher().removeViewportListener(m_listener);
     Node* parent = parentNode();
     if (parent && isHTMLPictureElement(*parent))
       toHTMLPictureElement(parent)->removeListenerFromSourceChildren();
   }
   HTMLElement::removedFrom(insertionPoint);
 }
 
@@ skipping 86 matching lines @@
 }
 
 const String& HTMLImageElement::currentSrc() const {
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/edits.html#dom-img-currentsrc
   // The currentSrc IDL attribute must return the img element's current
   // request's current URL.
 
   // Return the picked URL string in case of load error.
   if (imageLoader().hadError())
     return m_bestFitImageURL;
-  // Initially, the pending request turns into current request when it is either
-  // available or broken.  We use the image's dimensions as a proxy to it being
-  // in any of these states.
+  // Initially, the pending request turns into current request when it is
+  // either available or broken.  We use the image's dimensions as a proxy to
+  // it being in any of these states.
   if (!imageLoader().image() || !imageLoader().image()->getImage() ||
       !imageLoader().image()->getImage()->width())
     return emptyAtom;
 
   return imageLoader().image()->url().getString();
 }
 
 bool HTMLImageElement::isURLAttribute(const Attribute& attribute) const {
   return attribute.name() == srcAttr || attribute.name() == lowsrcAttr ||
          attribute.name() == longdescAttr ||
@@ skipping 45 matching lines @@
   document().updateStyleAndLayoutIgnorePendingStylesheets();
   LayoutObject* r = layoutObject();
   if (!r)
     return 0;
 
   // FIXME: This doesn't work correctly with transforms.
   FloatPoint absPos = r->localToAbsolute();
   return absPos.y();
 }
 
+ScriptPromise HTMLImageElement::decode(ScriptState* scriptState,
+                                       ExceptionState& exceptionState) {
+  exceptionState.clearException();
+  m_decodePromiseResolvers.push_back(
+      ScriptPromiseResolver::create(scriptState));
+  ScriptPromise promise = m_decodePromiseResolvers.back()->promise();
+  if (complete())
+    requestDecode();
+  return promise;
+}
+
 bool HTMLImageElement::complete() const {
   return imageLoader().imageComplete();
 }
 
 void HTMLImageElement::didMoveToNewDocument(Document& oldDocument) {
   selectSourceURL(ImageLoader::UpdateIgnorePreviousError);
   imageLoader().elementDidMoveToNewDocument();
   HTMLElement::didMoveToNewDocument(oldDocument);
 }
 
 bool HTMLImageElement::isServerMap() const {
   if (!fastHasAttribute(ismapAttr))
     return false;
 
   const AtomicString& usemap = fastGetAttribute(usemapAttr);
 
-  // If the usemap attribute starts with '#', it refers to a map element in the
-  // document.
+  // If the usemap attribute starts with '#', it refers to a map element in
+  // the document.
   if (usemap[0] == '#')
     return false;
 
   return document()
       .completeURL(stripLeadingAndTrailingHTMLSpaces(usemap))
       .isEmpty();
 }
 
 Image* HTMLImageElement::imageContents() {
   if (!imageLoader().imageComplete())
@@ skipping 230 matching lines @@
   return m_layoutDisposition == LayoutDisposition::Collapsed;
 }
 
 void HTMLImageElement::setLayoutDisposition(LayoutDisposition layoutDisposition,
                                             bool forceReattach) {
   if (m_layoutDisposition == layoutDisposition && !forceReattach)
     return;
 
   m_layoutDisposition = layoutDisposition;
 
-  // This can happen inside of attachLayoutTree() in the middle of a recalcStyle
-  // so we need to reattach synchronously here.
+  // This can happen inside of attachLayoutTree() in the middle of a
+  // recalcStyle so we need to reattach synchronously here.
   if (document().inStyleRecalc()) {
     reattachLayoutTree();
   } else {
     if (m_layoutDisposition == LayoutDisposition::FallbackContent) {
       EventDispatchForbiddenScope::AllowUserAgentEvents allowEvents;
       ensureUserAgentShadowRoot();
     }
     lazyReattachIfAttached();
   }
 }
 
 PassRefPtr<ComputedStyle> HTMLImageElement::customStyleForLayoutObject() {
   switch (m_layoutDisposition) {
     case LayoutDisposition::PrimaryContent:  // Fall through.
     case LayoutDisposition::Collapsed:
       return originalStyleForLayoutObject();
     case LayoutDisposition::FallbackContent:
       return HTMLImageFallbackHelper::customStyleForAltText(
           *this, ComputedStyle::clone(*originalStyleForLayoutObject()));
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
+void HTMLImageElement::defaultEventHandler(Event* event) {
+  HTMLElement::defaultEventHandler(event);
+  if (m_decodePromiseResolvers.isEmpty())
+    return;
+
+  if (event->type() == EventTypeNames::load) {
+    requestDecode();
+  } else if (event->type() == EventTypeNames::error) {
+    didDecode(false);
+  }
+}
+
 bool HTMLImageElement::isOpaque() const {
   Image* image = const_cast<HTMLImageElement*>(this)->imageContents();
   return image && image->currentFrameKnownToBeOpaque();
 }
 
 int HTMLImageElement::sourceWidth() {
   SourceImageStatus status;
   FloatSize defaultObjectSize(width(), height());
   RefPtr<Image> image = getSourceImageForCanvas(
       &status, PreferNoAcceleration, SnapshotReasonUnknown, defaultObjectSize);
@@ skipping 21 matching lines @@
 void HTMLImageElement::associateWith(HTMLFormElement* form) {
   if (form && form->isConnected()) {
     m_form = form;
     m_formWasSetByParser = true;
     m_form->associate(*this);
     m_form->didAssociateByParser();
   }
 };
 
 }  // namespace blink