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 21 matching lines @@
       : element_(element) {}
   Member<HTMLImageElement> element_;
 };
 
 HTMLImageElement::HTMLImageElement(Document& document, bool created_by_parser)
     : HTMLElement(imgTag, document),
       image_loader_(HTMLImageLoader::Create(this)),
       image_device_pixel_ratio_(1.0f),
       source_(nullptr),
       layout_disposition_(LayoutDisposition::kPrimaryContent),
+      decode_sequence_id_(0),
       form_was_set_by_parser_(false),
       element_created_by_parser_(created_by_parser),
       is_fallback_image_(false),
       referrer_policy_(kReferrerPolicyDefault) {
   SetHasCustomStyleCallbacks();
 }
 
 HTMLImageElement* HTMLImageElement::Create(Document& document) {
   return new HTMLImageElement(document);
 }
 
 HTMLImageElement* HTMLImageElement::Create(Document& document,
                                            bool created_by_parser) {
   return new HTMLImageElement(document, created_by_parser);
 }
 
 HTMLImageElement::~HTMLImageElement() {}
 
 DEFINE_TRACE(HTMLImageElement) {
   visitor->Trace(image_loader_);
   visitor->Trace(listener_);
   visitor->Trace(form_);
   visitor->Trace(source_);
+  visitor->Trace(decode_promise_resolvers_);
   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::kUpdateSizeChanged);
 }
 
+void HTMLImageElement::RequestDecode() {
+  DCHECK(!decode_promise_resolvers_.IsEmpty());
+  LocalFrame* frame = GetDocument().GetFrame();
+  // If we don't have the image, or the document doesn't have a frame, then
+  // reject the decode, since we can't plumb the request to the correct place.
+  if (!GetImageLoader().GetImage() ||
+      !GetImageLoader().GetImage()->GetImage() || !frame) {
+    DidDecode(decode_sequence_id_, false);
+    return;
+  }
+  Image* image = GetImageLoader().GetImage()->GetImage();
+  frame->GetChromeClient().RequestDecode(
+      frame, image->ImageForCurrentFrame(),
+      WTF::Bind(&HTMLImageElement::DidDecode, WrapWeakPersistent(this),
+                decode_sequence_id_));
+}
+
+void HTMLImageElement::DidDecode(uint32_t sequence_id, bool success) {
+  // If the sequence id attached with this callback doesn't match our current
+  // sequence id, then the source of the image has changed. In other words, the
+  // decode resolved/rejected by this callback was already rejected. Since we
+  // could have had a new decode request, we have to make sure not to
+  // resolve/reject those using the stale callback.
+  if (sequence_id != decode_sequence_id_)
+    return;
+
+  if (success) {
+    for (auto& resolver : decode_promise_resolvers_)
+      resolver->Resolve();
+  } else {
+    for (auto& resolver : decode_promise_resolvers_) {
+      resolver->Reject(DOMException::Create(
+          kEncodingError, "The source image cannot be decoded"));
+    }
+  }
+  decode_promise_resolvers_.Clear();
+}
+
 HTMLImageElement* HTMLImageElement::CreateForJSConstructor(Document& document) {
   HTMLImageElement* image = new HTMLImageElement(document);
   image->element_created_by_parser_ = 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.new_value)
         text->setTextContent(AltText());
     }
   } else if (name == srcAttr || name == srcsetAttr || name == sizesAttr) {
     SelectSourceURL(ImageLoader::kUpdateIgnorePreviousError);
+    // Ensure to fail any pending decodes on possible source changes.
+    if (!decode_promise_resolvers_.IsEmpty() &&
+        params.old_value != params.new_value) {
+      DidDecode(decode_sequence_id_, false);
+      // Increment the sequence id so that any in flight decode completion tasks
+      // will not trigger promise resolution for new decode requests.
+      ++decode_sequence_id_;
+    }
   } else if (name == usemapAttr) {
     SetIsLink(!params.new_value.IsNull());
   } else if (name == referrerpolicyAttr) {
     referrer_policy_ = kReferrerPolicyDefault;
     if (!params.new_value.IsNull()) {
       SecurityPolicy::ReferrerPolicyFromString(
           params.new_value, kSupportReferrerPolicyLegacyKeywords,
           &referrer_policy_);
       UseCounter::Count(GetDocument(),
                         UseCounter::kHTMLImageElementReferrerPolicyAttribute);
@@ skipping 316 matching lines @@
   GetDocument().UpdateStyleAndLayoutIgnorePendingStylesheets();
   LayoutObject* r = GetLayoutObject();
   if (!r)
     return 0;
 
   // FIXME: This doesn't work correctly with transforms.
   FloatPoint abs_pos = r->LocalToAbsolute();
   return abs_pos.Y();
 }
 
+ScriptPromise HTMLImageElement::decode(ScriptState* script_state,
+                                       ExceptionState& exception_state) {
+  if (!script_state->ContextIsValid()) {
+    exception_state.ThrowDOMException(kEncodingError,
+                                      "The source image cannot be decoded");
+    return ScriptPromise();
+  }
+  exception_state.ClearException();
+  decode_promise_resolvers_.push_back(
+      ScriptPromiseResolver::Create(script_state));
+  ScriptPromise promise = decode_promise_resolvers_.back()->Promise();
+  if (complete())
+    RequestDecode();
+  return promise;
+}
+
 bool HTMLImageElement::complete() const {
   return GetImageLoader().ImageComplete();
 }
 
 void HTMLImageElement::DidMoveToNewDocument(Document& old_document) {
   SelectSourceURL(ImageLoader::kUpdateIgnorePreviousError);
   GetImageLoader().ElementDidMoveToNewDocument();
   HTMLElement::DidMoveToNewDocument(old_document);
 }
 
 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 GetDocument()
       .CompleteURL(StripLeadingAndTrailingHTMLSpaces(usemap))
       .IsEmpty();
 }
 
 Image* HTMLImageElement::ImageContents() {
   if (!GetImageLoader().ImageComplete())
@@ skipping 199 matching lines @@
       return OriginalStyleForLayoutObject();
     case LayoutDisposition::kFallbackContent:
       return HTMLImageFallbackHelper::CustomStyleForAltText(
           *this, ComputedStyle::Clone(*OriginalStyleForLayoutObject()));
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
+void HTMLImageElement::ImageNotifyFinished(bool success) {
+  if (decode_promise_resolvers_.IsEmpty())
+    return;
+  if (success)
+    RequestDecode();
+  else
+    DidDecode(decode_sequence_id_, false);
+}
+
 IntSize HTMLImageElement::BitmapSourceSize() const {
   ImageResourceContent* image = CachedImage();
   if (!image)
     return IntSize();
   LayoutSize l_size = image->ImageSize(
       LayoutObject::ShouldRespectImageOrientation(GetLayoutObject()), 1.0f);
   DCHECK(l_size.Fraction().IsZero());
   return IntSize(l_size.Width().ToInt(), l_size.Height().ToInt());
 }
 
 void HTMLImageElement::AssociateWith(HTMLFormElement* form) {
   if (form && form->isConnected()) {
     form_ = form;
     form_was_set_by_parser_ = true;
     form_->Associate(*this);
     form_->DidAssociateByParser();
   }
 };
 
 FloatSize HTMLImageElement::SourceDefaultObjectSize() {
   return FloatSize(width(), height());
 }
 
 }  // namespace blink