Add HTMLPictureElement-based source selection to HTMLImageElement

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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/html/HTMLImageElement.h"
 
 #include "CSSPropertyNames.h"
 #include "HTMLNames.h"
+#include "MediaTypeNames.h"
 #include "RuntimeEnabledFeatures.h"
 #include "bindings/v8/ScriptEventListener.h"
+#include "core/css/MediaQueryMatcher.h"
 #include "core/css/MediaValuesCached.h"
 #include "core/css/parser/SizesAttributeParser.h"
 #include "core/dom/Attribute.h"
 #include "core/fetch/ImageResource.h"
 #include "core/html/HTMLAnchorElement.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLFormElement.h"
+#include "core/html/HTMLSourceElement.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/html/parser/HTMLSrcsetParser.h"
 #include "core/rendering/RenderImage.h"
+#include "platform/MIMETypeRegistry.h"
 
 using namespace std;
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 HTMLImageElement::HTMLImageElement(Document& document, HTMLFormElement* form)
     : HTMLElement(imgTag, document)
     , m_imageLoader(this)
@@ skipping 92 matching lines @@
         m_form->disassociate(*this);
     }
     if (nearestForm) {
         m_form = nearestForm->createWeakPtr();
         m_form->associate(*this);
     } else {
         m_form = WeakPtr<HTMLFormElement>();
     }
 }
 
+void HTMLImageElement::setBestFitURLAndDPRFromImageCandidate(const ImageCandidate& candidate)
+{
+    m_bestFitImageURL = candidate.url();
+    float candidateScaleFactor = candidate.scaleFactor();
+    // FIXME: Make this ">0" part match the spec, once it settles.
+    if (candidateScaleFactor > 0)
+        m_imageDevicePixelRatio = 1 / candidateScaleFactor;
+    if (renderer() && renderer()->isImage())
+        toRenderImage(renderer())->setImageDevicePixelRatio(m_imageDevicePixelRatio);
+}
+
 void HTMLImageElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
     if (name == altAttr) {
         if (renderer() && renderer()->isImage())
             toRenderImage(renderer())->updateAltText();
     } else if (name == srcAttr || name == srcsetAttr || name == sizesAttr) {
-        int effectiveSize = 0;
+        unsigned effectiveSize = 0;
         if (RuntimeEnabledFeatures::pictureSizesEnabled())
             effectiveSize = SizesAttributeParser::findEffectiveSize(fastGetAttribute(sizesAttr), MediaValuesCached::create(document()));
         ImageCandidate candidate = bestFitSourceForImageAttributes(document().devicePixelRatio(), effectiveSize, fastGetAttribute(srcAttr), fastGetAttribute(srcsetAttr));
-        m_bestFitImageURL = candidate.toAtomicString();
-        float candidateScaleFactor = candidate.scaleFactor();
-        // FIXME: Make this ">0" part match the spec, once it settles.
-        if (candidateScaleFactor > 0)
-            m_imageDevicePixelRatio = 1 / candidateScaleFactor;
-        if (renderer() && renderer()->isImage())
-            toRenderImage(renderer())->setImageDevicePixelRatio(m_imageDevicePixelRatio);
+        setBestFitURLAndDPRFromImageCandidate(candidate);
         m_imageLoader.updateFromElementIgnoringPreviousError();
     } else if (name == usemapAttr) {
         setIsLink(!value.isNull());
     } else if (name == compositeAttr) {
         // FIXME: images don't support blend modes in their compositing attribute.
         blink::WebBlendMode blendOp = blink::WebBlendModeNormal;
         if (!parseCompositeAndBlendOperator(value, m_compositeOperator, blendOp))
             m_compositeOperator = CompositeSourceOver;
     } else {
         HTMLElement::parseAttribute(name, value);
     }
 }
 
 const AtomicString& HTMLImageElement::altText() const
 {
     // lets figure out the alt text.. magic stuff
     // http://www.w3.org/TR/1998/REC-html40-19980424/appendix/notes.html#altgen
     // also heavily discussed by Hixie on bugzilla
     const AtomicString& alt = fastGetAttribute(altAttr);
     if (!alt.isNull())
         return alt;
     // fall back to title attribute
     return fastGetAttribute(titleAttr);
 }
 
+static bool supportedImageType(const String& type)
+{
+    return MIMETypeRegistry::isSupportedImageResourceMIMEType(type);
+}
+
+// http://picture.responsiveimages.org/#update-source-set
+ImageCandidate HTMLImageElement::findBestFitImageFromPictureParent()
+{
+    ASSERT(isMainThread());
+    Node* parent = parentNode();
+    if (!parent || !isHTMLPictureElement(*parent))
+        return ImageCandidate();
+    for (Node* child = parent->firstChild(); child; child = child->nextSibling()) {
+        if (child == this)
+            return ImageCandidate();
+
+        if (!isHTMLSourceElement(*child))
+            continue;
+
+        HTMLSourceElement* source = toHTMLSourceElement(child);
+        String srcset = source->fastGetAttribute(srcsetAttr);
+        if (srcset.isEmpty())
+            continue;
+        String type = source->fastGetAttribute(typeAttr);
+        if (!type.isEmpty() && !supportedImageType(type))
+            continue;
+
+        String media = source->fastGetAttribute(mediaAttr);
+        if (!media.isEmpty()) {
+            RefPtr<MediaQuerySet> mediaQueries = MediaQuerySet::create(media);
+            if (!document().mediaQueryMatcher().evaluate(mediaQueries.get()))
+                continue;
+        }
+
+        unsigned effectiveSize = SizesAttributeParser::findEffectiveSize(source->fastGetAttribute(sizesAttr), MediaValuesCached::create(document()));
+        ImageCandidate candidate = bestFitSourceForSrcsetAttribute(document().devicePixelRatio(), effectiveSize, source->fastGetAttribute(srcsetAttr));
+        if (candidate.isEmpty())
+            continue;
+        return candidate;
+    }
+    return ImageCandidate();
+}
+
 RenderObject* HTMLImageElement::createRenderer(RenderStyle* style)
 {
     if (style->hasContent())
         return RenderObject::createObject(this, style);
 
     RenderImage* image = new RenderImage(this);
     image->setImageResource(RenderImageResource::create());
     image->setImageDevicePixelRatio(m_imageDevicePixelRatio);
     return image;
 }
@@ skipping 24 matching lines @@
             renderImageResource->setImageResource(m_imageLoader.image());
 
     }
 }
 
 Node::InsertionNotificationRequest HTMLImageElement::insertedInto(ContainerNode* insertionPoint)
 {
     if (!m_formWasSetByParser || insertionPoint->highestAncestorOrSelf() != m_form->highestAncestorOrSelf())
         resetFormOwner();
 
+    bool imageWasModified = false;
+    if (RuntimeEnabledFeatures::pictureEnabled()) {
+        ImageCandidate candidate = findBestFitImageFromPictureParent();
+        if (!candidate.isEmpty()) {
+            setBestFitURLAndDPRFromImageCandidate(candidate);
+            imageWasModified = true;
+        }
+    }
+
     // If we have been inserted from a renderer-less document,
     // our loader may have not fetched the image, so do it now.
-    if (insertionPoint->inDocument() && !m_imageLoader.image())
+    if ((insertionPoint->inDocument() && !m_imageLoader.image()) || imageWasModified)
         m_imageLoader.updateFromElement();
 
     return HTMLElement::insertedInto(insertionPoint);
 }
 
 void HTMLImageElement::removedFrom(ContainerNode* insertionPoint)
 {
     if (!m_form || m_form->highestAncestorOrSelf() != highestAncestorOrSelf())
         resetFormOwner();
     HTMLElement::removedFrom(insertionPoint);
@@ skipping 56 matching lines @@
 int HTMLImageElement::naturalHeight() const
 {
     if (!m_imageLoader.image())
         return 0;
 
     return m_imageLoader.image()->imageSizeForRenderer(renderer(), 1.0f).height();
 }
 
 const AtomicString& HTMLImageElement::currentSrc() const
 {
+    // FIXME: Need to absolutize the returned value.
     return m_bestFitImageURL;
 }
 
 bool HTMLImageElement::isURLAttribute(const Attribute& attribute) const
 {
     return attribute.name() == srcAttr
         || attribute.name() == lowsrcAttr
         || attribute.name() == longdescAttr
         || (attribute.name() == usemapAttr && attribute.value().string()[0] != '#')
         || HTMLElement::isURLAttribute(attribute);
@@ skipping 147 matching lines @@
     if (!image)
         return FloatSize();
     LayoutSize size;
     size = image->imageSizeForRenderer(renderer(), 1.0f); // FIXME: Not sure about this.
     if (renderer() && renderer()->isRenderImage() && image->image() && !image->image()->hasRelativeWidth())
         size.scale(toRenderImage(renderer())->imageDevicePixelRatio());
     return size;
 }
 
 }