Have srcset respond to viewport changes

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.
@@ skipping 29 matching lines @@
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/html/parser/HTMLSrcsetParser.h"
 #include "core/rendering/RenderImage.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
+class HTMLImageElement::Listener FINAL : public MediaQueryListListener {
+public:
+    static RefPtrWillBeRawPtr<Listener> create(HTMLImageElement* element)
+    {
+        return adoptRefWillBeNoop(new Listener(element));
+    }
+
+    virtual void call() OVERRIDE
+    {
+        if (m_element)
+            m_element->notifyMediaQueryChanged();
+    }
+
+    void clearElement() { m_element = nullptr; }
+    virtual void trace(Visitor* visitor) OVERRIDE
+    {
+        visitor->trace(m_element);
+        MediaQueryListListener::trace(visitor);
+    }
+private:
+    Listener(HTMLImageElement* element) : m_element(element) { }
+    RawPtrWillBeMember<HTMLImageElement> m_element;
+};
+
 HTMLImageElement::HTMLImageElement(Document& document, HTMLFormElement* form, bool createdByParser)
     : HTMLElement(imgTag, document)
     , m_imageLoader(HTMLImageLoader::create(this))
     , m_compositeOperator(CompositeSourceOver)
     , m_imageDevicePixelRatio(1.0f)
     , m_formWasSetByParser(false)
     , m_elementCreatedByParser(createdByParser)
+    , m_intrinsicSizingViewportDependant(false)
+    , m_effectiveSizeViewportDependant(false)
 {
     ScriptWrappable::init(this);
     if (form && form->inDocument()) {
 #if ENABLE(OILPAN)
         m_form = form;
 #else
         m_form = form->createWeakPtr();
 #endif
         m_formWasSetByParser = true;
         m_form->associate(*this);
         m_form->didAssociateByParser();
     }
 }
 
 PassRefPtrWillBeRawPtr<HTMLImageElement> HTMLImageElement::create(Document& document)
 {
     return adoptRefWillBeNoop(new HTMLImageElement(document));
 }
 
 PassRefPtrWillBeRawPtr<HTMLImageElement> HTMLImageElement::create(Document& document, HTMLFormElement* form, bool createdByParser)
 {
     return adoptRefWillBeNoop(new HTMLImageElement(document, form, createdByParser));
 }
 
 HTMLImageElement::~HTMLImageElement()
 {
 #if !ENABLE(OILPAN)
+    if (m_listener)
+        m_listener->clearElement();
     if (m_form)
         m_form->disassociate(*this);
 #endif
 }
 
+void HTMLImageElement::createMediaQueryListIfDoesNotExist()
+{
+    if (m_mediaQueryList)
+        return;
+    RefPtrWillBeRawPtr<MediaQuerySet> set = MediaQuerySet::create(MediaTypeNames::all);
+    m_listener = Listener::create(this);
+    m_mediaQueryList = MediaQueryList::create(&document().mediaQueryMatcher(), set.release());
+    m_mediaQueryList->addListener(m_listener);
+    m_mediaQueryList->alwaysUpdate();
+}
+
 void HTMLImageElement::trace(Visitor* visitor)
 {
     visitor->trace(m_imageLoader);
     visitor->trace(m_form);
+    visitor->trace(m_listener);
+    visitor->trace(m_mediaQueryList);
     HTMLElement::trace(visitor);
 }
 
+void HTMLImageElement::notifyMediaQueryChanged()
+{
+    // 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::UpdateForce);
+}
+
 PassRefPtrWillBeRawPtr<HTMLImageElement> HTMLImageElement::createForJSConstructor(Document& document, int width, int height)
 {
     RefPtrWillBeRawPtr<HTMLImageElement> image = adoptRefWillBeNoop(new HTMLImageElement(document));
     if (width)
         image->setWidth(width);
     if (height)
         image->setHeight(height);
     image->m_elementCreatedByParser = false;
     return image.release();
 }
@@ skipping 68 matching lines @@
 #endif
     }
 }
 
 void HTMLImageElement::setBestFitURLAndDPRFromImageCandidate(const ImageCandidate& candidate)
 {
     m_bestFitImageURL = candidate.url();
     float candidateDensity = candidate.density();
     if (candidateDensity >= 0)
         m_imageDevicePixelRatio = 1.0 / candidateDensity;
+    if (candidate.resourceWidth() > 0)
+        m_intrinsicSizingViewportDependant = true;
     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) {
@@ skipping 45 matching lines @@
         String srcset = source->fastGetAttribute(srcsetAttr);
         if (srcset.isEmpty())
             continue;
         String type = source->fastGetAttribute(typeAttr);
         if (!type.isEmpty() && !supportedImageType(type))
             continue;
 
         if (!source->mediaQueryMatches())
             continue;
 
-        unsigned effectiveSize = SizesAttributeParser::findEffectiveSize(source->fastGetAttribute(sizesAttr), MediaValuesDynamic::create(document()));
+        SizesAttributeParser parser = SizesAttributeParser(MediaValuesDynamic::create(document()), source->fastGetAttribute(sizesAttr));
+        unsigned effectiveSize = parser.length();
+        m_effectiveSizeViewportDependant = parser.viewportDependant();
         ImageCandidate candidate = bestFitSourceForSrcsetAttribute(document().devicePixelRatio(), effectiveSize, source->fastGetAttribute(srcsetAttr));
         if (candidate.isEmpty())
             continue;
         return candidate;
     }
     return ImageCandidate();
 }
 
 RenderObject* HTMLImageElement::createRenderer(RenderStyle* style)
 {
@@ skipping 301 matching lines @@
     if (RuntimeEnabledFeatures::pictureEnabled()) {
         ImageCandidate candidate = findBestFitImageFromPictureParent();
         if (!candidate.isEmpty()) {
             setBestFitURLAndDPRFromImageCandidate(candidate);
             foundURL = true;
         }
     }
 
     if (!foundURL) {
         unsigned effectiveSize = 0;
-        if (RuntimeEnabledFeatures::pictureSizesEnabled())
-            effectiveSize = SizesAttributeParser::findEffectiveSize(fastGetAttribute(sizesAttr), MediaValuesDynamic::create(document()));
+        if (RuntimeEnabledFeatures::pictureSizesEnabled()) {
+            SizesAttributeParser parser = SizesAttributeParser(MediaValuesDynamic::create(document()), fastGetAttribute(sizesAttr));
+            effectiveSize = parser.length();
+            m_effectiveSizeViewportDependant = parser.viewportDependant();
+        }
         ImageCandidate candidate = bestFitSourceForImageAttributes(document().devicePixelRatio(), effectiveSize, fastGetAttribute(srcAttr), fastGetAttribute(srcsetAttr));
         setBestFitURLAndDPRFromImageCandidate(candidate);
     }
+    if (m_intrinsicSizingViewportDependant && m_effectiveSizeViewportDependant) {
+        createMediaQueryListIfDoesNotExist();
+        document().mediaQueryMatcher().addMediaQueryList(m_mediaQueryList.get());
+    }
     imageLoader().updateFromElement(behavior);
 }
 
 const KURL& HTMLImageElement::sourceURL() const
 {
     return cachedImage()->response().url();
 }
 
 }