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(

[dcheng, 2017/04/12 06:53:16]

After reading this through, I think it's fine to just plumb through the
document's frame() here.

Then, as previously mentioned, ChromeClientImpl will use the frame to look up
the LocalRoot(), and then get the WebLocalFrameImpl from that, and then get its
WebFrameWidgetBase from that. From there, we can use the WebLayerTreeView to
enter cc.

[vmpstr, 2017/04/17 18:13:11]

Done. Let me know if this looks better...

+        image->imageForCurrentFrame(),
+        WTF::bind(&HTMLImageElement::didDecode,
+                  m_weakPtrFactory.createWeakPtr()));

[kouhei (in TOK), 2017/04/07 14:26:28]

wrapWeakPersistent(this)?

[vmpstr, 2017/04/07 20:43:43]

Hmm, we have to revoke the weak ptrs if the src of the image changes, since we
might get callbacks for the wrong image. Is that possible with weak persistent?

[dcheng, 2017/04/12 06:53:16]

Other potential options:
- PostCancellableTask, which encapsulates this logic internally:
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/WebTa...

- Use a sequence number when the source changes

(I am not sure how common it is to use WeakPtrFactory with Oilpan objects, but
it does seem a bit unusual)

[vmpstr, 2017/04/17 18:13:11]

Done, I used a sequence number here with wrapWeakPersistent.

+  }
+}
+
+void HTMLImageElement::didDecode(bool success) {
+  if (m_decodePromiseResolvers.isEmpty())
+    return;
+  if (success) {
+    for (auto& resolver : m_decodePromiseResolvers)
+      resolver->resolve();
+  } else {
+    for (auto& resolver : m_decodePromiseResolvers) {
+      resolver->reject(DOMException::create(
+          EncodingError, "The source image cannot be decoded"));
+    }
+  }
+  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 169 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::imageNotifyFinished(bool success) {
+  if (m_decodePromiseResolvers.isEmpty())
+    return;
+  if (success)
+    requestDecode();
+  else
+    didDecode(false);
+}
+
 IntSize HTMLImageElement::bitmapSourceSize() const {
   ImageResourceContent* image = cachedImage();
   if (!image)
     return IntSize();
   LayoutSize lSize = image->imageSize(
       LayoutObject::shouldRespectImageOrientation(layoutObject()), 1.0f);
   DCHECK(lSize.fraction().isZero());
   return IntSize(lSize.width().toInt(), lSize.height().toInt());
 }
 
 void HTMLImageElement::associateWith(HTMLFormElement* form) {
   if (form && form->isConnected()) {
     m_form = form;
     m_formWasSetByParser = true;
     m_form->associate(*this);
     m_form->didAssociateByParser();
   }
 };
 
 FloatSize HTMLImageElement::sourceDefaultObjectSize() {
   return FloatSize(width(), height());
 }
 
 }  // namespace blink