Attachment #368023 for bug #196698

View Details Raw Unified Return to Bug 196698

| Differences between



2019-04-23  Rob Buis  <rbuis@igalia.com>

        Support lazy image and iframe loading (loading="lazy")
        https://bugs.webkit.org/show_bug.cgi?id=196698

        Reviewed by NOBODY (OOPS!).

        Tests: http/tests/lazyload/attribute.html
               http/tests/lazyload/fixed-dimension.html
               http/tests/lazyload/js-image.html
               http/tests/lazyload/lazy.html
               http/tests/lazyload/scroll.html
               http/tests/lazyload/style-dimension.html
               imported/w3c/web-platform-tests/loading/lazyload/attribute_off_image.tentative.html
               imported/w3c/web-platform-tests/loading/lazyload/change_attribute_to_off_image.tentative.html
               imported/w3c/web-platform-tests/loading/lazyload/scroll_to_attribute_auto_image.tentative.html
               imported/w3c/web-platform-tests/loading/lazyload/scroll_to_attribute_invalid_image.tentative.html
               imported/w3c/web-platform-tests/loading/lazyload/scroll_to_attribute_on_image.tentative.html
               imported/w3c/web-platform-tests/loading/lazyload/scroll_to_attribute_unset_image.tentative.html
               imported/w3c/web-platform-tests/loading/lazyload/window_load_event_occurs_with_below_viewport_image.tentative.html

        * Sources.txt:
        * WebCore.xcodeproj/project.pbxproj:
        * css/CSSImageValue.cpp:
        (WebCore::CSSImageValue::loadImage):
        * css/CSSImageValue.h:
        * css/parser/CSSParser.cpp:
        (WebCore::CSSParser::parseInlineStyleDeclaration):
        * css/parser/CSSParser.h:
        * css/parser/CSSParserImpl.cpp:
        (WebCore::CSSParserImpl::parseInlineStyleDeclaration):
        * css/parser/CSSParserImpl.h:
        * dom/Document.cpp:
        (WebCore::Document::ensureLazyLoadImageObserver):
        * dom/Document.h:
        * html/HTMLAttributeNames.in:
        * html/HTMLImageElement.cpp:
        (WebCore::HTMLImageElement::HTMLImageElement):
        (WebCore::HTMLImageElement::create):
        (WebCore::HTMLImageElement::createForJSConstructor):
        (WebCore::HTMLImageElement::parseAttribute):
        (WebCore::HTMLImageElement::loadDeferredImage):
        (WebCore::HTMLImageElement::isDimensionSmallAndAbsoluteForLazyLoad):
        (WebCore::HTMLImageElement::isInlineStyleDimensionsSmall):
        * html/HTMLImageElement.h:
        (WebCore::HTMLImageElement::createdByParser const):
        * html/HTMLImageElement.idl:
        * html/HTMLTagNames.in:
        * html/ImageDocument.cpp:
        * html/LazyLoadImageObserver.cpp: Added.
        (WebCore::LazyLoadImageObserver::startMonitoring):
        (WebCore::LazyLoadImageObserver::stopMonitoring):
        (WebCore::LazyLoadImageObserver::startMonitoringNearViewport):
        * html/LazyLoadImageObserver.h: Copied from Tools/DumpRenderTree/TestOptions.h.
        * html/parser/HTMLPreloadScanner.cpp:
        (WebCore::TokenPreloadScanner::StartTagScanner::createPreloadRequest):
        (WebCore::TokenPreloadScanner::StartTagScanner::processAttribute):
        * html/parser/HTMLResourcePreloader.cpp:
        (WebCore::PreloadRequest::resourceRequest):
        * html/parser/HTMLResourcePreloader.h:
        (WebCore::PreloadRequest::setLazyloadImageEnabled):
        * loader/ImageLoader.cpp:
        (WebCore::isLazyLoadableImage):
        (WebCore::ImageLoader::updateFromElement):
        (WebCore::ImageLoader::notifyFinished):
        (WebCore::ImageLoader::loadDeferredImage):
        * loader/ImageLoader.h:
        * page/RuntimeEnabledFeatures.h:
        (WebCore::RuntimeEnabledFeatures::setLazyImageLoadingEnabled):
        (WebCore::RuntimeEnabledFeatures::lazyImageLoadingEnabled const):
        * page/Settings.yaml:
        * rendering/style/RenderStyle.cpp:
        (WebCore::RenderStyle::loadDeferredImages const):
        * rendering/style/RenderStyle.h:
        * rendering/style/StyleCachedImage.cpp:
        (WebCore::StyleCachedImage::addClient):
        (WebCore::StyleCachedImage::removeClient):
        (WebCore::StyleCachedImage::loadDeferredImage):
        * rendering/style/StyleCachedImage.h:

2019-04-22  Youenn Fablet  <youenn@apple.com>

        Update libwebrtc logging when WebCore WebRTC logging is updated



2019-04-23  Rob Buis  <rbuis@igalia.com>

        Support lazy image and iframe loading (loading="lazy")
        https://bugs.webkit.org/show_bug.cgi?id=196698

        Reviewed by NOBODY (OOPS!).

        Add runtime flag.

        * Shared/WebPreferences.yaml:

2019-04-22  Zalan Bujtas  <zalan@apple.com>

        [ContentChangeObserver] Some dropdown menus may close without user gesture on americanexpress.com



2019-04-23  Rob Buis  <rbuis@igalia.com>

        Support lazy image and iframe loading (loading="lazy")
        https://bugs.webkit.org/show_bug.cgi?id=196698

        Reviewed by NOBODY (OOPS!).

        * WebView/WebPreferenceKeysPrivate.h:
        * WebView/WebPreferences.mm:
        (+[WebPreferences initialize]):
        (-[WebPreferences lazyImageLoadingEnabled]):
        (-[WebPreferences setLazyImageLoadingEnabled:]):
        * WebView/WebPreferencesPrivate.h:
        * WebView/WebView.mm:
        (-[WebView _preferencesChanged:]):

2019-04-18  Daniel Bates  <dabates@apple.com>

        Use existing KeyEventCodesIOS constants instead of duplicating them



2019-04-23  Rob Buis  <rbuis@igalia.com>

        Support lazy image and iframe loading (loading="lazy")
        https://bugs.webkit.org/show_bug.cgi?id=196698

        Reviewed by NOBODY (OOPS!).

        * Interfaces/IWebPreferencesPrivate.idl:
        * WebPreferenceKeysPrivate.h:
        * WebPreferences.cpp:
        (WebPreferences::initializeDefaultSettings):
        (WebPreferences::lazyImageLoadingEnabled):
        (WebPreferences::setLazyImageLoadingEnabled):
        * WebPreferences.h:
        * WebView.cpp:
        (WebView::notifyPreferencesChanged):

2019-04-20  Don Olmstead  <don.olmstead@sony.com>

        [CMake][Win] Use target oriented design for WebKitLegacy

Lines 1179-1184 html/InputType.cpp a/Source/WebCore/Sources.txt_sec1
- a/Source/WebCore/Sources.txt +1 lines
1179	html/InputTypeNames.cpp	1179	html/InputTypeNames.cpp
1180	html/LabelableElement.cpp	1180	html/LabelableElement.cpp
1181	html/LabelsNodeList.cpp	1181	html/LabelsNodeList.cpp
		1182	html/LazyLoadImageObserver.cpp
1182	html/LinkIconCollector.cpp	1183	html/LinkIconCollector.cpp
1183	html/LinkRelAttribute.cpp	1184	html/LinkRelAttribute.cpp
1184	html/MediaController.cpp	1185	html/MediaController.cpp



    return !m_accessedImage;
}

CachedImage* CSSImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options, bool defer)
{
    if (!m_accessedImage || !defer) {
        m_accessedImage = true;

        ResourceLoaderOptions loadOptions = options;
        loadOptions.loadedFromOpaqueSource = m_loadedFromOpaqueSource;
        ResourceRequest resourceRequest(loader.document()->completeURL(m_url.string()));
        if (defer) {
            resourceRequest.setHTTPHeaderField(HTTPHeaderName::Range, "bytes=0-2047");
            loadOptions.cache = FetchOptions::Cache::NoStore;
        }
        CachedResourceRequest request(WTFMove(resourceRequest), loadOptions);
        if (m_initiatorName.isEmpty())
            request.setInitiator(cachedResourceRequestInitiators().css);
        else

Lines 41-47 public: a/Source/WebCore/css/CSSImageValue.h_sec1
- a/Source/WebCore/css/CSSImageValue.h -1 / +1 lines
41	~CSSImageValue();	41	~CSSImageValue();
42		42
43	bool isPending() const;	43	bool isPending() const;
44	CachedImage* loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);	44	CachedImage* loadImage(CachedResourceLoader&, const ResourceLoaderOptions&, bool defer = false);
45	CachedImage* cachedImage() const { return m_cachedImage.get(); }	45	CachedImage* cachedImage() const { return m_cachedImage.get(); }
46		46
47	const URL& url() const { return m_url; }	47	const URL& url() const { return m_url; }

Lines 167-172 Ref<ImmutableStyleProperties> CSSParser::parseInlineStyleDeclaration(const Strin a/Source/WebCore/css/parser/CSSParser.cpp_sec1
- a/Source/WebCore/css/parser/CSSParser.cpp +5 lines
167	return CSSParserImpl::parseInlineStyleDeclaration(string, element);	167	return CSSParserImpl::parseInlineStyleDeclaration(string, element);
168	}	168	}
169		169
		170	Ref<ImmutableStyleProperties> CSSParser::parseInlineStyleDeclaration(const String& string, const CSSParserMode& mode)
		171	{
		172	return CSSParserImpl::parseInlineStyleDeclaration(string, mode);
		173	}
		174
170	bool CSSParser::parseDeclaration(MutableStyleProperties& declaration, const String& string)	175	bool CSSParser::parseDeclaration(MutableStyleProperties& declaration, const String& string)
171	{	176	{
172	return CSSParserImpl::parseDeclarationList(&declaration, string, m_context);	177	return CSSParserImpl::parseDeclarationList(&declaration, string, m_context);

Lines 75-80 public: a/Source/WebCore/css/parser/CSSParser.h_sec1
- a/Source/WebCore/css/parser/CSSParser.h +1 lines
75		75
76	WEBCORE_EXPORT bool parseDeclaration(MutableStyleProperties&, const String&);	76	WEBCORE_EXPORT bool parseDeclaration(MutableStyleProperties&, const String&);
77	static Ref<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, const Element*);	77	static Ref<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, const Element*);
		78	static Ref<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, const CSSParserMode&);
78		79
79	void parseSelector(const String&, CSSSelectorList&);	80	void parseSelector(const String&, CSSSelectorList&);
80		81

Lines 166-171 Ref<ImmutableStyleProperties> CSSParserImpl::parseInlineStyleDeclaration(const S a/Source/WebCore/css/parser/CSSParserImpl.cpp_sec1
- a/Source/WebCore/css/parser/CSSParserImpl.cpp +9 lines
166	return createStyleProperties(parser.m_parsedProperties, context.mode);	166	return createStyleProperties(parser.m_parsedProperties, context.mode);
167	}	167	}
168		168
		169	Ref<ImmutableStyleProperties> CSSParserImpl::parseInlineStyleDeclaration(const String& string, const CSSParserMode& mode)
		170	{
		171	CSSParserContext context(mode);
		172
		173	CSSParserImpl parser(context, string);
		174	parser.consumeDeclarationList(parser.tokenizer()->tokenRange(), StyleRule::Style);
		175	return createStyleProperties(parser.m_parsedProperties, context.mode);
		176	}
		177
169	Ref<ImmutableStyleProperties> CSSParserImpl::parseDeferredDeclaration(CSSParserTokenRange tokenRange, const CSSParserContext& context, StyleSheetContents* styleSheet)	178	Ref<ImmutableStyleProperties> CSSParserImpl::parseDeferredDeclaration(CSSParserTokenRange tokenRange, const CSSParserContext& context, StyleSheetContents* styleSheet)
170	{	179	{
171	if (!styleSheet) {	180	if (!styleSheet) {

Lines 85-90 public: a/Source/WebCore/css/parser/CSSParserImpl.h_sec1
- a/Source/WebCore/css/parser/CSSParserImpl.h +1 lines
85	static CSSParser::ParseResult parseValue(MutableStyleProperties*, CSSPropertyID, const String&, bool important, const CSSParserContext&);	85	static CSSParser::ParseResult parseValue(MutableStyleProperties*, CSSPropertyID, const String&, bool important, const CSSParserContext&);
86	static CSSParser::ParseResult parseCustomPropertyValue(MutableStyleProperties*, const AtomicString& propertyName, const String&, bool important, const CSSParserContext&);	86	static CSSParser::ParseResult parseCustomPropertyValue(MutableStyleProperties*, const AtomicString& propertyName, const String&, bool important, const CSSParserContext&);
87	static Ref<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, const Element*);	87	static Ref<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, const Element*);
		88	static Ref<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, const CSSParserMode&);
88	static bool parseDeclarationList(MutableStyleProperties*, const String&, const CSSParserContext&);	89	static bool parseDeclarationList(MutableStyleProperties*, const String&, const CSSParserContext&);
89	static RefPtr<StyleRuleBase> parseRule(const String&, const CSSParserContext&, StyleSheetContents*, AllowedRulesType);	90	static RefPtr<StyleRuleBase> parseRule(const String&, const CSSParserContext&, StyleSheetContents*, AllowedRulesType);
90	static void parseStyleSheet(const String&, const CSSParserContext&, StyleSheetContents*, CSSParser::RuleParsing);	91	static void parseStyleSheet(const String&, const CSSParserContext&, StyleSheetContents*, CSSParser::RuleParsing);

Lines 117-122 a/Source/WebCore/dom/Document.cpp_sec1
- a/Source/WebCore/dom/Document.cpp +8 lines
117	#include "KeyboardEvent.h"	117	#include "KeyboardEvent.h"
118	#include "KeyframeEffect.h"	118	#include "KeyframeEffect.h"
119	#include "LayoutDisallowedScope.h"	119	#include "LayoutDisallowedScope.h"
		120	#include "LazyLoadImageObserver.h"
120	#include "LibWebRTCProvider.h"	121	#include "LibWebRTCProvider.h"
121	#include "LoaderStrategy.h"	122	#include "LoaderStrategy.h"
122	#include "Logging.h"	123	#include "Logging.h"
Lines 8333-8336 void Document::setHasStartedApplePaySession() a/Source/WebCore/dom/Document.cpp_sec2
8333		8334
8334	#endif	8335	#endif
8335		8336
		8337	LazyLoadImageObserver& Document::ensureLazyLoadImageObserver()
		8338	{
		8339	if (!m_lazyLoadImageObserver)
		8340	m_lazyLoadImageObserver = new LazyLoadImageObserver();
		8341	return *m_lazyLoadImageObserver;
		8342	}
		8343
8336	} // namespace WebCore	8344	} // namespace WebCore

Lines 145-150 class IntPoint; a/Source/WebCore/dom/Document.h_sec1
- a/Source/WebCore/dom/Document.h +5 lines
145	class JSNode;	145	class JSNode;
146	class LayoutPoint;	146	class LayoutPoint;
147	class LayoutRect;	147	class LayoutRect;
		148	class LazyLoadImageObserver;
148	class LiveNodeList;	149	class LiveNodeList;
149	class Locale;	150	class Locale;
150	class Location;	151	class Location;
Lines 1527-1532 public: a/Source/WebCore/dom/Document.h_sec2
1527		1528
1528	void frameWasDisconnectedFromOwner();	1529	void frameWasDisconnectedFromOwner();
1529		1530
		1531	LazyLoadImageObserver& ensureLazyLoadImageObserver();
		1532
1530	protected:	1533	protected:
1531	enum ConstructionFlags { Synthesized = 1, NonRenderedPlaceholder = 1 << 1 };	1534	enum ConstructionFlags { Synthesized = 1, NonRenderedPlaceholder = 1 << 1 };
1532	Document(Frame*, const URL&, unsigned = DefaultDocumentClass, unsigned constructionFlags = 0);	1535	Document(Frame*, const URL&, unsigned = DefaultDocumentClass, unsigned constructionFlags = 0);
Lines 1726-1731 private: a/Source/WebCore/dom/Document.h_sec3
1726		1729
1727	Element* m_cssTarget { nullptr };	1730	Element* m_cssTarget { nullptr };
1728		1731
		1732	LazyLoadImageObserver* m_lazyLoadImageObserver { nullptr };
		1733
1729	RefPtr<SerializedScriptValue> m_pendingStateObject;	1734	RefPtr<SerializedScriptValue> m_pendingStateObject;
1730	MonotonicTime m_documentCreationTime;	1735	MonotonicTime m_documentCreationTime;
1731	bool m_overMinimumLayoutThreshold { false };	1736	bool m_overMinimumLayoutThreshold { false };

Lines 163-168 language a/Source/WebCore/html/HTMLAttributeNames.in_sec1
- a/Source/WebCore/html/HTMLAttributeNames.in +1 lines
163	leftmargin	163	leftmargin
164	link	164	link
165	list	165	list
		166	loading
166	longdesc	167	longdesc
167	loop	168	loop
168	low	169	low



#include "Settings.h"
#include "ShadowRoot.h"
#include "SizesAttributeParser.h"
#include "StyleProperties.h"
#include <wtf/IsoMallocInlines.h>
#include <wtf/text/StringBuilder.h>



using namespace HTMLNames;

HTMLImageElement::HTMLImageElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form, bool createdByParser)
    : HTMLElement(tagName, document)
    , m_imageLoader(*this)
    , m_form(nullptr)

    , m_compositeOperator(CompositeSourceOver)
    , m_imageDevicePixelRatio(1.0f)
    , m_experimentalImageMenuEnabled(false)
    , m_createdByParser(createdByParser)
{
    ASSERT(hasTagName(imgTag));
    setHasCustomStyleResolveCallbacks();


Ref<HTMLImageElement> HTMLImageElement::create(Document& document)
{
    return adoptRef(*new HTMLImageElement(imgTag, document, nullptr, false));
}

Ref<HTMLImageElement> HTMLImageElement::create(const QualifiedName& tagName, Document& document, HTMLFormElement* form, bool createdByParser)
{
    return adoptRef(*new HTMLImageElement(tagName, document, form, createdByParser));
}

HTMLImageElement::~HTMLImageElement()


Ref<HTMLImageElement> HTMLImageElement::createForJSConstructor(Document& document, Optional<unsigned> width, Optional<unsigned> height)
{
    auto image = adoptRef(*new HTMLImageElement(imgTag, document, nullptr, false));
    if (width)
        image->setWidth(width.value());
    if (height)

        m_experimentalImageMenuEnabled = !value.isNull();
        updateImageControls();
#endif
    } else if (name == x_apple_editable_imageAttr) {
        updateEditableImage();
    } else if (name == loadingAttr && equalLettersIgnoringASCIICase(value, "eager")) {
//             !GetDocument().IsLazyLoadPolicyEnforced()) {
        loadDeferredImage();
    } else {
        if (name == nameAttr) {
            bool willHaveName = !value.isNull();
            if (m_hadNameBeforeAttributeChanged != willHaveName && isConnected() && !isInShadowTree() && is<HTMLDocument>(document())) {

    HTMLElement::defaultEventHandler(event);
}

void HTMLImageElement::loadDeferredImage()
{
    m_imageLoader.loadDeferredImage();
}

// Minimum height or width of the image to start lazyloading.
constexpr int kMinDimensionToLazyLoad = 10;

bool HTMLImageElement::isDimensionSmallAndAbsoluteForLazyLoad(const AtomicString& attributeValue)
{
    auto optionalDimension = parseValidHTMLNonNegativeInteger(attributeValue);
    return optionalDimension && optionalDimension.value() <= kMinDimensionToLazyLoad;
}

bool HTMLImageElement::isInlineStyleDimensionsSmall(const StyleProperties* propertySet)
{
    if (!propertySet)
        return false;
    auto height = propertySet->getPropertyCSSValue(CSSPropertyHeight);
    auto width = propertySet->getPropertyCSSValue(CSSPropertyWidth);
    if (!height || !height->isPrimitiveValue() || !width || !width->isPrimitiveValue())
        return false;
    const auto& widthPrim = downcast<CSSPrimitiveValue>(*width);
    const auto& heightPrim = downcast<CSSPrimitiveValue>(*height);
    return heightPrim.isPx() && (heightPrim.doubleValue() <= kMinDimensionToLazyLoad)
        && widthPrim.isPx() && (widthPrim.doubleValue() <= kMinDimensionToLazyLoad);
}

}

Lines 44-50 class HTMLImageElement : public HTMLElement, public FormNamedItem { a/Source/WebCore/html/HTMLImageElement.h_sec1
- a/Source/WebCore/html/HTMLImageElement.h -2 / +10 lines
44	friend class HTMLFormElement;	44	friend class HTMLFormElement;
45	public:	45	public:
46	static Ref<HTMLImageElement> create(Document&);	46	static Ref<HTMLImageElement> create(Document&);
47	static Ref<HTMLImageElement> create(const QualifiedName&, Document&, HTMLFormElement*);	47	static Ref<HTMLImageElement> create(const QualifiedName&, Document&, HTMLFormElement*, bool createdByParser);
48	static Ref<HTMLImageElement> createForJSConstructor(Document&, Optional<unsigned> width, Optional<unsigned> height);	48	static Ref<HTMLImageElement> createForJSConstructor(Document&, Optional<unsigned> width, Optional<unsigned> height);
49		49
50	virtual ~HTMLImageElement();	50	virtual ~HTMLImageElement();
Lines 123-130 public: a/Source/WebCore/html/HTMLImageElement.h_sec2
123		123
124	void defaultEventHandler(Event&) final;	124	void defaultEventHandler(Event&) final;
125		125
		126	void loadDeferredImage();
		127
		128	bool createdByParser() const { return m_createdByParser; }
		129
		130	static bool isDimensionSmallAndAbsoluteForLazyLoad(const AtomicString&);
		131	static bool isInlineStyleDimensionsSmall(const StyleProperties*);
		132
126	protected:	133	protected:
127	HTMLImageElement(const QualifiedName&, Document&, HTMLFormElement* = 0);	134	HTMLImageElement(const QualifiedName&, Document&, HTMLFormElement*, bool createdByParser);
128		135
129	void didMoveToNewDocument(Document& oldDocument, Document& newDocument) override;	136	void didMoveToNewDocument(Document& oldDocument, Document& newDocument) override;
130		137
Lines 183-188 private: a/Source/WebCore/html/HTMLImageElement.h_sec3
183	float m_imageDevicePixelRatio;	190	float m_imageDevicePixelRatio;
184	bool m_experimentalImageMenuEnabled;	191	bool m_experimentalImageMenuEnabled;
185	bool m_hadNameBeforeAttributeChanged { false }; // FIXME: We only need this because parseAttribute() can't see the old value.	192	bool m_hadNameBeforeAttributeChanged { false }; // FIXME: We only need this because parseAttribute() can't see the old value.
		193	bool m_createdByParser { false };
186		194
187	RefPtr<EditableImageReference> m_editableImage;	195	RefPtr<EditableImageReference> m_editableImage;
188	WeakPtr<HTMLPictureElement> m_pictureElement;	196	WeakPtr<HTMLPictureElement> m_pictureElement;

Lines 44-49 a/Source/WebCore/html/HTMLImageElement.idl_sec1
- a/Source/WebCore/html/HTMLImageElement.idl +2 lines
44		44
45	[Conditional=ATTACHMENT_ELEMENT, EnabledAtRuntime=AttachmentElement] readonly attribute DOMString attachmentIdentifier;	45	[Conditional=ATTACHMENT_ELEMENT, EnabledAtRuntime=AttachmentElement] readonly attribute DOMString attachmentIdentifier;
46		46
		47	[EnabledAtRuntime=LazyImageLoading, CEReactions, Reflect] attribute DOMString loading;
		48
47	// Extensions	49	// Extensions
48	readonly attribute boolean complete;	50	readonly attribute boolean complete;
49	[CEReactions=NotNeeded, Reflect, URL] attribute USVString lowsrc;	51	[CEReactions=NotNeeded, Reflect, URL] attribute USVString lowsrc;

Lines 67-73 html a/Source/WebCore/html/HTMLTagNames.in_sec1
- a/Source/WebCore/html/HTMLTagNames.in -1 / +1 lines
67	i interfaceName=HTMLElement	67	i interfaceName=HTMLElement
68	iframe interfaceName=HTMLIFrameElement	68	iframe interfaceName=HTMLIFrameElement
69	image interfaceName=HTMLUnknownElement	69	image interfaceName=HTMLUnknownElement
70	img interfaceName=HTMLImageElement, constructorNeedsFormElement	70	img interfaceName=HTMLImageElement, constructorNeedsFormElement, constructorNeedsCreatedByParser
71	input constructorNeedsFormElement, constructorNeedsCreatedByParser	71	input constructorNeedsFormElement, constructorNeedsCreatedByParser
72	ins interfaceName=HTMLModElement	72	ins interfaceName=HTMLModElement
73	kbd interfaceName=HTMLElement	73	kbd interfaceName=HTMLElement

Lines 102-108 public: a/Source/WebCore/html/ImageDocument.cpp_sec1
- a/Source/WebCore/html/ImageDocument.cpp -1 / +1 lines
102		102
103	private:	103	private:
104	ImageDocumentElement(ImageDocument& document)	104	ImageDocumentElement(ImageDocument& document)
105	: HTMLImageElement(imgTag, document)	105	: HTMLImageElement(imgTag, document, nullptr, false)
106	, m_imageDocument(&document)	106	, m_imageDocument(&document)
107	{	107	{
108	}	108	}



/*
 * Copyright (C) 2019 Igalia S.L.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "LazyLoadImageObserver.h"

#include "Frame.h"
#include "HTMLImageElement.h"
#include "IntersectionObserverCallback.h"
#include "RenderStyle.h"

#include <limits>

namespace WebCore {

class IntersectionObserverCallbackImpl final : public IntersectionObserverCallback {
public:
    static Ref<IntersectionObserverCallbackImpl> create(Document* document)
    {
        return adoptRef(*new IntersectionObserverCallbackImpl(document));
    }
    IntersectionObserverCallbackImpl(Document* document)
        : IntersectionObserverCallback(document), m_document(document)
    {
    }
    CallbackResult<void> handleEvent(const Vector<Ref<IntersectionObserverEntry>>& entries, IntersectionObserver&)
    {
        ASSERT(!entries.isEmpty());

        for (auto& entry : entries) {
            if (!entry->isIntersecting())
                continue;
            Element* element = entry->target();
            if (is<HTMLImageElement>(element))
                downcast<HTMLImageElement>(*element).loadDeferredImage();

            // Load the background image if the element has one deferred.
            if (const auto* style = element->computedStyle())
                style->loadDeferredImages(*m_document);

            m_document->ensureLazyLoadImageObserver().stopMonitoring(*element);
        }
        return { };
    }
private:
    Document* m_document;
};

namespace {

Document* getRootDocumentOrNull(const Element& element)
{
    if (Frame* frame = element.document().frame())
        return frame->tree().top().document();
    return nullptr;
}

} // namespace

void LazyLoadImageObserver::startMonitoring(Element& element)
{
    if (Document* document = getRootDocumentOrNull(element))
        document->ensureLazyLoadImageObserver().startMonitoringNearViewport(document, element);
}

void LazyLoadImageObserver::stopMonitoring(Element& element)
{
    if (Document* document = getRootDocumentOrNull(element))
        document->ensureLazyLoadImageObserver().m_lazyLoadIntersectionObserver->unobserve(element);
}

LazyLoadImageObserver::LazyLoadImageObserver() = default;

void LazyLoadImageObserver::startMonitoringNearViewport(Document* rootDocument, Element& element)
{
    if (!m_lazyLoadIntersectionObserver) {
        auto callback = IntersectionObserverCallbackImpl::create(rootDocument);
        auto options = IntersectionObserver::Init { nullptr, "", { } };
        auto observer = IntersectionObserver::create(*rootDocument, WTFMove(callback), WTFMove(options));
        if (observer.hasException())
            return;
        m_lazyLoadIntersectionObserver = observer.returnValue().ptr();
    }
    m_lazyLoadIntersectionObserver->observe(element);
}

}



/*
 * Copyright (C) 2019 Igalia S.L.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include "IntersectionObserver.h"

namespace WebCore {

class Document;
class Element;

class LazyLoadImageObserver {
public:
    LazyLoadImageObserver();

    static void startMonitoring(Element&);
    static void stopMonitoring(Element&);

private:
    void startMonitoringNearViewport(Document*, Element&);

    // The intersection observer responsible for loading the image once it's near
    // the viewport.
    RefPtr<IntersectionObserver> m_lazyLoadIntersectionObserver;
};

} // namespace

Lines 28-33 a/Source/WebCore/html/parser/HTMLPreloadScanner.cpp_sec1
- a/Source/WebCore/html/parser/HTMLPreloadScanner.cpp +31 lines
28	#include "config.h"	28	#include "config.h"
29	#include "HTMLPreloadScanner.h"	29	#include "HTMLPreloadScanner.h"
30		30
		31	#include "HTMLImageElement.h"
31	#include "HTMLNames.h"	32	#include "HTMLNames.h"
32	#include "HTMLParserIdioms.h"	33	#include "HTMLParserIdioms.h"
33	#include "HTMLSrcsetParser.h"	34	#include "HTMLSrcsetParser.h"
Lines 43-48 a/Source/WebCore/html/parser/HTMLPreloadScanner.cpp_sec2
43	#include "RenderView.h"	44	#include "RenderView.h"
44	#include "RuntimeEnabledFeatures.h"	45	#include "RuntimeEnabledFeatures.h"
45	#include "SizesAttributeParser.h"	46	#include "SizesAttributeParser.h"
		47	#include "StyleProperties.h"
46	#include <wtf/MainThread.h>	48	#include <wtf/MainThread.h>
47		49
48	namespace WebCore {	50	namespace WebCore {
Lines 165-170 public: a/Source/WebCore/html/parser/HTMLPreloadScanner.cpp_sec3
165	request->setCrossOriginMode(m_crossOriginMode);	167	request->setCrossOriginMode(m_crossOriginMode);
166	request->setNonce(m_nonceAttribute);	168	request->setNonce(m_nonceAttribute);
167		169
		170	if ((equalLettersIgnoringASCIICase(m_lazyloadAttribute, "lazy")
		171	\|\| equalLettersIgnoringASCIICase(m_lazyloadAttribute, "auto"))
		172	&& !((m_widthAttrSmallAbsolute && m_heightAttrSmallAbsolute) \|\| m_inlineStyleDimensionsSmall))
		173	request->setLazyloadImageEnabled(true);
		174
168	// According to the spec, the module tag ignores the "charset" attribute as the same to the worker's	175	// According to the spec, the module tag ignores the "charset" attribute as the same to the worker's
169	// importScript. But WebKit supports the "charset" for importScript intentionally. So to be consistent,	176	// importScript. But WebKit supports the "charset" for importScript intentionally. So to be consistent,
170	// even for the module tags, we handle the "charset" attribute.	177	// even for the module tags, we handle the "charset" attribute.
Lines 206-211 private: a/Source/WebCore/html/parser/HTMLPreloadScanner.cpp_sec4
206	m_sizesAttribute = attributeValue;	213	m_sizesAttribute = attributeValue;
207	break;	214	break;
208	}	215	}
		216	if (match(attributeName, loadingAttr) && m_lazyloadAttribute.isNull()) {
		217	m_lazyloadAttribute = attributeValue;
		218	break;
		219	}
		220	if (RuntimeEnabledFeatures::sharedFeatures().lazyImageLoadingEnabled()) {
		221	if (match(attributeName, widthAttr) && !m_widthAttrSmallAbsolute) {
		222	m_widthAttrSmallAbsolute = HTMLImageElement::isDimensionSmallAndAbsoluteForLazyLoad(attributeValue);
		223	break;
		224	}
		225	if (match(attributeName, heightAttr) && !m_heightAttrSmallAbsolute) {
		226	m_heightAttrSmallAbsolute = HTMLImageElement::isDimensionSmallAndAbsoluteForLazyLoad(attributeValue);
		227	break;
		228	}
		229	if (match(attributeName, styleAttr) && !m_inlineStyleDimensionsSmall) {
		230	CSSParserMode mode = /media_values_->StrictMode() ? HTMLStandardMode :/ HTMLQuirksMode;
		231	const auto propertySet = CSSParser::parseInlineStyleDeclaration(attributeValue, mode);
		232	m_inlineStyleDimensionsSmall = HTMLImageElement::isInlineStyleDimensionsSmall(propertySet.ptr());
		233	}
		234	}
		235
209	processImageAndScriptAttribute(attributeName, attributeValue);	236	processImageAndScriptAttribute(attributeName, attributeValue);
210	break;	237	break;
211	case TagId::Source:	238	case TagId::Source:
Lines 365-373 private: a/Source/WebCore/html/parser/HTMLPreloadScanner.cpp_sec5
365	String m_metaContent;	392	String m_metaContent;
366	String m_asAttribute;	393	String m_asAttribute;
367	String m_typeAttribute;	394	String m_typeAttribute;
		395	String m_lazyloadAttribute;
368	bool m_metaIsViewport;	396	bool m_metaIsViewport;
369	bool m_metaIsDisabledAdaptations;	397	bool m_metaIsDisabledAdaptations;
370	bool m_inputIsImage;	398	bool m_inputIsImage;
		399	bool m_widthAttrSmallAbsolute { false };
		400	bool m_heightAttrSmallAbsolute { false };
		401	bool m_inlineStyleDimensionsSmall { false };
371	float m_deviceScaleFactor;	402	float m_deviceScaleFactor;
372	PreloadRequest::ModuleScript m_moduleScript { PreloadRequest::ModuleScript::No };	403	PreloadRequest::ModuleScript m_moduleScript { PreloadRequest::ModuleScript::No };
373	};	404	};



    if (skipContentSecurityPolicyCheck)
        options.contentSecurityPolicyImposition = ContentSecurityPolicyImposition::SkipPolicyCheck;

    ResourceRequest resourceRequest(completeURL(document));
    if (m_lazyloadImageEnabled) {
        resourceRequest.setHTTPHeaderField(HTTPHeaderName::Range, "bytes=0-2047");
        options.cache = FetchOptions::Cache::NoStore;
    }

    String crossOriginMode = m_crossOriginMode;
    if (m_moduleScript == ModuleScript::Yes) {
        if (crossOriginMode.isNull())
            crossOriginMode = "omit"_s;
    }
    auto request = createPotentialAccessControlRequest(WTFMove(resourceRequest), document, crossOriginMode, WTFMove(options));
    request.setInitiator(m_initiator);
    return request;
}



    void setCharset(const String& charset) { m_charset = charset.isolatedCopy(); }
    void setCrossOriginMode(const String& mode) { m_crossOriginMode = mode; }
    void setNonce(const String& nonce) { m_nonceAttribute = nonce; }
    void setLazyloadImageEnabled(bool enabled) { m_lazyloadImageEnabled = enabled; }
    CachedResource::Type resourceType() const { return m_resourceType; }

private:

    String m_crossOriginMode;
    String m_nonceAttribute;
    ModuleScript m_moduleScript;
    bool m_lazyloadImageEnabled { false };
};

typedef Vector<std::unique_ptr<PreloadRequest>> PreloadRequestStream;

Lines 38-46 a/Source/WebCore/loader/ImageLoader.cpp_sec1
- a/Source/WebCore/loader/ImageLoader.cpp +59 lines
38	#include "HTMLObjectElement.h"	38	#include "HTMLObjectElement.h"
39	#include "HTMLParserIdioms.h"	39	#include "HTMLParserIdioms.h"
40	#include "InspectorInstrumentation.h"	40	#include "InspectorInstrumentation.h"
		41	#include "LazyLoadImageObserver.h"
41	#include "Page.h"	42	#include "Page.h"
42	#include "RenderImage.h"	43	#include "RenderImage.h"
43	#include "RenderSVGImage.h"	44	#include "RenderSVGImage.h"
		45	#include "RuntimeEnabledFeatures.h"
		46	#include "StyleProperties.h"
44	#include <wtf/NeverDestroyed.h>	47	#include <wtf/NeverDestroyed.h>
45		48
46	#if ENABLE(VIDEO)	49	#if ENABLE(VIDEO)
Lines 66-71 template<> struct ValueCheck<WebCore::ImageLoader*> { a/Source/WebCore/loader/ImageLoader.cpp_sec2
66		69
67	namespace WebCore {	70	namespace WebCore {
68		71
		72	static bool isLazyLoadableImage(const HTMLImageElement& htmlImage, const URL& url)
		73	{
		74	// Do not lazyload image elements created from javascript.
		75	if (!htmlImage.createdByParser())
		76	return false;
		77	if (!url.protocolIsInHTTPFamily())
		78	return false;
		79	if (equalLettersIgnoringASCIICase(htmlImage.attributeWithoutSynchronization(HTMLNames::loadingAttr), "eager"))
		80	return false;
		81	// Avoid lazyloading if width and height attributes are small. This
		82	// heuristic helps avoid double fetching tracking pixels.
		83	if (HTMLImageElement::isDimensionSmallAndAbsoluteForLazyLoad(htmlImage.attributeWithoutSynchronization(HTMLNames::widthAttr))
		84	&& HTMLImageElement::isDimensionSmallAndAbsoluteForLazyLoad(htmlImage.attributeWithoutSynchronization(HTMLNames::heightAttr)))
		85	return false;
		86	// Avoid lazyloading if width or height is specified in inline style and is
		87	// small enough. This heuristic helps avoid double fetching tracking pixels.
		88	if (HTMLImageElement::isInlineStyleDimensionsSmall(htmlImage.inlineStyle()))
		89	return false;
		90	return true;
		91	}
		92
69	static ImageEventSender& beforeLoadEventSender()	93	static ImageEventSender& beforeLoadEventSender()
70	{	94	{
71	static NeverDestroyed<ImageEventSender> sender(eventNames().beforeloadEvent);	95	static NeverDestroyed<ImageEventSender> sender(eventNames().beforeloadEvent);
Lines 183-188 void ImageLoader::updateFromElement() a/Source/WebCore/loader/ImageLoader.cpp_sec3
183		207
184	ResourceRequest resourceRequest(document.completeURL(sourceURI(attr)));	208	ResourceRequest resourceRequest(document.completeURL(sourceURI(attr)));
185	resourceRequest.setInspectorInitiatorNodeIdentifier(InspectorInstrumentation::identifierForNode(m_element));	209	resourceRequest.setInspectorInitiatorNodeIdentifier(InspectorInstrumentation::identifierForNode(m_element));
		210	if (m_lazyImageLoadState == LazyImageLoadState::kNone) {
		211	if (is<HTMLImageElement>(element())) {
		212	if (isLazyLoadableImage(downcast<HTMLImageElement>(element()), resourceRequest.url())
		213	&& RuntimeEnabledFeatures::sharedFeatures().lazyImageLoadingEnabled()) {
		214	m_lazyImageLoadState = LazyImageLoadState::kDeferred;
		215	resourceRequest.setHTTPHeaderField(HTTPHeaderName::Range, "bytes=0-2047");
		216	options.cache = FetchOptions::Cache::NoStore;
		217	}
		218	}
		219	}
186		220
187	auto request = createPotentialAccessControlRequest(WTFMove(resourceRequest), document, crossOriginAttribute, WTFMove(options));	221	auto request = createPotentialAccessControlRequest(WTFMove(resourceRequest), document, crossOriginAttribute, WTFMove(options));
188	request.setInitiator(element());	222	request.setInitiator(element());
Lines 250-255 void ImageLoader::updateFromElement() a/Source/WebCore/loader/ImageLoader.cpp_sec4
250	} else	284	} else
251	updateRenderer();	285	updateRenderer();
252		286
		287	if (m_lazyImageLoadState == LazyImageLoadState::kDeferred)
		288	LazyLoadImageObserver::startMonitoring(element());
253	// If newImage is cached, addClient() will result in the load event	289	// If newImage is cached, addClient() will result in the load event
254	// being queued to fire. Ensure this happens after beforeload is	290	// being queued to fire. Ensure this happens after beforeload is
255	// dispatched.	291	// dispatched.
Lines 280-285 void ImageLoader::notifyFinished(CachedResource& resource) a/Source/WebCore/loader/ImageLoader.cpp_sec5
280	ASSERT(m_failedLoadURL.isEmpty());	316	ASSERT(m_failedLoadURL.isEmpty());
281	ASSERT_UNUSED(resource, &resource == m_image.get());	317	ASSERT_UNUSED(resource, &resource == m_image.get());
282		318
		319	if (m_lazyImageLoadState == LazyImageLoadState::kDeferred) {
		320	// LazyImages: if a placeholder is loaded, suppress load events and do not
		321	// consider the image as loaded, except for unblocking document load events.
		322	// The final image load (including load events) occurs when the
		323	// non-placeholder image loading (triggered by loadDeferredImage()) is
		324	// finished.
		325	if (resource.response().httpStatusCode() == 206)
		326	return;
		327	// A placeholder was requested, but the result was an error or a full image.
		328	// In these cases, consider this as the final image and suppress further
		329	// reloading and proceed to the image load completion process below.
		330	LazyLoadImageObserver::stopMonitoring(element());
		331	m_lazyImageLoadState = LazyImageLoadState::kFullImage;
		332	}
		333
283	m_imageComplete = true;	334	m_imageComplete = true;
284	if (!hasPendingBeforeLoadEvent())	335	if (!hasPendingBeforeLoadEvent())
285	updateRenderer();	336	updateRenderer();
Lines 542-545 inline void ImageLoader::clearFailedLoadURL() a/Source/WebCore/loader/ImageLoader.cpp_sec6
542	m_failedLoadURL = nullAtom();	593	m_failedLoadURL = nullAtom();
543	}	594	}
544		595
		596	void ImageLoader::loadDeferredImage()
		597	{
		598	if (m_lazyImageLoadState != LazyImageLoadState::kDeferred)
		599	return;
		600	m_lazyImageLoadState = LazyImageLoadState::kFullImage;
		601	updateFromElement();
		602	}
		603
545	}	604	}

Lines 74-84 public: a/Source/WebCore/loader/ImageLoader.h_sec1
- a/Source/WebCore/loader/ImageLoader.h +6 lines
74	static void dispatchPendingLoadEvents();	74	static void dispatchPendingLoadEvents();
75	static void dispatchPendingErrorEvents();	75	static void dispatchPendingErrorEvents();
76		76
		77	void loadDeferredImage();
		78
77	protected:	79	protected:
78	explicit ImageLoader(Element&);	80	explicit ImageLoader(Element&);
79	void notifyFinished(CachedResource&) override;	81	void notifyFinished(CachedResource&) override;
80		82
81	private:	83	private:
		84	// LazyImages: Defer the image load until the image is near the viewport.
		85	enum class LazyImageLoadState { kNone, kDeferred, kFullImage };
		86
82	virtual void dispatchLoadEvent() = 0;	87	virtual void dispatchLoadEvent() = 0;
83	virtual String sourceURI(const AtomicString&) const = 0;	88	virtual String sourceURI(const AtomicString&) const = 0;
84		89
Lines 112-117 private: a/Source/WebCore/loader/ImageLoader.h_sec2
112	bool m_imageComplete : 1;	117	bool m_imageComplete : 1;
113	bool m_loadManually : 1;	118	bool m_loadManually : 1;
114	bool m_elementIsProtected : 1;	119	bool m_elementIsProtected : 1;
		120	LazyImageLoadState m_lazyImageLoadState { LazyImageLoadState::kNone };
115	};	121	};
116		122
117	}	123	}

Lines 353-358 public: a/Source/WebCore/page/RuntimeEnabledFeatures.h_sec1
- a/Source/WebCore/page/RuntimeEnabledFeatures.h +5 lines
353	bool pageAtRuleSupportEnabled() const { return m_pageAtRuleSupportEnabled; }	353	bool pageAtRuleSupportEnabled() const { return m_pageAtRuleSupportEnabled; }
354	void setPageAtRuleSupportEnabled(bool isEnabled) { m_pageAtRuleSupportEnabled = isEnabled; }	354	void setPageAtRuleSupportEnabled(bool isEnabled) { m_pageAtRuleSupportEnabled = isEnabled; }
355		355
		356	void setLazyImageLoadingEnabled(bool areEnabled) { m_lazyImageLoadingEnabled = areEnabled; }
		357	bool lazyImageLoadingEnabled() const { return m_lazyImageLoadingEnabled; }
		358
356	WEBCORE_EXPORT static RuntimeEnabledFeatures& sharedFeatures();	359	WEBCORE_EXPORT static RuntimeEnabledFeatures& sharedFeatures();
357		360
358	private:	361	private:
Lines 535-540 private: a/Source/WebCore/page/RuntimeEnabledFeatures.h_sec2
535		538
536	bool m_referrerPolicyAttributeEnabled { false };	539	bool m_referrerPolicyAttributeEnabled { false };
537		540
		541	bool m_lazyImageLoadingEnabled { false };
		542
538	friend class WTF::NeverDestroyed<RuntimeEnabledFeatures>;	543	friend class WTF::NeverDestroyed<RuntimeEnabledFeatures>;
539	};	544	};
540		545

Lines 735-740 resizeObserverEnabled: a/Source/WebCore/page/Settings.yaml_sec1
- a/Source/WebCore/page/Settings.yaml +3 lines
735	initial: false	735	initial: false
736	conditional: RESIZE_OBSERVER	736	conditional: RESIZE_OBSERVER
737		737
		738	lazyImageLoadingEnabled:
		739	initial: false
		740
738	# Only set by Layout Tests.	741	# Only set by Layout Tests.
739	mediaTypeOverride:	742	mediaTypeOverride:
740	type: String	743	type: String



#include "CSSParser.h"
#include "CSSPropertyNames.h"
#include "CSSPropertyParser.h"
#include "CachedImage.h"
#include "ContentData.h"
#include "CursorList.h"
#include "FloatRoundedRect.h"

#include "ScaleTransformOperation.h"
#include "ShadowData.h"
#include "StyleBuilderConverter.h"
#include "StyleCachedImage.h"
#include "StyleImage.h"
#include "StyleInheritedData.h"
#include "StyleResolver.h"

    return visitedDependentColor(propertyID);
}

void RenderStyle::loadDeferredImages(Document& document) const
{
    if (hasBackgroundImage()) {
        for (auto* layer = &backgroundLayers(); layer; layer = layer->next()) {
            if (layer->image() && is<StyleCachedImage>(*layer->image()))
                downcast<StyleCachedImage>(*layer->image()).loadDeferredImage(document);
        }
    }
}

} // namespace WebCore

Lines 1448-1454 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec1
- a/Source/WebCore/rendering/style/RenderStyle.h -1 / +3 lines
1448		1448
1449	void setHasExplicitlyInheritedProperties() { m_nonInheritedFlags.hasExplicitlyInheritedProperties = true; }	1449	void setHasExplicitlyInheritedProperties() { m_nonInheritedFlags.hasExplicitlyInheritedProperties = true; }
1450	bool hasExplicitlyInheritedProperties() const { return m_nonInheritedFlags.hasExplicitlyInheritedProperties; }	1450	bool hasExplicitlyInheritedProperties() const { return m_nonInheritedFlags.hasExplicitlyInheritedProperties; }
1451		1451
		1452	void loadDeferredImages(Document&) const;
		1453
1452	// Initial values for all the properties	1454	// Initial values for all the properties
1453	static Overflow initialOverflowX() { return Overflow::Visible; }	1455	static Overflow initialOverflowX() { return Overflow::Visible; }
1454	static Overflow initialOverflowY() { return Overflow::Visible; }	1456	static Overflow initialOverflowY() { return Overflow::Visible; }

Lines 28-33 a/Source/WebCore/rendering/style/StyleCachedImage.cpp_sec1
- a/Source/WebCore/rendering/style/StyleCachedImage.cpp +16 lines
28	#include "CSSImageSetValue.h"	28	#include "CSSImageSetValue.h"
29	#include "CSSImageValue.h"	29	#include "CSSImageValue.h"
30	#include "CachedImage.h"	30	#include "CachedImage.h"
		31	#include "LazyLoadImageObserver.h"
31	#include "RenderElement.h"	32	#include "RenderElement.h"
32	#include "RenderView.h"	33	#include "RenderView.h"
33		34
Lines 192-197 void StyleCachedImage::addClient(RenderElement* renderer) a/Source/WebCore/rendering/style/StyleCachedImage.cpp_sec2
192	return;	193	return;
193	ASSERT(renderer);	194	ASSERT(renderer);
194	m_cachedImage->addClient(*renderer);	195	m_cachedImage->addClient(*renderer);
		196	if (is<CSSImageValue>(m_cssValue) && renderer->element())
		197	LazyLoadImageObserver::startMonitoring(*renderer->element());
195	}	198	}
196		199
197	void StyleCachedImage::removeClient(RenderElement* renderer)	200	void StyleCachedImage::removeClient(RenderElement* renderer)
Lines 202-207 void StyleCachedImage::removeClient(RenderElement* renderer) a/Source/WebCore/rendering/style/StyleCachedImage.cpp_sec3
202	ASSERT(renderer);	205	ASSERT(renderer);
203		206
204	m_cachedImage->removeClient(*renderer);	207	m_cachedImage->removeClient(*renderer);
		208	if (is<CSSImageValue>(m_cssValue) && renderer->element())
		209	LazyLoadImageObserver::stopMonitoring(*renderer->element());
205	}	210	}
206		211
207	RefPtr<Image> StyleCachedImage::image(RenderElement* renderer, const FloatSize&) const	212	RefPtr<Image> StyleCachedImage::image(RenderElement* renderer, const FloatSize&) const
Lines 224-227 bool StyleCachedImage::knownToBeOpaque(const RenderElement* renderer) const a/Source/WebCore/rendering/style/StyleCachedImage.cpp_sec4
224	return m_cachedImage->currentFrameKnownToBeOpaque(renderer);	229	return m_cachedImage->currentFrameKnownToBeOpaque(renderer);
225	}	230	}
226		231
		232	void StyleCachedImage::loadDeferredImage(Document& document)
		233	{
		234	if (!is<CSSImageValue>(m_cssValue))
		235	return;
		236	ResourceLoaderOptions options;
		237	options.cache = FetchOptions::Cache::Reload;
		238	auto& imageValue = downcast<CSSImageValue>(m_cssValue.get());
		239	m_cachedImage = imageValue.loadImage(document.cachedResourceLoader(), options, !imageURL().protocolIsInHTTPFamily());
		240	m_cachedImage->setLoading(true);
		241	}
		242
227	}	243	}

Lines 63-68 public: a/Source/WebCore/rendering/style/StyleCachedImage.h_sec1
- a/Source/WebCore/rendering/style/StyleCachedImage.h +2 lines
63	float imageScaleFactor() const final;	63	float imageScaleFactor() const final;
64	bool knownToBeOpaque(const RenderElement*) const final;	64	bool knownToBeOpaque(const RenderElement*) const final;
65		65
		66	void loadDeferredImage(Document&);
		67
66	private:	68	private:
67	StyleCachedImage(CSSValue&);	69	StyleCachedImage(CSSValue&);
68	URL imageURL();	70	URL imageURL();



  type: bool
  defaultValue: true
  condition: ENABLE(MEDIA_STREAM)

LazyImageLoadingEnabled:
  type: bool
  defaultValue: false
  humanReadableName: "Lazy Image Loading"
  humanReadableDescription: "Enable Lazy Image Loading support"
  category: experimental
  webcoreBinding: RuntimeEnabledFeatures

Lines 268-270 a/Source/WebKitLegacy/mac/WebView/WebPreferenceKeysPrivate.h_sec1
- a/Source/WebKitLegacy/mac/WebView/WebPreferenceKeysPrivate.h +1 lines
268	#define WebKitAdClickAttributionEnabledPreferenceKey @"WebKitAdClickAttributionEnabled"	268	#define WebKitAdClickAttributionEnabledPreferenceKey @"WebKitAdClickAttributionEnabled"
269	#define WebKitReferrerPolicyAttributeEnabledPreferenceKey @"WebKitReferrerPolicyAttributeEnabled"	269	#define WebKitReferrerPolicyAttributeEnabledPreferenceKey @"WebKitReferrerPolicyAttributeEnabled"
270	#define WebKitResizeObserverEnabledPreferenceKey @"WebKitResizeObserverEnabled"	270	#define WebKitResizeObserverEnabledPreferenceKey @"WebKitResizeObserverEnabled"
		271	#define WebKitLazyImageLoadingEnabledPreferenceKey @"WebKitLazyImageLoadingEnabled"



#if ENABLE(RESIZE_OBSERVER)
        @NO, WebKitResizeObserverEnabledPreferenceKey,
#endif
        @NO, WebKitLazyImageLoadingEnabledPreferenceKey,
        nil];

#if !PLATFORM(IOS_FAMILY)

{
    [self _setBoolValue:flag forKey:WebKitResizeObserverEnabledPreferenceKey];
}

- (BOOL)lazyImageLoadingEnabled
{
    return [self _boolValueForKey:WebKitLazyImageLoadingEnabledPreferenceKey];
}

- (void)setLazyImageLoadingEnabled:(BOOL)flag
{
    [self _setBoolValue:flag forKey:WebKitLazyImageLoadingEnabledPreferenceKey];
}
@end

@implementation WebPreferences (WebInternal)

Lines 635-640 extern NSString *WebPreferencesCacheModelChangedInternalNotification WEBKIT_DEPR a/Source/WebKitLegacy/mac/WebView/WebPreferencesPrivate.h_sec1
- a/Source/WebKitLegacy/mac/WebView/WebPreferencesPrivate.h +1 lines
635	@property (nonatomic) BOOL sourceBufferChangeTypeEnabled;	635	@property (nonatomic) BOOL sourceBufferChangeTypeEnabled;
636	@property (nonatomic) BOOL referrerPolicyAttributeEnabled;	636	@property (nonatomic) BOOL referrerPolicyAttributeEnabled;
637	@property (nonatomic) BOOL resizeObserverEnabled;	637	@property (nonatomic) BOOL resizeObserverEnabled;
		638	@property (nonatomic) BOOL lazyImageLoadingEnabled;
638		639
639	#if TARGET_OS_IPHONE	640	#if TARGET_OS_IPHONE
640	@property (nonatomic) BOOL quickLookDocumentSavingEnabled;	641	@property (nonatomic) BOOL quickLookDocumentSavingEnabled;

Lines 3221-3226 static bool needsSelfRetainWhileLoadingQuirk() a/Source/WebKitLegacy/mac/WebView/WebView.mm_sec1
- a/Source/WebKitLegacy/mac/WebView/WebView.mm +2 lines
3221	#if ENABLE(RESIZE_OBSERVER)	3221	#if ENABLE(RESIZE_OBSERVER)
3222	settings.setResizeObserverEnabled([preferences resizeObserverEnabled]);	3222	settings.setResizeObserverEnabled([preferences resizeObserverEnabled]);
3223	#endif	3223	#endif
		3224
		3225	settings.setLazyImageLoadingEnabled([preferences lazyImageLoadingEnabled]);
3224	}	3226	}
3225		3227
3226	static inline IMP getMethod(id o, SEL s)	3228	static inline IMP getMethod(id o, SEL s)

Lines 240-243 interface IWebPreferencesPrivate7 : IWebPreferencesPrivate6 a/Source/WebKitLegacy/win/Interfaces/IWebPreferencesPrivate.idl_sec1
- a/Source/WebKitLegacy/win/Interfaces/IWebPreferencesPrivate.idl +2 lines
240	HRESULT setCrossOriginWindowPolicySupportEnabled([in] BOOL enabled);	240	HRESULT setCrossOriginWindowPolicySupportEnabled([in] BOOL enabled);
241	HRESULT resizeObserverEnabled([out, retval] BOOL*);	241	HRESULT resizeObserverEnabled([out, retval] BOOL*);
242	HRESULT setResizeObserverEnabled([in] BOOL enabled);	242	HRESULT setResizeObserverEnabled([in] BOOL enabled);
		243	HRESULT lazyImageLoadingEnabled([out, retval] BOOL*);
		244	HRESULT setLazyImageLoadingEnabled([in] BOOL enabled);
243	}	245	}

Lines 207-209 a/Source/WebKitLegacy/win/WebPreferenceKeysPrivate.h_sec1
- a/Source/WebKitLegacy/win/WebPreferenceKeysPrivate.h +2 lines
207	#define WebKitCSSOMViewScrollingAPIEnabledPreferenceKey "WebKitCSSOMViewScrollingAPIEnabled"	207	#define WebKitCSSOMViewScrollingAPIEnabledPreferenceKey "WebKitCSSOMViewScrollingAPIEnabled"
208		208
209	#define WebKitResizeObserverEnabledPreferenceKey "WebKitResizeObserverEnabled"	209	#define WebKitResizeObserverEnabledPreferenceKey "WebKitResizeObserverEnabled"
		210
		211	#define WebKitLazyImageLoadingEnabledPreferenceKey "WebKitLazyImageLoadingEnabled"

Lines 331-336 void WebPreferences::initializeDefaultSettings() a/Source/WebKitLegacy/win/WebPreferences.cpp_sec1
- a/Source/WebKitLegacy/win/WebPreferences.cpp +16 lines
331		331
332	CFDictionaryAddValue(defaults, CFSTR(WebKitResizeObserverEnabledPreferenceKey), kCFBooleanFalse);	332	CFDictionaryAddValue(defaults, CFSTR(WebKitResizeObserverEnabledPreferenceKey), kCFBooleanFalse);
333		333
		334	CFDictionaryAddValue(defaults, CFSTR(WebKitLazyImageLoadingEnabledPreferenceKey), kCFBooleanFalse);
		335
334	defaultSettings = defaults;	336	defaultSettings = defaults;
335	}	337	}
336		338
Lines 2276-2278 HRESULT WebPreferences::setResizeObserverEnabled(BOOL enabled) a/Source/WebKitLegacy/win/WebPreferences.cpp_sec2
2276	setBoolValue(WebKitResizeObserverEnabledPreferenceKey, enabled);	2278	setBoolValue(WebKitResizeObserverEnabledPreferenceKey, enabled);
2277	return S_OK;	2279	return S_OK;
2278	}	2280	}
		2281
		2282	HRESULT WebPreferences::lazyImageLoadingEnabled(_Out_ BOOL* enabled)
		2283	{
		2284	if (!enabled)
		2285	return E_POINTER;
		2286	*enabled = boolValueForKey(WebKitLazyImageLoadingEnabledPreferenceKey);
		2287	return S_OK;
		2288	}
		2289
		2290	HRESULT WebPreferences::setLazyImageLoadingEnabled(BOOL enabled)
		2291	{
		2292	setBoolValue(WebKitLazyImageLoadingEnabledPreferenceKey, enabled);
		2293	return S_OK;
		2294	}

Lines 285-290 public: a/Source/WebKitLegacy/win/WebPreferences.h_sec1
- a/Source/WebKitLegacy/win/WebPreferences.h +2 lines
285	virtual HRESULT STDMETHODCALLTYPE setCrossOriginWindowPolicySupportEnabled(BOOL);	285	virtual HRESULT STDMETHODCALLTYPE setCrossOriginWindowPolicySupportEnabled(BOOL);
286	virtual HRESULT STDMETHODCALLTYPE resizeObserverEnabled(_Out_ BOOL*);	286	virtual HRESULT STDMETHODCALLTYPE resizeObserverEnabled(_Out_ BOOL*);
287	virtual HRESULT STDMETHODCALLTYPE setResizeObserverEnabled(BOOL);	287	virtual HRESULT STDMETHODCALLTYPE setResizeObserverEnabled(BOOL);
		288	virtual HRESULT STDMETHODCALLTYPE lazyImageLoadingEnabled(_Out_ BOOL*);
		289	virtual HRESULT STDMETHODCALLTYPE setLazyImageLoadingEnabled(BOOL);
288		290
289	// WebPreferences	291	// WebPreferences
290		292

Lines 5601-5606 HRESULT WebView::notifyPreferencesChanged(IWebNotification* notification) a/Source/WebKitLegacy/win/WebView.cpp_sec1
- a/Source/WebKitLegacy/win/WebView.cpp +5 lines
5601	return hr;	5601	return hr;
5602	settings.setResizeObserverEnabled(!!enabled);	5602	settings.setResizeObserverEnabled(!!enabled);
5603		5603
		5604	hr = prefsPrivate->lazyImageLoadingEnabled(&enabled);
		5605	if (FAILED(hr))
		5606	return hr;
		5607	settings.setLazyImageLoadingEnabled(!!enabled);
		5608
5604	return S_OK;	5609	return S_OK;
5605	}	5610	}
5606		5611



2019-04-23  Rob Buis  <rbuis@igalia.com>

        Support lazy image and iframe loading (loading="lazy")
        https://bugs.webkit.org/show_bug.cgi?id=196698

        Reviewed by NOBODY (OOPS!).

        * DumpRenderTree/TestOptions.cpp:
        (TestOptions::TestOptions):
        * DumpRenderTree/TestOptions.h:
        * DumpRenderTree/mac/DumpRenderTree.mm:
        (setWebPreferencesForTestOptions):
        * DumpRenderTree/win/DumpRenderTree.cpp:
        (enableExperimentalFeatures):

2019-04-22  Aakash Jain  <aakash_jain@apple.com>

        [ews-build] Improve summary for UploadBuiltProduct step

Lines 113-118 TestOptions::TestOptions(const std::string& pathOrURL, const std::string& absolu a/Tools/DumpRenderTree/TestOptions.cpp_sec1
- a/Tools/DumpRenderTree/TestOptions.cpp +2 lines
113	adClickAttributionEnabled = parseBooleanTestHeaderValue(value);	113	adClickAttributionEnabled = parseBooleanTestHeaderValue(value);
114	else if (key == "experimental:ResizeObserverEnabled")	114	else if (key == "experimental:ResizeObserverEnabled")
115	enableResizeObserver = parseBooleanTestHeaderValue(value);	115	enableResizeObserver = parseBooleanTestHeaderValue(value);
		116	else if (key == "experimental:LazyImageLoadingEnabled")
		117	enableLazyImageLoading = parseBooleanTestHeaderValue(value);
116	pairStart = pairEnd + 1;	118	pairStart = pairEnd + 1;
117	}	119	}
118	}	120	}

Lines 47-52 struct TestOptions { a/Tools/DumpRenderTree/TestOptions.h_sec1
- a/Tools/DumpRenderTree/TestOptions.h +1 lines
47	bool enableCSSLogical { false };	47	bool enableCSSLogical { false };
48	bool adClickAttributionEnabled { false };	48	bool adClickAttributionEnabled { false };
49	bool enableResizeObserver { false };	49	bool enableResizeObserver { false };
		50	bool enableLazyImageLoading { false };
50	std::string jscOptions;	51	std::string jscOptions;
51		52
52	TestOptions(const std::string& pathOrURL, const std::string& absolutePath);	53	TestOptions(const std::string& pathOrURL, const std::string& absolutePath);

Lines 1019-1024 static void setWebPreferencesForTestOptions(const TestOptions& options) a/Tools/DumpRenderTree/mac/DumpRenderTree.mm_sec1
- a/Tools/DumpRenderTree/mac/DumpRenderTree.mm +1 lines
1019	preferences.CSSLogicalEnabled = options.enableCSSLogical;	1019	preferences.CSSLogicalEnabled = options.enableCSSLogical;
1020	preferences.adClickAttributionEnabled = options.adClickAttributionEnabled;	1020	preferences.adClickAttributionEnabled = options.adClickAttributionEnabled;
1021	preferences.resizeObserverEnabled = options.enableResizeObserver;	1021	preferences.resizeObserverEnabled = options.enableResizeObserver;
		1022	preferences.lazyImageLoadingEnabled = options.enableLazyImageLoading;
1022	}	1023	}
1023		1024
1024	// Called once on DumpRenderTree startup.	1025	// Called once on DumpRenderTree startup.

Lines 790-795 static void enableExperimentalFeatures(IWebPreferences* preferences) a/Tools/DumpRenderTree/win/DumpRenderTree.cpp_sec1
- a/Tools/DumpRenderTree/win/DumpRenderTree.cpp +1 lines
790	prefsPrivate->setResizeObserverEnabled(TRUE);	790	prefsPrivate->setResizeObserverEnabled(TRUE);
791	prefsPrivate->setWebAnimationsEnabled(TRUE);	791	prefsPrivate->setWebAnimationsEnabled(TRUE);
792	prefsPrivate->setServerTimingEnabled(TRUE);	792	prefsPrivate->setServerTimingEnabled(TRUE);
		793	prefsPrivate->setLazyImageLoadingEnabled(TRUE);
793	// FIXME: WebGL2	794	// FIXME: WebGL2
794	// FIXME: WebRTC	795	// FIXME: WebRTC
795	}	796	}



2019-04-23  Rob Buis  <rbuis@igalia.com>

        Support lazy image and iframe loading (loading="lazy")
        https://bugs.webkit.org/show_bug.cgi?id=196698

        Reviewed by NOBODY (OOPS!).

        * http/tests/lazyload/attribute-expected.txt: Added.
        * http/tests/lazyload/attribute.html: Added.
        * http/tests/lazyload/fixed-dimension-expected.txt: Added.
        * http/tests/lazyload/fixed-dimension.html: Added.
        * http/tests/lazyload/js-image-expected.txt: Added.
        * http/tests/lazyload/js-image.html: Added.
        * http/tests/lazyload/lazy-expected.txt: Added.
        * http/tests/lazyload/lazy.html: Added.
        * http/tests/lazyload/placeholder.js: Added.
        (is_image_fully_loaded):
        * http/tests/lazyload/scroll-expected.txt: Added.
        * http/tests/lazyload/scroll.html: Added.
        * http/tests/lazyload/style-dimension-expected.txt: Added.
        * http/tests/lazyload/style-dimension.html: Added.

2019-04-22  Zalan Bujtas  <zalan@apple.com>

        [ContentChangeObserver] Some dropdown menus may close without user gesture on americanexpress.com



2019-04-23  Rob Buis  <rbuis@igalia.com>

        Support lazy image and iframe loading (loading="lazy")
        https://bugs.webkit.org/show_bug.cgi?id=196698

        Reviewed by NOBODY (OOPS!).

        * web-platform-tests/loading/lazyload/attribute_off_image.tentative-expected.txt: Added.
        * web-platform-tests/loading/lazyload/attribute_off_image.tentative.html: Added.
        * web-platform-tests/loading/lazyload/change_attribute_to_off_image.tentative-expected.txt: Added.
        * web-platform-tests/loading/lazyload/change_attribute_to_off_image.tentative.html: Added.
        * web-platform-tests/loading/lazyload/resources/image_1.png: Added.
        * web-platform-tests/loading/lazyload/resources/image_2.png: Added.
        * web-platform-tests/loading/lazyload/resources/image_3.png: Added.
        * web-platform-tests/loading/lazyload/resources/image_4.png: Added.
        * web-platform-tests/loading/lazyload/resources/subframe_1.html: Added.
        * web-platform-tests/loading/lazyload/resources/subframe_2.html: Added.
        * web-platform-tests/loading/lazyload/resources/subframe_3.html: Added.
        * web-platform-tests/loading/lazyload/resources/subframe_4.html: Added.
        * web-platform-tests/loading/lazyload/scroll_to_attribute_auto_image.tentative-expected.txt: Added.
        * web-platform-tests/loading/lazyload/scroll_to_attribute_auto_image.tentative.html: Added.
        * web-platform-tests/loading/lazyload/scroll_to_attribute_invalid_image.tentative-expected.txt: Added.
        * web-platform-tests/loading/lazyload/scroll_to_attribute_invalid_image.tentative.html: Added.
        * web-platform-tests/loading/lazyload/scroll_to_attribute_on_image.tentative-expected.txt: Added.
        * web-platform-tests/loading/lazyload/scroll_to_attribute_on_image.tentative.html: Added.
        * web-platform-tests/loading/lazyload/scroll_to_attribute_unset_image.tentative-expected.txt: Added.
        * web-platform-tests/loading/lazyload/scroll_to_attribute_unset_image.tentative.html: Added.
        * web-platform-tests/loading/lazyload/window_load_event_occurs_with_below_viewport_image.tentative-expected.txt: Added.
        * web-platform-tests/loading/lazyload/window_load_event_occurs_with_below_viewport_image.tentative.html: Added.

2019-04-22  Youenn Fablet  <youenn@apple.com>

        Cache API should return Abort error in case of putting an aborted fetch

Line 0 a/LayoutTests/http/tests/lazyload/attribute-expected.txt_sec1
- a/LayoutTests/http/tests/lazyload/attribute-expected.txt +7 lines
	1
	2
	3	PASS Test that document load event is fired
	4	PASS Test that <img> with loading=lazy or auto or no attribute or invalid value are loaded as a placeholder
	5	PASS Test that <img> with loading=eager is fully loaded, and not a placeholder
	6	PASS Test that deferred <img> are fully loaded when lazyload is turned off
	7



<!DOCTYPE html>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="placeholder.js"></script>

<body>
  <div style="height:10000px;"></div>
  <img id="no_attribute_img" src='../loading/resources/base-image1.png'>
  <img id="auto_attribute_img" src='../loading/resources/base-image2.png' loading="auto">
  <img id="invalid_attribute_img" src='../loading/resources/base-image3.png' loading="invalid-value-default">
  <img id="lazy_attribute_img" src='../loading/resources/dup-image1.png' loading="lazy">
  <img id="eager_attribute_img" src='../loading/resources/dup-image2.png' loading="eager">
</body>

<script>
  var no_attribute_img = document.getElementById("no_attribute_img");
  var auto_attribute_img = document.getElementById("auto_attribute_img");
  var invalid_attribute_img = document.getElementById("invalid_attribute_img");
  var lazy_attribute_img = document.getElementById("lazy_attribute_img");
  var eager_attribute_img = document.getElementById("eager_attribute_img");

  async_test(function(t) {
    window.addEventListener("load", t.step_func_done());
  }, "Test that document load event is fired");

  async_test(function(t) {
    window.addEventListener("load", t.step_func_done(function() {
      assert_false(is_image_fully_loaded(lazy_attribute_img));
      assert_false(is_image_fully_loaded(no_attribute_img));
    }));
    lazy_attribute_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with loading=lazy"));
    auto_attribute_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with loading=auto"));
    no_attribute_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with no loading attribute"));
    invalid_attribute_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with invalid loading attribute"));
  }, "Test that <img> with loading=lazy or auto or no attribute or invalid value are loaded as a placeholder");

  async_test(function(t) {
    eager_attribute_img.addEventListener("load",
      t.step_func_done(function() {
        assert_true(is_image_fully_loaded(eager_attribute_img));
      }));
  }, "Test that <img> with loading=eager is fully loaded, and not a placeholder");

  async_test(function(t) {
    var complete = 0;
    var onload_callback = function() {
      if (++complete == 4) {
        // The four images with loading=lazy,auto or default or invalid attribute are loaded.
        assert_true(is_image_fully_loaded(no_attribute_img));
        assert_true(is_image_fully_loaded(lazy_attribute_img));
        assert_true(is_image_fully_loaded(auto_attribute_img));
        assert_true(is_image_fully_loaded(invalid_attribute_img));
        t.done();
      }
      assert_equals("eager", this.getAttribute('loading'));
    };
    no_attribute_img.addEventListener("load", onload_callback);
    lazy_attribute_img.addEventListener("load", onload_callback);
    auto_attribute_img.addEventListener("load", onload_callback);
    invalid_attribute_img.addEventListener("load", onload_callback);
    window.addEventListener("load", t.step_func(function() {
      assert_equals(null, no_attribute_img.getAttribute('loading'));
      assert_equals("lazy", lazy_attribute_img.getAttribute('loading'));
      assert_equals("auto", auto_attribute_img.getAttribute('loading'));
      assert_equals("invalid-value-default", invalid_attribute_img.getAttribute('loading'));
      no_attribute_img.setAttribute('loading', 'eager');
      lazy_attribute_img.setAttribute('loading', 'eager');
      auto_attribute_img.setAttribute('loading', 'eager');
      invalid_attribute_img.setAttribute('loading', 'eager');
    }));
  }, "Test that deferred <img> are fully loaded when lazyload is turned off");
</script>

Line 0 a/LayoutTests/http/tests/lazyload/fixed-dimension-expected.txt_sec1
- a/LayoutTests/http/tests/lazyload/fixed-dimension-expected.txt +6 lines
	1
	2
	3	PASS Test that document load event is fired
	4	PASS Test that small <img> with fixed height and width is loaded, and not a placeholder
	5	PASS Test that <img> with non fixed height and width below the viewport is loaded as placeholder
	6



<!DOCTYPE html>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="placeholder.js"></script>

<body>
  <div style="height:10000px;"></div>
  <img id="fixed_dimension_img" src='../loading/resources/base-image1.png' width="10" height="10">
  <img id="large_dimension_img" src='../loading/resources/base-image2.png' width="100" height="100">
  <img id="percent_dimension_img" src='../loading/resources/base-image3.png' width="10%" height="10%">
  <img id="fixed_width_only_img" src='../loading/resources/dup-image1.png' width="10">
  <img id="fixed_height_only_img" src='../loading/resources/dup-image2.png' height="10">
</body>

<script>
  async_test(function(t) {
    window.addEventListener("load", t.step_func_done());
  }, "Test that document load event is fired");

  async_test(function(t) {
    var fixed_dimension_img = document.getElementById("fixed_dimension_img");
    fixed_dimension_img.addEventListener("load",
      t.step_func_done(function() {
        assert_true(is_image_fully_loaded(fixed_dimension_img));
      }));
  }, "Test that small <img> with fixed height and width is loaded, and not a placeholder");

  async_test(function(t) {
    var large_dimension_img = document.getElementById("large_dimension_img");
    var percent_dimension_img = document.getElementById("percent_dimension_img");
    var fixed_width_only_img = document.getElementById("fixed_width_only_img");
    var fixed_height_only_img = document.getElementById("fixed_height_only_img");
    window.addEventListener("load", t.step_func_done(function() {
      assert_false(is_image_fully_loaded(large_dimension_img));
      assert_false(is_image_fully_loaded(percent_dimension_img));
      assert_false(is_image_fully_loaded(fixed_width_only_img));
      assert_false(is_image_fully_loaded(fixed_height_only_img));
    }));
    large_dimension_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with large fixed dimension"));
    percent_dimension_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with percentage dimension"));
    fixed_width_only_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with only fixed width"));
    fixed_height_only_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with only fixed height"));
  }, "Test that <img> with non fixed height and width below the viewport is loaded as placeholder");
</script>

Line 0 a/LayoutTests/http/tests/lazyload/js-image-expected.txt_sec1
- a/LayoutTests/http/tests/lazyload/js-image-expected.txt +5 lines
	1
	2
	3	PASS Test that load event is fired for JS Image() fetches
	4	PASS Test that load event is fired for <img> created via JS and attached below viewport
	5



<!DOCTYPE html>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="placeholder.js"></script>

<body>
  <div style="height:10000px;"></div>
</body>

<script>
  async_test(function(t) {
    const img = new Image();
    img.onload = t.step_func_done(function() {
      assert_true(is_image_fully_loaded(img));
    });
    img.src = '../loading/resources/base-image1.png';
  }, "Test that load event is fired for JS Image() fetches");

  async_test(function(t) {
    const attached_img = document.createElement("IMG");
    document.body.appendChild(attached_img);
    attached_img.onload = t.step_func_done(function() {
      assert_true(is_image_fully_loaded(attached_img));
    });
    attached_img.src = "../loading/resources/base-image2.png";
  }, "Test that load event is fired for <img> created via JS and attached below viewport");
</script>

Line 0 a/LayoutTests/http/tests/lazyload/lazy-expected.txt_sec1
- a/LayoutTests/http/tests/lazyload/lazy-expected.txt +7 lines
	1
	2
	3
	4	PASS Test that document load event is fired
	5	PASS Test that <img> in viewport is loaded, and not a placeholder
	6	PASS Test that <img> below viewport is a placeholder, with lazyimage enabled
	7



<!DOCTYPE html>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="placeholder.js"></script>

<body>
  <img id="in_viewport" src='../loading/resources/base-image1.png'>
  <div style="height:10000px;"></div>
  <img id="below_viewport" src='../loading/resources/base-image2.png'>
</body>

<script>
  var in_viewport_element = document.getElementById("in_viewport");
  var below_viewport_element = document.getElementById("below_viewport");
  async_test(function(t) {
    window.addEventListener("load", t.step_func_done());
  }, "Test that document load event is fired");

  async_test(function(t) {
    in_viewport_element.addEventListener("load",
      t.step_func_done(function() {
        assert_true(is_image_fully_loaded(in_viewport_element));
      }));
  }, "Test that <img> in viewport is loaded, and not a placeholder");

  async_test(function(t) {
    var complete = 0;
    var onload_callback = function() {
      if (++complete == 2) {
        // Document and the above viewport image has loaded.
        assert_false(is_image_fully_loaded(below_viewport_element));
        t.done();
      }
    };
    window.addEventListener("load", t.step_func(onload_callback));
    in_viewport_element.addEventListener("load",
      t.step_func(onload_callback));
    below_viewport_element.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image"));
  }, "Test that <img> below viewport is a placeholder, with lazyimage enabled");
</script>



// Returns if the image is complete and fully loaded as a non-placeholder image.
function is_image_fully_loaded(image) {
  if (!image.complete) {
    return false;
  }

  let canvas = document.createElement('canvas');
  canvas.width = canvas.height = 1;
  let canvasContext = canvas.getContext("2d");
  canvasContext.drawImage(image, 0, 0);
  let data = canvasContext.getImageData(0, 0, canvas.width, canvas.height).data;

  // Fully loaded image should not be a placeholder which is drawn as a
  // translucent gray rectangle in placeholder_image.cc
  return data[0] != 0xd9 || data[1] != 0xd9 || data[2] != 0xd9;
}

Line 0 a/LayoutTests/http/tests/lazyload/scroll-expected.txt_sec1
- a/LayoutTests/http/tests/lazyload/scroll-expected.txt +7 lines
	1
	2
	3
	4	PASS Test that document load event is fired
	5	PASS Test that <img> in viewport is loaded, and not a placeholder
	6	PASS Test that <img> below viewport is loaded when scrolled near, and not a placeholder
	7



<!DOCTYPE html>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="placeholder.js"></script>

<body>
  <img id="in_viewport" src='../loading/resources/base-image1.png'>
  <div style="height:10000px;"></div>
  <img id="below_viewport" src='../loading/resources/base-image2.png'>
</body>

<script>
  var in_viewport_element = document.getElementById("in_viewport");
  var below_viewport_element = document.getElementById("below_viewport");
  async_test(function(t) {
    window.addEventListener("load", t.step_func_done());
  }, "Test that document load event is fired");

  async_test(function(t) {
    in_viewport_element.addEventListener("load",
      t.step_func_done(function() {
        assert_true(is_image_fully_loaded(in_viewport_element));
      }));
  }, "Test that <img> in viewport is loaded, and not a placeholder");

  async_test(function(t) {
    in_viewport_element.addEventListener("load", t.step_func(function() {
      below_viewport_element.scrollIntoView();
    }));
    below_viewport_element.addEventListener("load",
      t.step_func_done(function() {
        assert_true(is_image_fully_loaded(below_viewport_element));
      }));
  }, "Test that <img> below viewport is loaded when scrolled near, and not a placeholder");
</script>

Line 0 a/LayoutTests/http/tests/lazyload/style-dimension-expected.txt_sec1
- a/LayoutTests/http/tests/lazyload/style-dimension-expected.txt +6 lines
	1
	2
	3	PASS Test that document load event is fired
	4	PASS Test that small <img> with width and height mentioned in inline dimensions is not deferred by lazyload
	5	PASS Test that <img> with non small height or width below the viewport is loaded as placeholder
	6



<!DOCTYPE html>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="placeholder.js"></script>

<body>
  <div style="height:10000px;"></div>
  <img id="small_dimension_img" style="height:1px; width:10px" src='../loading/resources/base-image1.png'>
  <img id="large_dimension_img" src='../loading/resources/base-image2.png' style="height:20px; width:20px">
  <img id="height_only_img" src='../loading/resources/base-image3.png' style="height:1px;">
  <img id="width_only_img" src='../loading/resources/dup-image1.png' style="width:1px;">
  <img id="percent_dimension_img" src='../loading/resources/dup-image2.png' style="height:10%; width:10%">
</body>

<script>
  async_test(function(t) {
    window.addEventListener("load", t.step_func_done());
  }, "Test that document load event is fired");

  async_test(function(t) {
    var small_dimension_img = document.getElementById("small_dimension_img");
    small_dimension_img.addEventListener("load",
      t.step_func_done(function() {
        assert_true(is_image_fully_loaded(small_dimension_img));
      }));
  }, "Test that small <img> with width and height mentioned in inline dimensions is not deferred by lazyload ");

  async_test(function(t) {
    var large_dimension_img = document.getElementById("large_dimension_img");
    var height_only_img = document.getElementById("height_only_img");
    var width_only_img = document.getElementById("width_only_img");
    var percent_dimension_img = document.getElementById("percent_dimension_img");
    window.addEventListener("load", t.step_func_done(function() {
      assert_false(is_image_fully_loaded(large_dimension_img));
      assert_false(is_image_fully_loaded(height_only_img));
      assert_false(is_image_fully_loaded(width_only_img));
      assert_false(is_image_fully_loaded(percent_dimension_img));
    }));
    large_dimension_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with large inline dimension"));
    height_only_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with only inline height"));
    width_only_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with only inline width"));
    percent_dimension_img.addEventListener("load",
      t.unreached_func("Load event should not be fired for below viewport image with percentage inline dimension"));
  }, "Test that <img> with non small height or width below the viewport is loaded as placeholder");
</script>



main frame - didStartProvisionalLoadForFrame
main frame - didCommitLoadForFrame
main frame - didReceiveTitle: Loading images with loading="eager"
main frame - didFinishDocumentLoadForFrame
main frame - didHandleOnloadEventsForFrame
main frame - didFinishLoadForFrame



PASS Test that both images load immediately and block the window's load event. 




<!DOCTYPE html>
<head>
  <title>Loading images with loading="eager"</title>
  <link rel="author" title="Scott Little" href="mailto:sclittle@chromium.org">
  <link rel="help" href="https://github.com/whatwg/html/pull/3752">
  <script src="/resources/testharness.js"></script>
  <script src="/resources/testharnessreport.js"></script>
</head>

<!--
Marked as tentative until https://github.com/whatwg/html/pull/3752 is landed.
-->

<body>
  <img id="in_viewport" src="resources/image_1.png" loading="eager">
  <div style="height:10000px;"></div>
  <img id="below_viewport" src="resources/image_2.png" loading="eager">
</body>

<script>
  var t = async_test("Test that both images load immediately and block the window's load event.");

  var has_in_viewport_image_loaded = false;
  document.getElementById("in_viewport").addEventListener("load",
    t.step_func(function() {
      assert_false(has_in_viewport_image_loaded);
      has_in_viewport_image_loaded = true;
    }));

  var has_below_viewport_image_loaded = false;
  document.getElementById("below_viewport").addEventListener("load",
    t.step_func(function() {
      assert_false(has_below_viewport_image_loaded);
      has_below_viewport_image_loaded = true;
    }));

  window.addEventListener("load", t.step_func_done(function() {
    assert_true(has_in_viewport_image_loaded);
    assert_true(has_below_viewport_image_loaded);
  }));
</script>



main frame - didStartProvisionalLoadForFrame
main frame - didCommitLoadForFrame
main frame - didReceiveTitle: Images load immediately when load attribute is changed to "off"
main frame - didFinishDocumentLoadForFrame
main frame - didHandleOnloadEventsForFrame
main frame - didFinishLoadForFrame
     

PASS Test that a below viewport image that has its load attribute changed to off is loaded. 




<!DOCTYPE html>
<head>
  <title>Images load immediately when load attribute is changed to "off"</title>
  <link rel="author" title="Scott Little" href="mailto:sclittle@chromium.org">
  <link rel="help" href="https://github.com/whatwg/html/pull/3752">
  <script src="/resources/testharness.js"></script>
  <script src="/resources/testharnessreport.js"></script>
</head>

<!--
Marked as tentative until https://github.com/whatwg/html/pull/3752 is landed.
-->

<body>
  <div style="height:10000px;"></div>
  <img id="attribute_unset" src="resources/image_1.png">
  <img id="attribute_invalid" src="resources/image_2.png" load="invalid_value">
  <img id="attribute_auto" src="resources/image_3.png" load="auto">
  <img id="attribute_on" src="resources/image_4.png" load="lazy">
</body>

<script>
  var t = async_test("Test that a below viewport image that has its load attribute changed to off is loaded.");

  var has_attribute_unset_loaded = false;
  var has_attribute_invalid_loaded = false;
  var has_attribute_auto_loaded = false;
  var has_attribute_on_loaded = false;

  function checkIfDone() {
    if (has_attribute_unset_loaded &&
        has_attribute_invalid_loaded &&
        has_attribute_auto_loaded &&
        has_attribute_on_loaded) {
      t.done();
    }
  }

  document.getElementById("attribute_unset").addEventListener("load", t.step_func(function() {
    assert_false(has_attribute_unset_loaded);
    has_attribute_unset_loaded = true;
    checkIfDone();
  }));
  document.getElementById("attribute_invalid").addEventListener("load", t.step_func(function() {
    assert_false(has_attribute_invalid_loaded);
    has_attribute_invalid_loaded = true;
    checkIfDone();
  }));
  document.getElementById("attribute_auto").addEventListener("load", t.step_func(function() {
    assert_false(has_attribute_auto_loaded);
    has_attribute_auto_loaded = true;
    checkIfDone();
  }));
  document.getElementById("attribute_on").addEventListener("load", t.step_func(function() {
    assert_false(has_attribute_on_loaded);
    has_attribute_on_loaded = true;
    checkIfDone();
  }));

  window.addEventListener("load", t.step_func_done(function() {
    document.getElementById("attribute_unset").setAttribute("load", "eager");
    document.getElementById("attribute_invalid").setAttribute("load", "eager");
    document.getElementById("attribute_auto").setAttribute("load", "eager");
    document.getElementById("attribute_on").setAttribute("load", "eager");
  }));
</script>

Line 0 a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/resources/subframe_1.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/resources/subframe_1.html +5 lines
	1	<html>
	2	<body>
	3	<p>Subframe 1.</p>
	4	</body>
	5	</html>

Line 0 a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/resources/subframe_2.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/resources/subframe_2.html +5 lines
	1	<html>
	2	<body>
	3	<p>Subframe 2.</p>
	4	</body>
	5	</html>

Line 0 a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/resources/subframe_3.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/resources/subframe_3.html +5 lines
	1	<html>
	2	<body>
	3	<p>Subframe 3.</p>
	4	</body>
	5	</html>

Line 0 a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/resources/subframe_4.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/resources/subframe_4.html +5 lines
	1	<html>
	2	<body>
	3	<p>Subframe 4.</p>
	4	</body>
	5	</html>



main frame - didStartProvisionalLoadForFrame
main frame - didCommitLoadForFrame
main frame - didReceiveTitle: Images with loading="auto" load when in the viewport
main frame - didFinishDocumentLoadForFrame
main frame - didHandleOnloadEventsForFrame
main frame - didFinishLoadForFrame



PASS Test that images with loading='auto' that enter the viewport get loaded. 




<!DOCTYPE html>
<head>
  <title>Images with loading="auto" load when in the viewport</title>
  <link rel="author" title="Scott Little" href="mailto:sclittle@chromium.org">
  <link rel="help" href="https://github.com/whatwg/html/pull/3752">
  <script src="/resources/testharness.js"></script>
  <script src="/resources/testharnessreport.js"></script>
</head>

<!--
Marked as tentative until https://github.com/whatwg/html/pull/3752 is landed.
-->

<body>
  <img id="in_viewport" src="resources/image_1.png" loading="auto">
  <div style="height:10000px;"></div>
  <img id="below_viewport" src="resources/image_2.png" loading="auto">
</body>

<script>
  var t = async_test("Test that images with loading='auto' that enter the viewport get loaded.");

  var has_in_viewport_loaded = false;
  var has_below_viewport_loaded = false;

  document.getElementById("in_viewport").addEventListener("load", t.step_func(function() {
    assert_false(has_in_viewport_loaded);
    has_in_viewport_loaded = true;
    if (has_below_viewport_loaded) {
      // Note that the below_viewport element's load event could happen before
      // the window.load event occurs, if the browser decides to load it
      // immediately instead of lazily loading. This is valid behavior, so the
      // test has passed if the below_viewport element has loaded.
      t.done();
    } else {
      document.getElementById("below_viewport").scrollIntoView();
    }
  }));

  document.getElementById("below_viewport").addEventListener("load", t.step_func(function() {
    assert_false(has_below_viewport_loaded);
    has_below_viewport_loaded = true;
    if (has_in_viewport_loaded) {
      t.done();
    }
  }));
</script>



main frame - didStartProvisionalLoadForFrame
main frame - didCommitLoadForFrame
main frame - didReceiveTitle: Images with an invalid loading attribute load when in the viewport
main frame - didFinishDocumentLoadForFrame
main frame - didHandleOnloadEventsForFrame
main frame - didFinishLoadForFrame



PASS Test that images with invalid loading attributes that enter the viewport get loaded. 




<!DOCTYPE html>
<head>
  <title>Images with an invalid loading attribute load when in the viewport</title>
  <link rel="author" title="Scott Little" href="mailto:sclittle@chromium.org">
  <link rel="help" href="https://github.com/whatwg/html/pull/3752">
  <script src="/resources/testharness.js"></script>
  <script src="/resources/testharnessreport.js"></script>
</head>

<!--
Marked as tentative until https://github.com/whatwg/html/pull/3752 is landed.
-->

<body>
  <img id="in_viewport" src="resources/image_1.png" loading="invalid_value">
  <div style="height:10000px;"></div>
  <img id="below_viewport" src="resources/image_2.png" loading="invalid_value">
</body>

<script>
  var t = async_test("Test that images with invalid loading attributes that enter the viewport get loaded.");

  var has_in_viewport_loaded = false;
  var has_below_viewport_loaded = false;

  document.getElementById("in_viewport").addEventListener("load", t.step_func(function() {
    assert_false(has_in_viewport_loaded);
    has_in_viewport_loaded = true;
    if (has_below_viewport_loaded) {
      // Note that the below_viewport element's load event could happen before
      // the window.load event occurs, if the browser decides to load it
      // immediately instead of lazily loading. This is valid behavior, so the
      // test has passed if the below_viewport element has loaded.
      t.done();
    } else {
      document.getElementById("below_viewport").scrollIntoView();
    }
  }));

  document.getElementById("below_viewport").addEventListener("load", t.step_func(function() {
    assert_false(has_below_viewport_loaded);
    has_below_viewport_loaded = true;
    if (has_in_viewport_loaded) {
      t.done();
    }
  }));
</script>



main frame - didStartProvisionalLoadForFrame
main frame - didCommitLoadForFrame
main frame - didReceiveTitle: Images with loading="lazy" load when in the viewport
main frame - didFinishDocumentLoadForFrame
main frame - didHandleOnloadEventsForFrame
main frame - didFinishLoadForFrame



PASS Test that images with loading='lazy' that enter the viewport get loaded. 




<!DOCTYPE html>
<head>
  <title>Images with loading="lazy" load when in the viewport</title>
  <link rel="author" title="Scott Little" href="mailto:sclittle@chromium.org">
  <link rel="help" href="https://github.com/whatwg/html/pull/3752">
  <script src="/resources/testharness.js"></script>
  <script src="/resources/testharnessreport.js"></script>
</head>

<!--
Marked as tentative until https://github.com/whatwg/html/pull/3752 is landed.
-->

<body>
  <img id="in_viewport" src="resources/image_1.png" loading="lazy">
  <div style="height:10000px;"></div>
  <img id="below_viewport" src="resources/image_2.png" loading="lazy">
</body>

<script>
  var t = async_test("Test that images with loading='lazy' that enter the viewport get loaded.");

  var has_in_viewport_loaded = false;
  var has_below_viewport_loaded = false;

  document.getElementById("in_viewport").addEventListener("load", t.step_func(function() {
    assert_false(has_in_viewport_loaded);
    has_in_viewport_loaded = true;
    if (has_below_viewport_loaded) {
      // Note that the below_viewport element's load event could happen before
      // the window.load event occurs, if the browser decides to load it
      // immediately instead of lazily loading. This is valid behavior, so the
      // test has passed if the below_viewport element has loaded.
      t.done();
    } else {
      document.getElementById("below_viewport").scrollIntoView();
    }
  }));

  document.getElementById("below_viewport").addEventListener("load", t.step_func(function() {
    assert_false(has_below_viewport_loaded);
    has_below_viewport_loaded = true;
    if (has_in_viewport_loaded) {
      t.done();
    }
  }));
</script>



main frame - didStartProvisionalLoadForFrame
main frame - didCommitLoadForFrame
main frame - didReceiveTitle: Images without a lazyload attribute load when in the viewport
main frame - didFinishDocumentLoadForFrame
main frame - didHandleOnloadEventsForFrame
main frame - didFinishLoadForFrame



PASS Test that images without a lazyload attribute that enter the viewport get loaded. 




<!DOCTYPE html>
<head>
  <title>Images without a lazyload attribute load when in the viewport</title>
  <link rel="author" title="Scott Little" href="mailto:sclittle@chromium.org">
  <link rel="help" href="https://github.com/whatwg/html/pull/3752">
  <script src="/resources/testharness.js"></script>
  <script src="/resources/testharnessreport.js"></script>
</head>

<!--
Marked as tentative until https://github.com/whatwg/html/pull/3752 is landed.
-->

<body>
  <img id="in_viewport" src="resources/image_1.png">
  <div style="height:10000px;"></div>
  <img id="below_viewport" src="resources/image_2.png">
</body>

<script>
  var t = async_test("Test that images without a lazyload attribute that enter the viewport get loaded.");

  var has_in_viewport_loaded = false;
  var has_below_viewport_loaded = false;

  document.getElementById("in_viewport").addEventListener("load", t.step_func(function() {
    assert_false(has_in_viewport_loaded);
    has_in_viewport_loaded = true;
    if (has_below_viewport_loaded) {
      // Note that the below_viewport element's load event could happen before
      // the window.load event occurs, if the browser decides to load it
      // immediately instead of lazily loading. This is valid behavior, so the
      // test has passed if the below_viewport element has loaded.
      t.done();
    } else {
      document.getElementById("below_viewport").scrollIntoView();
    }
  }));

  document.getElementById("below_viewport").addEventListener("load", t.step_func(function() {
    assert_false(has_below_viewport_loaded);
    has_below_viewport_loaded = true;
    if (has_in_viewport_loaded) {
      t.done();
    }
  }));
</script>



main frame - didStartProvisionalLoadForFrame
main frame - didCommitLoadForFrame
main frame - didReceiveTitle: Below-viewport images don't endlessly delay the window load event.
main frame - didFinishDocumentLoadForFrame
main frame - didHandleOnloadEventsForFrame
main frame - didFinishLoadForFrame
     

PASS Test that below-viewport images don't endlessly delay the window load event. 




<!DOCTYPE html>
<head>
  <title>Below-viewport images don't endlessly delay the window load event.</title>
  <link rel="author" title="Scott Little" href="mailto:sclittle@chromium.org">
  <link rel="help" href="https://github.com/whatwg/html/pull/3752">
  <script src="/resources/testharness.js"></script>
  <script src="/resources/testharnessreport.js"></script>
</head>

<!--
Marked as tentative until https://github.com/whatwg/html/pull/3752 is landed.
-->

<body>
  <div style="height:10000px;"></div>
  <img id="attribute_unset" src="resources/image_1.png">
  <img id="attribute_invalid" src="resources/image_2.png" loading="invalid_value">
  <img id="attribute_auto" src="resources/image_3.png" loading="auto">
  <img id="attribute_on" src="resources/image_4.png" loading="lazy">
</body>

<script>
  var t = async_test("Test that below-viewport images don't endlessly delay the window load event.");

  // Note that the below-viewport elements' load events could happen before the
  // window.load event occurs, if the browser decides to load immediately
  // instead of lazily loading. This is valid behavior, since loading="lazy" is
  // only a strong hint to the browser that the element is well suited to being
  // lazily loaded, so the browser is not required to lazily load it. The unset,
  // invalid, and "auto" attribute values similarly leave it up to the browser
  // to decide whether or not to lazily load the element. As a result, the test
  // passes once the below-viewport elements load.
  window.addEventListener("load", t.step_func_done());
</script>

Return to Bug 196698

Lines 1665-1667 MediaCaptureRequiresSecureConnection: a/Source/WebKit/Shared/WebPreferences.yaml_sec1
- a/Source/WebKit/Shared/WebPreferences.yaml +8 lines
1665	type: bool	1665	type: bool
1666	defaultValue: true	1666	defaultValue: true
1667	condition: ENABLE(MEDIA_STREAM)	1667	condition: ENABLE(MEDIA_STREAM)
		1668
		1669	LazyImageLoadingEnabled:
		1670	type: bool
		1671	defaultValue: false
		1672	humanReadableName: "Lazy Image Loading"
		1673	humanReadableDescription: "Enable Lazy Image Loading support"
		1674	category: experimental
		1675	webcoreBinding: RuntimeEnabledFeatures

Lines 691-696 public: a/Source/WebKitLegacy/mac/WebView/WebPreferences.mm_sec1
- a/Source/WebKitLegacy/mac/WebView/WebPreferences.mm +11 lines
691	#if ENABLE(RESIZE_OBSERVER)	691	#if ENABLE(RESIZE_OBSERVER)
692	@NO, WebKitResizeObserverEnabledPreferenceKey,	692	@NO, WebKitResizeObserverEnabledPreferenceKey,
693	#endif	693	#endif
		694	@NO, WebKitLazyImageLoadingEnabledPreferenceKey,
694	nil];	695	nil];
695		696
696	#if !PLATFORM(IOS_FAMILY)	697	#if !PLATFORM(IOS_FAMILY)
Lines 3456-3461 static NSString *classIBCreatorID = nil; a/Source/WebKitLegacy/mac/WebView/WebPreferences.mm_sec2
3456	{	3457	{
3457	[self _setBoolValue:flag forKey:WebKitResizeObserverEnabledPreferenceKey];	3458	[self _setBoolValue:flag forKey:WebKitResizeObserverEnabledPreferenceKey];
3458	}	3459	}
		3460
		3461	- (BOOL)lazyImageLoadingEnabled
		3462	{
		3463	return [self _boolValueForKey:WebKitLazyImageLoadingEnabledPreferenceKey];
		3464	}
		3465
		3466	- (void)setLazyImageLoadingEnabled:(BOOL)flag
		3467	{
		3468	[self _setBoolValue:flag forKey:WebKitLazyImageLoadingEnabledPreferenceKey];
		3469	}
3459	@end	3470	@end
3460		3471
3461	@implementation WebPreferences (WebInternal)	3472	@implementation WebPreferences (WebInternal)

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +80 lines
		1	2019-04-23 Rob Buis <rbuis@igalia.com>
		2
		3	Support lazy image and iframe loading (loading="lazy")
		4	https://bugs.webkit.org/show_bug.cgi?id=196698
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Tests: http/tests/lazyload/attribute.html
		9	http/tests/lazyload/fixed-dimension.html
		10	http/tests/lazyload/js-image.html
		11	http/tests/lazyload/lazy.html
		12	http/tests/lazyload/scroll.html
		13	http/tests/lazyload/style-dimension.html
		14	imported/w3c/web-platform-tests/loading/lazyload/attribute_off_image.tentative.html
		15	imported/w3c/web-platform-tests/loading/lazyload/change_attribute_to_off_image.tentative.html
		16	imported/w3c/web-platform-tests/loading/lazyload/scroll_to_attribute_auto_image.tentative.html
		17	imported/w3c/web-platform-tests/loading/lazyload/scroll_to_attribute_invalid_image.tentative.html
		18	imported/w3c/web-platform-tests/loading/lazyload/scroll_to_attribute_on_image.tentative.html
		19	imported/w3c/web-platform-tests/loading/lazyload/scroll_to_attribute_unset_image.tentative.html
		20	imported/w3c/web-platform-tests/loading/lazyload/window_load_event_occurs_with_below_viewport_image.tentative.html
		21
		22	* Sources.txt:
		23	* WebCore.xcodeproj/project.pbxproj:
		24	* css/CSSImageValue.cpp:
		25	(WebCore::CSSImageValue::loadImage):
		26	* css/CSSImageValue.h:
		27	* css/parser/CSSParser.cpp:
		28	(WebCore::CSSParser::parseInlineStyleDeclaration):
		29	* css/parser/CSSParser.h:
		30	* css/parser/CSSParserImpl.cpp:
		31	(WebCore::CSSParserImpl::parseInlineStyleDeclaration):
		32	* css/parser/CSSParserImpl.h:
		33	* dom/Document.cpp:
		34	(WebCore::Document::ensureLazyLoadImageObserver):
		35	* dom/Document.h:
		36	* html/HTMLAttributeNames.in:
		37	* html/HTMLImageElement.cpp:
		38	(WebCore::HTMLImageElement::HTMLImageElement):
		39	(WebCore::HTMLImageElement::create):
		40	(WebCore::HTMLImageElement::createForJSConstructor):
		41	(WebCore::HTMLImageElement::parseAttribute):
		42	(WebCore::HTMLImageElement::loadDeferredImage):
		43	(WebCore::HTMLImageElement::isDimensionSmallAndAbsoluteForLazyLoad):
		44	(WebCore::HTMLImageElement::isInlineStyleDimensionsSmall):
		45	* html/HTMLImageElement.h:
		46	(WebCore::HTMLImageElement::createdByParser const):
		47	* html/HTMLImageElement.idl:
		48	* html/HTMLTagNames.in:
		49	* html/ImageDocument.cpp:
		50	* html/LazyLoadImageObserver.cpp: Added.
		51	(WebCore::LazyLoadImageObserver::startMonitoring):
		52	(WebCore::LazyLoadImageObserver::stopMonitoring):
		53	(WebCore::LazyLoadImageObserver::startMonitoringNearViewport):
		54	* html/LazyLoadImageObserver.h: Copied from Tools/DumpRenderTree/TestOptions.h.
		55	* html/parser/HTMLPreloadScanner.cpp:
		56	(WebCore::TokenPreloadScanner::StartTagScanner::createPreloadRequest):
		57	(WebCore::TokenPreloadScanner::StartTagScanner::processAttribute):
		58	* html/parser/HTMLResourcePreloader.cpp:
		59	(WebCore::PreloadRequest::resourceRequest):
		60	* html/parser/HTMLResourcePreloader.h:
		61	(WebCore::PreloadRequest::setLazyloadImageEnabled):
		62	* loader/ImageLoader.cpp:
		63	(WebCore::isLazyLoadableImage):
		64	(WebCore::ImageLoader::updateFromElement):
65	(WebCore::ImageLoader::notifyFinished):
66	(WebCore::ImageLoader::loadDeferredImage):
67	* loader/ImageLoader.h:
68	* page/RuntimeEnabledFeatures.h:
69	(WebCore::RuntimeEnabledFeatures::setLazyImageLoadingEnabled):
70	(WebCore::RuntimeEnabledFeatures::lazyImageLoadingEnabled const):
71	* page/Settings.yaml:
72	* rendering/style/RenderStyle.cpp:
73	(WebCore::RenderStyle::loadDeferredImages const):
74	* rendering/style/RenderStyle.h:
75	* rendering/style/StyleCachedImage.cpp:
76	(WebCore::StyleCachedImage::addClient):
77	(WebCore::StyleCachedImage::removeClient):
78	(WebCore::StyleCachedImage::loadDeferredImage):
79	* rendering/style/StyleCachedImage.h:
80
1	2019-04-22 Youenn Fablet <youenn@apple.com>	81	2019-04-22 Youenn Fablet <youenn@apple.com>
2		82
3	Update libwebrtc logging when WebCore WebRTC logging is updated	83	Update libwebrtc logging when WebCore WebRTC logging is updated

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +11 lines
		1	2019-04-23 Rob Buis <rbuis@igalia.com>
		2
		3	Support lazy image and iframe loading (loading="lazy")
		4	https://bugs.webkit.org/show_bug.cgi?id=196698
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Add runtime flag.
		9
		10	* Shared/WebPreferences.yaml:
		11
1	2019-04-22 Zalan Bujtas <zalan@apple.com>	12	2019-04-22 Zalan Bujtas <zalan@apple.com>
2		13
3	[ContentChangeObserver] Some dropdown menus may close without user gesture on americanexpress.com	14	[ContentChangeObserver] Some dropdown menus may close without user gesture on americanexpress.com

Lines 1-3 a/Source/WebKitLegacy/mac/ChangeLog_sec1
- a/Source/WebKitLegacy/mac/ChangeLog +16 lines
		1	2019-04-23 Rob Buis <rbuis@igalia.com>
		2
		3	Support lazy image and iframe loading (loading="lazy")
		4	https://bugs.webkit.org/show_bug.cgi?id=196698
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* WebView/WebPreferenceKeysPrivate.h:
		9	* WebView/WebPreferences.mm:
		10	(+[WebPreferences initialize]):
		11	(-[WebPreferences lazyImageLoadingEnabled]):
		12	(-[WebPreferences setLazyImageLoadingEnabled:]):
		13	* WebView/WebPreferencesPrivate.h:
		14	* WebView/WebView.mm:
		15	(-[WebView _preferencesChanged:]):
		16
1	2019-04-18 Daniel Bates <dabates@apple.com>	17	2019-04-18 Daniel Bates <dabates@apple.com>
2		18
3	Use existing KeyEventCodesIOS constants instead of duplicating them	19	Use existing KeyEventCodesIOS constants instead of duplicating them

Lines 1-3 a/Source/WebKitLegacy/win/ChangeLog_sec1
- a/Source/WebKitLegacy/win/ChangeLog +17 lines
		1	2019-04-23 Rob Buis <rbuis@igalia.com>
		2
		3	Support lazy image and iframe loading (loading="lazy")
		4	https://bugs.webkit.org/show_bug.cgi?id=196698
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* Interfaces/IWebPreferencesPrivate.idl:
		9	* WebPreferenceKeysPrivate.h:
		10	* WebPreferences.cpp:
		11	(WebPreferences::initializeDefaultSettings):
		12	(WebPreferences::lazyImageLoadingEnabled):
		13	(WebPreferences::setLazyImageLoadingEnabled):
		14	* WebPreferences.h:
		15	* WebView.cpp:
		16	(WebView::notifyPreferencesChanged):
		17
1	2019-04-20 Don Olmstead <don.olmstead@sony.com>	18	2019-04-20 Don Olmstead <don.olmstead@sony.com>
2		19
3	[CMake][Win] Use target oriented design for WebKitLegacy	20	[CMake][Win] Use target oriented design for WebKitLegacy

Lines 3363-3368 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj +6 lines
3363	AA7FEEAD16A4E74B004C0C33 /* JSSpeechSynthesis.h in Headers / = {isa = PBXBuildFile; fileRef = AA7FEEAC16A4E74B004C0C33 / JSSpeechSynthesis.h */; };	3363	AA7FEEAD16A4E74B004C0C33 /* JSSpeechSynthesis.h in Headers / = {isa = PBXBuildFile; fileRef = AA7FEEAC16A4E74B004C0C33 / JSSpeechSynthesis.h */; };
3364	AAA728F716D1D8BC00D3BBC6 /* WebAccessibilityObjectWrapperIOS.h in Headers / = {isa = PBXBuildFile; fileRef = AAA728F116D1D8BC00D3BBC6 / WebAccessibilityObjectWrapperIOS.h */; };	3364	AAA728F716D1D8BC00D3BBC6 /* WebAccessibilityObjectWrapperIOS.h in Headers / = {isa = PBXBuildFile; fileRef = AAA728F116D1D8BC00D3BBC6 / WebAccessibilityObjectWrapperIOS.h */; };
3365	AAC08CF315F941FD00F1E188 /* AccessibilitySVGRoot.h in Headers / = {isa = PBXBuildFile; fileRef = AAC08CF115F941FC00F1E188 / AccessibilitySVGRoot.h */; };	3365	AAC08CF315F941FD00F1E188 /* AccessibilitySVGRoot.h in Headers / = {isa = PBXBuildFile; fileRef = AAC08CF115F941FC00F1E188 / AccessibilitySVGRoot.h */; };
		3366	AAD9D0B521DFA810001B11C7 /* LazyLoadImageObserver.h in Headers / = {isa = PBXBuildFile; fileRef = AAD9D0B321DFA80E001B11C7 / LazyLoadImageObserver.h */; settings = {ATTRIBUTES = (Private, ); }; };
3366	AB23A32809BBA7D00067CC53 /* BeforeTextInsertedEvent.h in Headers / = {isa = PBXBuildFile; fileRef = AB23A32609BBA7D00067CC53 / BeforeTextInsertedEvent.h */; };	3367	AB23A32809BBA7D00067CC53 /* BeforeTextInsertedEvent.h in Headers / = {isa = PBXBuildFile; fileRef = AB23A32609BBA7D00067CC53 / BeforeTextInsertedEvent.h */; };
3367	AB247A6D0AFD6383003FA5FD /* RenderSlider.h in Headers / = {isa = PBXBuildFile; fileRef = AB247A6B0AFD6383003FA5FD / RenderSlider.h */; };	3368	AB247A6D0AFD6383003FA5FD /* RenderSlider.h in Headers / = {isa = PBXBuildFile; fileRef = AB247A6B0AFD6383003FA5FD / RenderSlider.h */; };
3368	AB31C91E10AE1B8E000C7B92 /* LineClampValue.h in Headers / = {isa = PBXBuildFile; fileRef = AB31C91D10AE1B8E000C7B92 / LineClampValue.h */; settings = {ATTRIBUTES = (Private, ); }; };	3369	AB31C91E10AE1B8E000C7B92 /* LineClampValue.h in Headers / = {isa = PBXBuildFile; fileRef = AB31C91D10AE1B8E000C7B92 / LineClampValue.h */; settings = {ATTRIBUTES = (Private, ); }; };
Lines 11942-11947 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
11942	AAA728F316D1D8BC00D3BBC6 /* AXObjectCacheIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = AXObjectCacheIOS.mm; sourceTree = "<group>"; };	11943	AAA728F316D1D8BC00D3BBC6 /* AXObjectCacheIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = AXObjectCacheIOS.mm; sourceTree = "<group>"; };
11943	AAC08CF015F941FC00F1E188 /* AccessibilitySVGRoot.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AccessibilitySVGRoot.cpp; sourceTree = "<group>"; };	11944	AAC08CF015F941FC00F1E188 /* AccessibilitySVGRoot.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AccessibilitySVGRoot.cpp; sourceTree = "<group>"; };
11944	AAC08CF115F941FC00F1E188 /* AccessibilitySVGRoot.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AccessibilitySVGRoot.h; sourceTree = "<group>"; };	11945	AAC08CF115F941FC00F1E188 /* AccessibilitySVGRoot.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AccessibilitySVGRoot.h; sourceTree = "<group>"; };
		11946	AAD9D0B121DFA80C001B11C7 /* LazyLoadImageObserver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LazyLoadImageObserver.cpp; sourceTree = "<group>"; };
		11947	AAD9D0B321DFA80E001B11C7 /* LazyLoadImageObserver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LazyLoadImageObserver.h; sourceTree = "<group>"; };
11945	AAE27B7416CBFC0D00623043 /* PlatformSpeechSynthesizerMock.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PlatformSpeechSynthesizerMock.cpp; sourceTree = "<group>"; };	11948	AAE27B7416CBFC0D00623043 /* PlatformSpeechSynthesizerMock.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PlatformSpeechSynthesizerMock.cpp; sourceTree = "<group>"; };
11946	AAE27B7516CBFC0D00623043 /* PlatformSpeechSynthesizerMock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformSpeechSynthesizerMock.h; sourceTree = "<group>"; };	11949	AAE27B7516CBFC0D00623043 /* PlatformSpeechSynthesizerMock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformSpeechSynthesizerMock.h; sourceTree = "<group>"; };
11947	AAE3755D17429BCC006200C2 /* PlatformSpeechSynthesizerIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = PlatformSpeechSynthesizerIOS.mm; sourceTree = "<group>"; };	11950	AAE3755D17429BCC006200C2 /* PlatformSpeechSynthesizerIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = PlatformSpeechSynthesizerIOS.mm; sourceTree = "<group>"; };
Lines 21504-21509 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
21504	450CEBEF15073BBE002BB149 /* LabelableElement.h */,	21507	450CEBEF15073BBE002BB149 /* LabelableElement.h */,
21505	A456FA2411AD4A830020B420 /* LabelsNodeList.cpp */,	21508	A456FA2411AD4A830020B420 /* LabelsNodeList.cpp */,
21506	A456FA2511AD4A830020B420 /* LabelsNodeList.h */,	21509	A456FA2511AD4A830020B420 /* LabelsNodeList.h */,
		21510	AAD9D0B121DFA80C001B11C7 /* LazyLoadImageObserver.cpp */,
		21511	AAD9D0B321DFA80E001B11C7 /* LazyLoadImageObserver.h */,
21507	1A4DA41F1CDD3A8300F4473C /* LinkIconCollector.cpp */,	21512	1A4DA41F1CDD3A8300F4473C /* LinkIconCollector.cpp */,
21508	1A4DA4201CDD3A8300F4473C /* LinkIconCollector.h */,	21513	1A4DA4201CDD3A8300F4473C /* LinkIconCollector.h */,
21509	1A250E0C1CDD632000D0BE63 /* LinkIconType.h */,	21514	1A250E0C1CDD632000D0BE63 /* LinkIconType.h */,
Lines 30376-30381 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
30376	6F7CA3C6208C2957002F29AB /* LayoutState.h in Headers */,	30381	6F7CA3C6208C2957002F29AB /* LayoutState.h in Headers */,
30377	11310CF220BA4A320065A8D0 /* LayoutTreeBuilder.h in Headers */,	30382	11310CF220BA4A320065A8D0 /* LayoutTreeBuilder.h in Headers */,
30378	141DC0481648348F00371E5A /* LayoutUnit.h in Headers */,	30383	141DC0481648348F00371E5A /* LayoutUnit.h in Headers */,
		30384	AAD9D0B521DFA810001B11C7 /* LazyLoadImageObserver.h in Headers */,
30379	CDE8B5ED1A69777300B4B66A /* LegacyCDMPrivateClearKey.h in Headers */,	30385	CDE8B5ED1A69777300B4B66A /* LegacyCDMPrivateClearKey.h in Headers */,
30380	CDF4B7121E0087AE00E235A2 /* LegacyCDMSession.h in Headers */,	30386	CDF4B7121E0087AE00E235A2 /* LegacyCDMSession.h in Headers */,
30381	CDE8B5F11A69778B00B4B66A /* LegacyCDMSessionClearKey.h in Headers */,	30387	CDE8B5F11A69778B00B4B66A /* LegacyCDMSessionClearKey.h in Headers */,

Lines 58-71 bool CSSImageValue::isPending() const a/Source/WebCore/css/CSSImageValue.cpp_sec1
- a/Source/WebCore/css/CSSImageValue.cpp -3 / +8 lines
58	return !m_accessedImage;	58	return !m_accessedImage;
59	}	59	}
60		60
61	CachedImage* CSSImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)	61	CachedImage* CSSImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options, bool defer)
62	{	62	{
63	if (!m_accessedImage) {	63	if (!m_accessedImage \|\| !defer) {
64	m_accessedImage = true;	64	m_accessedImage = true;
65		65
66	ResourceLoaderOptions loadOptions = options;	66	ResourceLoaderOptions loadOptions = options;
67	loadOptions.loadedFromOpaqueSource = m_loadedFromOpaqueSource;	67	loadOptions.loadedFromOpaqueSource = m_loadedFromOpaqueSource;
68	CachedResourceRequest request(ResourceRequest(loader.document()->completeURL(m_url.string())), loadOptions);	68	ResourceRequest resourceRequest(loader.document()->completeURL(m_url.string()));
		69	if (defer) {
		70	resourceRequest.setHTTPHeaderField(HTTPHeaderName::Range, "bytes=0-2047");
		71	loadOptions.cache = FetchOptions::Cache::NoStore;
		72	}
		73	CachedResourceRequest request(WTFMove(resourceRequest), loadOptions);
69	if (m_initiatorName.isEmpty())	74	if (m_initiatorName.isEmpty())
70	request.setInitiator(cachedResourceRequestInitiators().css);	75	request.setInitiator(cachedResourceRequestInitiators().css);
71	else	76	else

Lines 55-60 a/Source/WebCore/html/HTMLImageElement.cpp_sec1
- a/Source/WebCore/html/HTMLImageElement.cpp -7 / +40 lines
55	#include "Settings.h"	55	#include "Settings.h"
56	#include "ShadowRoot.h"	56	#include "ShadowRoot.h"
57	#include "SizesAttributeParser.h"	57	#include "SizesAttributeParser.h"
		58	#include "StyleProperties.h"
58	#include <wtf/IsoMallocInlines.h>	59	#include <wtf/IsoMallocInlines.h>
59	#include <wtf/text/StringBuilder.h>	60	#include <wtf/text/StringBuilder.h>
60		61
Lines 68-74 WTF_MAKE_ISO_ALLOCATED_IMPL(HTMLImageElement); a/Source/WebCore/html/HTMLImageElement.cpp_sec2
68		69
69	using namespace HTMLNames;	70	using namespace HTMLNames;
70		71
71	HTMLImageElement::HTMLImageElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form)	72	HTMLImageElement::HTMLImageElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form, bool createdByParser)
72	: HTMLElement(tagName, document)	73	: HTMLElement(tagName, document)
73	, m_imageLoader(*this)	74	, m_imageLoader(*this)
74	, m_form(nullptr)	75	, m_form(nullptr)
Lines 76-81 HTMLImageElement::HTMLImageElement(const QualifiedName& tagName, Document& docum a/Source/WebCore/html/HTMLImageElement.cpp_sec3
76	, m_compositeOperator(CompositeSourceOver)	77	, m_compositeOperator(CompositeSourceOver)
77	, m_imageDevicePixelRatio(1.0f)	78	, m_imageDevicePixelRatio(1.0f)
78	, m_experimentalImageMenuEnabled(false)	79	, m_experimentalImageMenuEnabled(false)
		80	, m_createdByParser(createdByParser)
79	{	81	{
80	ASSERT(hasTagName(imgTag));	82	ASSERT(hasTagName(imgTag));
81	setHasCustomStyleResolveCallbacks();	83	setHasCustomStyleResolveCallbacks();
Lines 83-94 HTMLImageElement::HTMLImageElement(const QualifiedName& tagName, Document& docum a/Source/WebCore/html/HTMLImageElement.cpp_sec4
83		85
84	Ref<HTMLImageElement> HTMLImageElement::create(Document& document)	86	Ref<HTMLImageElement> HTMLImageElement::create(Document& document)
85	{	87	{
86	return adoptRef(*new HTMLImageElement(imgTag, document));	88	return adoptRef(*new HTMLImageElement(imgTag, document, nullptr, false));
87	}	89	}
88		90
89	Ref<HTMLImageElement> HTMLImageElement::create(const QualifiedName& tagName, Document& document, HTMLFormElement* form)	91	Ref<HTMLImageElement> HTMLImageElement::create(const QualifiedName& tagName, Document& document, HTMLFormElement* form, bool createdByParser)
90	{	92	{
91	return adoptRef(*new HTMLImageElement(tagName, document, form));	93	return adoptRef(*new HTMLImageElement(tagName, document, form, createdByParser));
92	}	94	}
93		95
94	HTMLImageElement::~HTMLImageElement()	96	HTMLImageElement::~HTMLImageElement()
Lines 100-106 HTMLImageElement::~HTMLImageElement() a/Source/WebCore/html/HTMLImageElement.cpp_sec5
100		102
101	Ref<HTMLImageElement> HTMLImageElement::createForJSConstructor(Document& document, Optional<unsigned> width, Optional<unsigned> height)	103	Ref<HTMLImageElement> HTMLImageElement::createForJSConstructor(Document& document, Optional<unsigned> width, Optional<unsigned> height)
102	{	104	{
103	auto image = adoptRef(*new HTMLImageElement(imgTag, document));	105	auto image = adoptRef(*new HTMLImageElement(imgTag, document, nullptr, false));
104	if (width)	106	if (width)
105	image->setWidth(width.value());	107	image->setWidth(width.value());
106	if (height)	108	if (height)
Lines 240-248 void HTMLImageElement::parseAttribute(const QualifiedName& name, const AtomicStr a/Source/WebCore/html/HTMLImageElement.cpp_sec6
240	m_experimentalImageMenuEnabled = !value.isNull();	242	m_experimentalImageMenuEnabled = !value.isNull();
241	updateImageControls();	243	updateImageControls();
242	#endif	244	#endif
243	} else if (name == x_apple_editable_imageAttr)	245	} else if (name == x_apple_editable_imageAttr) {
244	updateEditableImage();	246	updateEditableImage();
245	else {	247	} else if (name == loadingAttr && equalLettersIgnoringASCIICase(value, "eager")) {
		248	// !GetDocument().IsLazyLoadPolicyEnforced()) {
		249	loadDeferredImage();
		250	} else {
246	if (name == nameAttr) {	251	if (name == nameAttr) {
247	bool willHaveName = !value.isNull();	252	bool willHaveName = !value.isNull();
248	if (m_hadNameBeforeAttributeChanged != willHaveName && isConnected() && !isInShadowTree() && is<HTMLDocument>(document())) {	253	if (m_hadNameBeforeAttributeChanged != willHaveName && isConnected() && !isInShadowTree() && is<HTMLDocument>(document())) {
Lines 834-837 void HTMLImageElement::defaultEventHandler(Event& event) a/Source/WebCore/html/HTMLImageElement.cpp_sec7
834	HTMLElement::defaultEventHandler(event);	839	HTMLElement::defaultEventHandler(event);
835	}	840	}
836		841
		842	void HTMLImageElement::loadDeferredImage()
		843	{
		844	m_imageLoader.loadDeferredImage();
		845	}
		846
		847	// Minimum height or width of the image to start lazyloading.
		848	constexpr int kMinDimensionToLazyLoad = 10;
		849
		850	bool HTMLImageElement::isDimensionSmallAndAbsoluteForLazyLoad(const AtomicString& attributeValue)
		851	{
		852	auto optionalDimension = parseValidHTMLNonNegativeInteger(attributeValue);
		853	return optionalDimension && optionalDimension.value() <= kMinDimensionToLazyLoad;
		854	}
		855
		856	bool HTMLImageElement::isInlineStyleDimensionsSmall(const StyleProperties* propertySet)
		857	{
		858	if (!propertySet)
		859	return false;
		860	auto height = propertySet->getPropertyCSSValue(CSSPropertyHeight);
		861	auto width = propertySet->getPropertyCSSValue(CSSPropertyWidth);
		862	if (!height \|\| !height->isPrimitiveValue() \|\| !width \|\| !width->isPrimitiveValue())
		863	return false;
		864	const auto& widthPrim = downcast<CSSPrimitiveValue>(*width);
		865	const auto& heightPrim = downcast<CSSPrimitiveValue>(*height);
		866	return heightPrim.isPx() && (heightPrim.doubleValue() <= kMinDimensionToLazyLoad)
		867	&& widthPrim.isPx() && (widthPrim.doubleValue() <= kMinDimensionToLazyLoad);
		868	}
		869
837	}	870	}

Line 0 a/Source/WebCore/html/LazyLoadImageObserver.cpp_sec1
- a/Source/WebCore/html/LazyLoadImageObserver.cpp +109 lines
		1	/*
		2	* Copyright (C) 2019 Igalia S.L.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		23	* THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "LazyLoadImageObserver.h"
		28
		29	#include "Frame.h"
		30	#include "HTMLImageElement.h"
		31	#include "IntersectionObserverCallback.h"
		32	#include "RenderStyle.h"
		33
		34	#include <limits>
		35
		36	namespace WebCore {
		37
		38	class IntersectionObserverCallbackImpl final : public IntersectionObserverCallback {
		39	public:
		40	static Ref<IntersectionObserverCallbackImpl> create(Document* document)
		41	{
		42	return adoptRef(*new IntersectionObserverCallbackImpl(document));
		43	}
		44	IntersectionObserverCallbackImpl(Document* document)
		45	: IntersectionObserverCallback(document), m_document(document)
		46	{
		47	}
		48	CallbackResult<void> handleEvent(const Vector<Ref<IntersectionObserverEntry>>& entries, IntersectionObserver&)
		49	{
		50	ASSERT(!entries.isEmpty());
		51
		52	for (auto& entry : entries) {
		53	if (!entry->isIntersecting())
		54	continue;
		55	Element* element = entry->target();
		56	if (is<HTMLImageElement>(element))
		57	downcast<HTMLImageElement>(*element).loadDeferredImage();
		58
		59	// Load the background image if the element has one deferred.
		60	if (const auto* style = element->computedStyle())
		61	style->loadDeferredImages(*m_document);
		62
		63	m_document->ensureLazyLoadImageObserver().stopMonitoring(*element);
		64	}
65	return { };
66	}
67	private:
68	Document* m_document;
69	};
70
71	namespace {
72
73	Document* getRootDocumentOrNull(const Element& element)
74	{
75	if (Frame* frame = element.document().frame())
76	return frame->tree().top().document();
77	return nullptr;
78	}
79
80	} // namespace
81
82	void LazyLoadImageObserver::startMonitoring(Element& element)
83	{
84	if (Document* document = getRootDocumentOrNull(element))
85	document->ensureLazyLoadImageObserver().startMonitoringNearViewport(document, element);
86	}
87
88	void LazyLoadImageObserver::stopMonitoring(Element& element)
89	{
90	if (Document* document = getRootDocumentOrNull(element))
91	document->ensureLazyLoadImageObserver().m_lazyLoadIntersectionObserver->unobserve(element);
92	}
93
94	LazyLoadImageObserver::LazyLoadImageObserver() = default;
95
96	void LazyLoadImageObserver::startMonitoringNearViewport(Document* rootDocument, Element& element)
97	{
98	if (!m_lazyLoadIntersectionObserver) {
99	auto callback = IntersectionObserverCallbackImpl::create(rootDocument);
100	auto options = IntersectionObserver::Init { nullptr, "", { } };
101	auto observer = IntersectionObserver::create(*rootDocument, WTFMove(callback), WTFMove(options));
102	if (observer.hasException())
103	return;
104	m_lazyLoadIntersectionObserver = observer.returnValue().ptr();
105	}
106	m_lazyLoadIntersectionObserver->observe(element);
107	}
108
109	}

Lines 54-65 CachedResourceRequest PreloadRequest::resourceRequest(Document& document) a/Source/WebCore/html/parser/HTMLResourcePreloader.cpp_sec1
- a/Source/WebCore/html/parser/HTMLResourcePreloader.cpp -1 / +7 lines
54	if (skipContentSecurityPolicyCheck)	54	if (skipContentSecurityPolicyCheck)
55	options.contentSecurityPolicyImposition = ContentSecurityPolicyImposition::SkipPolicyCheck;	55	options.contentSecurityPolicyImposition = ContentSecurityPolicyImposition::SkipPolicyCheck;
56		56
		57	ResourceRequest resourceRequest(completeURL(document));
		58	if (m_lazyloadImageEnabled) {
		59	resourceRequest.setHTTPHeaderField(HTTPHeaderName::Range, "bytes=0-2047");
		60	options.cache = FetchOptions::Cache::NoStore;
		61	}
		62
57	String crossOriginMode = m_crossOriginMode;	63	String crossOriginMode = m_crossOriginMode;
58	if (m_moduleScript == ModuleScript::Yes) {	64	if (m_moduleScript == ModuleScript::Yes) {
59	if (crossOriginMode.isNull())	65	if (crossOriginMode.isNull())
60	crossOriginMode = "omit"_s;	66	crossOriginMode = "omit"_s;
61	}	67	}
62	auto request = createPotentialAccessControlRequest(completeURL(document), document, crossOriginMode, WTFMove(options));	68	auto request = createPotentialAccessControlRequest(WTFMove(resourceRequest), document, crossOriginMode, WTFMove(options));
63	request.setInitiator(m_initiator);	69	request.setInitiator(m_initiator);
64	return request;	70	return request;
65	}	71	}

Lines 54-59 public: a/Source/WebCore/html/parser/HTMLResourcePreloader.h_sec1
- a/Source/WebCore/html/parser/HTMLResourcePreloader.h +2 lines
54	void setCharset(const String& charset) { m_charset = charset.isolatedCopy(); }	54	void setCharset(const String& charset) { m_charset = charset.isolatedCopy(); }
55	void setCrossOriginMode(const String& mode) { m_crossOriginMode = mode; }	55	void setCrossOriginMode(const String& mode) { m_crossOriginMode = mode; }
56	void setNonce(const String& nonce) { m_nonceAttribute = nonce; }	56	void setNonce(const String& nonce) { m_nonceAttribute = nonce; }
		57	void setLazyloadImageEnabled(bool enabled) { m_lazyloadImageEnabled = enabled; }
57	CachedResource::Type resourceType() const { return m_resourceType; }	58	CachedResource::Type resourceType() const { return m_resourceType; }
58		59
59	private:	60	private:
Lines 68-73 private: a/Source/WebCore/html/parser/HTMLResourcePreloader.h_sec2
68	String m_crossOriginMode;	69	String m_crossOriginMode;
69	String m_nonceAttribute;	70	String m_nonceAttribute;
70	ModuleScript m_moduleScript;	71	ModuleScript m_moduleScript;
		72	bool m_lazyloadImageEnabled { false };
71	};	73	};
72		74
73	typedef Vector<std::unique_ptr<PreloadRequest>> PreloadRequestStream;	75	typedef Vector<std::unique_ptr<PreloadRequest>> PreloadRequestStream;

Lines 28-33 a/Source/WebCore/rendering/style/RenderStyle.cpp_sec1
- a/Source/WebCore/rendering/style/RenderStyle.cpp +12 lines
28	#include "CSSParser.h"	28	#include "CSSParser.h"
29	#include "CSSPropertyNames.h"	29	#include "CSSPropertyNames.h"
30	#include "CSSPropertyParser.h"	30	#include "CSSPropertyParser.h"
		31	#include "CachedImage.h"
31	#include "ContentData.h"	32	#include "ContentData.h"
32	#include "CursorList.h"	33	#include "CursorList.h"
33	#include "FloatRoundedRect.h"	34	#include "FloatRoundedRect.h"
Lines 42-47 a/Source/WebCore/rendering/style/RenderStyle.cpp_sec2
42	#include "ScaleTransformOperation.h"	43	#include "ScaleTransformOperation.h"
43	#include "ShadowData.h"	44	#include "ShadowData.h"
44	#include "StyleBuilderConverter.h"	45	#include "StyleBuilderConverter.h"
		46	#include "StyleCachedImage.h"
45	#include "StyleImage.h"	47	#include "StyleImage.h"
46	#include "StyleInheritedData.h"	48	#include "StyleInheritedData.h"
47	#include "StyleResolver.h"	49	#include "StyleResolver.h"
Lines 2480-2483 Color RenderStyle::computedStrokeColor() const a/Source/WebCore/rendering/style/RenderStyle.cpp_sec3
2480	return visitedDependentColor(propertyID);	2482	return visitedDependentColor(propertyID);
2481	}	2483	}
2482		2484
		2485	void RenderStyle::loadDeferredImages(Document& document) const
		2486	{
		2487	if (hasBackgroundImage()) {
		2488	for (auto* layer = &backgroundLayers(); layer; layer = layer->next()) {
		2489	if (layer->image() && is<StyleCachedImage>(*layer->image()))
		2490	downcast<StyleCachedImage>(*layer->image()).loadDeferredImage(document);
		2491	}
		2492	}
		2493	}
		2494
2483	} // namespace WebCore	2495	} // namespace WebCore

Lines 1-3 a/Tools/ChangeLog_sec1
- a/Tools/ChangeLog +15 lines
		1	2019-04-23 Rob Buis <rbuis@igalia.com>
		2
		3	Support lazy image and iframe loading (loading="lazy")
		4	https://bugs.webkit.org/show_bug.cgi?id=196698
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* DumpRenderTree/TestOptions.cpp:
		9	(TestOptions::TestOptions):
		10	* DumpRenderTree/TestOptions.h:
		11	* DumpRenderTree/mac/DumpRenderTree.mm:
		12	(setWebPreferencesForTestOptions):
		13	* DumpRenderTree/win/DumpRenderTree.cpp:
		14	(enableExperimentalFeatures):
		15
1	2019-04-22 Aakash Jain <aakash_jain@apple.com>	16	2019-04-22 Aakash Jain <aakash_jain@apple.com>
2		17
3	[ews-build] Improve summary for UploadBuiltProduct step	18	[ews-build] Improve summary for UploadBuiltProduct step

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +22 lines
		1	2019-04-23 Rob Buis <rbuis@igalia.com>
		2
		3	Support lazy image and iframe loading (loading="lazy")
		4	https://bugs.webkit.org/show_bug.cgi?id=196698
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* http/tests/lazyload/attribute-expected.txt: Added.
		9	* http/tests/lazyload/attribute.html: Added.
		10	* http/tests/lazyload/fixed-dimension-expected.txt: Added.
		11	* http/tests/lazyload/fixed-dimension.html: Added.
		12	* http/tests/lazyload/js-image-expected.txt: Added.
		13	* http/tests/lazyload/js-image.html: Added.
		14	* http/tests/lazyload/lazy-expected.txt: Added.
		15	* http/tests/lazyload/lazy.html: Added.
		16	* http/tests/lazyload/placeholder.js: Added.
		17	(is_image_fully_loaded):
		18	* http/tests/lazyload/scroll-expected.txt: Added.
		19	* http/tests/lazyload/scroll.html: Added.
		20	* http/tests/lazyload/style-dimension-expected.txt: Added.
		21	* http/tests/lazyload/style-dimension.html: Added.
		22
1	2019-04-22 Zalan Bujtas <zalan@apple.com>	23	2019-04-22 Zalan Bujtas <zalan@apple.com>
2		24
3	[ContentChangeObserver] Some dropdown menus may close without user gesture on americanexpress.com	25	[ContentChangeObserver] Some dropdown menus may close without user gesture on americanexpress.com

Lines 1-3 a/LayoutTests/imported/w3c/ChangeLog_sec1
- a/LayoutTests/imported/w3c/ChangeLog +30 lines
		1	2019-04-23 Rob Buis <rbuis@igalia.com>
		2
		3	Support lazy image and iframe loading (loading="lazy")
		4	https://bugs.webkit.org/show_bug.cgi?id=196698
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* web-platform-tests/loading/lazyload/attribute_off_image.tentative-expected.txt: Added.
		9	* web-platform-tests/loading/lazyload/attribute_off_image.tentative.html: Added.
		10	* web-platform-tests/loading/lazyload/change_attribute_to_off_image.tentative-expected.txt: Added.
		11	* web-platform-tests/loading/lazyload/change_attribute_to_off_image.tentative.html: Added.
		12	* web-platform-tests/loading/lazyload/resources/image_1.png: Added.
		13	* web-platform-tests/loading/lazyload/resources/image_2.png: Added.
		14	* web-platform-tests/loading/lazyload/resources/image_3.png: Added.
		15	* web-platform-tests/loading/lazyload/resources/image_4.png: Added.
		16	* web-platform-tests/loading/lazyload/resources/subframe_1.html: Added.
		17	* web-platform-tests/loading/lazyload/resources/subframe_2.html: Added.
		18	* web-platform-tests/loading/lazyload/resources/subframe_3.html: Added.
		19	* web-platform-tests/loading/lazyload/resources/subframe_4.html: Added.
		20	* web-platform-tests/loading/lazyload/scroll_to_attribute_auto_image.tentative-expected.txt: Added.
		21	* web-platform-tests/loading/lazyload/scroll_to_attribute_auto_image.tentative.html: Added.
		22	* web-platform-tests/loading/lazyload/scroll_to_attribute_invalid_image.tentative-expected.txt: Added.
		23	* web-platform-tests/loading/lazyload/scroll_to_attribute_invalid_image.tentative.html: Added.
		24	* web-platform-tests/loading/lazyload/scroll_to_attribute_on_image.tentative-expected.txt: Added.
		25	* web-platform-tests/loading/lazyload/scroll_to_attribute_on_image.tentative.html: Added.
		26	* web-platform-tests/loading/lazyload/scroll_to_attribute_unset_image.tentative-expected.txt: Added.
		27	* web-platform-tests/loading/lazyload/scroll_to_attribute_unset_image.tentative.html: Added.
		28	* web-platform-tests/loading/lazyload/window_load_event_occurs_with_below_viewport_image.tentative-expected.txt: Added.
		29	* web-platform-tests/loading/lazyload/window_load_event_occurs_with_below_viewport_image.tentative.html: Added.
		30
1	2019-04-22 Youenn Fablet <youenn@apple.com>	31	2019-04-22 Youenn Fablet <youenn@apple.com>
2		32
3	Cache API should return Abort error in case of putting an aborted fetch	33	Cache API should return Abort error in case of putting an aborted fetch

Line 0 a/LayoutTests/http/tests/lazyload/attribute.html_sec1
- a/LayoutTests/http/tests/lazyload/attribute.html +76 lines
		1	<!DOCTYPE html>
		2	<script src="/resources/testharness.js"></script>
		3	<script src="/resources/testharnessreport.js"></script>
		4	<script src="placeholder.js"></script>
		5
		6	<body>
		7	<div style="height:10000px;"></div>
		8	<img id="no_attribute_img" src='../loading/resources/base-image1.png'>
		9	<img id="auto_attribute_img" src='../loading/resources/base-image2.png' loading="auto">
		10	<img id="invalid_attribute_img" src='../loading/resources/base-image3.png' loading="invalid-value-default">
		11	<img id="lazy_attribute_img" src='../loading/resources/dup-image1.png' loading="lazy">
		12	<img id="eager_attribute_img" src='../loading/resources/dup-image2.png' loading="eager">
		13	</body>
		14
		15	<script>
		16	var no_attribute_img = document.getElementById("no_attribute_img");
		17	var auto_attribute_img = document.getElementById("auto_attribute_img");
		18	var invalid_attribute_img = document.getElementById("invalid_attribute_img");
		19	var lazy_attribute_img = document.getElementById("lazy_attribute_img");
		20	var eager_attribute_img = document.getElementById("eager_attribute_img");
		21
		22	async_test(function(t) {
		23	window.addEventListener("load", t.step_func_done());
		24	}, "Test that document load event is fired");
		25
		26	async_test(function(t) {
		27	window.addEventListener("load", t.step_func_done(function() {
		28	assert_false(is_image_fully_loaded(lazy_attribute_img));
		29	assert_false(is_image_fully_loaded(no_attribute_img));
		30	}));
		31	lazy_attribute_img.addEventListener("load",
		32	t.unreached_func("Load event should not be fired for below viewport image with loading=lazy"));
		33	auto_attribute_img.addEventListener("load",
		34	t.unreached_func("Load event should not be fired for below viewport image with loading=auto"));
		35	no_attribute_img.addEventListener("load",
		36	t.unreached_func("Load event should not be fired for below viewport image with no loading attribute"));
		37	invalid_attribute_img.addEventListener("load",
		38	t.unreached_func("Load event should not be fired for below viewport image with invalid loading attribute"));
		39	}, "Test that <img> with loading=lazy or auto or no attribute or invalid value are loaded as a placeholder");
		40
		41	async_test(function(t) {
		42	eager_attribute_img.addEventListener("load",
		43	t.step_func_done(function() {
		44	assert_true(is_image_fully_loaded(eager_attribute_img));
		45	}));
		46	}, "Test that <img> with loading=eager is fully loaded, and not a placeholder");
		47
		48	async_test(function(t) {
		49	var complete = 0;
		50	var onload_callback = function() {
		51	if (++complete == 4) {
		52	// The four images with loading=lazy,auto or default or invalid attribute are loaded.
		53	assert_true(is_image_fully_loaded(no_attribute_img));
		54	assert_true(is_image_fully_loaded(lazy_attribute_img));
		55	assert_true(is_image_fully_loaded(auto_attribute_img));
		56	assert_true(is_image_fully_loaded(invalid_attribute_img));
		57	t.done();
		58	}
		59	assert_equals("eager", this.getAttribute('loading'));
		60	};
		61	no_attribute_img.addEventListener("load", onload_callback);
		62	lazy_attribute_img.addEventListener("load", onload_callback);
		63	auto_attribute_img.addEventListener("load", onload_callback);
		64	invalid_attribute_img.addEventListener("load", onload_callback);
65	window.addEventListener("load", t.step_func(function() {
66	assert_equals(null, no_attribute_img.getAttribute('loading'));
67	assert_equals("lazy", lazy_attribute_img.getAttribute('loading'));
68	assert_equals("auto", auto_attribute_img.getAttribute('loading'));
69	assert_equals("invalid-value-default", invalid_attribute_img.getAttribute('loading'));
70	no_attribute_img.setAttribute('loading', 'eager');
71	lazy_attribute_img.setAttribute('loading', 'eager');
72	auto_attribute_img.setAttribute('loading', 'eager');
73	invalid_attribute_img.setAttribute('loading', 'eager');
74	}));
75	}, "Test that deferred <img> are fully loaded when lazyload is turned off");
76	</script>

Line 0 a/LayoutTests/http/tests/lazyload/placeholder.js_sec1
- a/LayoutTests/http/tests/lazyload/placeholder.js +16 lines
	1	// Returns if the image is complete and fully loaded as a non-placeholder image.
	2	function is_image_fully_loaded(image) {
	3	if (!image.complete) {
	4	return false;
	5	}
	6
	7	let canvas = document.createElement('canvas');
	8	canvas.width = canvas.height = 1;
	9	let canvasContext = canvas.getContext("2d");
	10	canvasContext.drawImage(image, 0, 0);
	11	let data = canvasContext.getImageData(0, 0, canvas.width, canvas.height).data;
	12
	13	// Fully loaded image should not be a placeholder which is drawn as a
	14	// translucent gray rectangle in placeholder_image.cc
	15	return data[0] != 0xd9 \|\| data[1] != 0xd9 \|\| data[2] != 0xd9;
	16	}

Line 0 a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/attribute_off_image.tentative-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/attribute_off_image.tentative-expected.txt +11 lines
	1	main frame - didStartProvisionalLoadForFrame
	2	main frame - didCommitLoadForFrame
	3	main frame - didReceiveTitle: Loading images with loading="eager"
	4	main frame - didFinishDocumentLoadForFrame
	5	main frame - didHandleOnloadEventsForFrame
	6	main frame - didFinishLoadForFrame
	7
	8
	9
	10	PASS Test that both images load immediately and block the window's load event.
	11

Line 0 a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/attribute_off_image.tentative.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/loading/lazyload/attribute_off_image.tentative.html +41 lines
	1	<!DOCTYPE html>
	2	<head>
	3	<title>Loading images with loading="eager"</title>
	4	<link rel="author" title="Scott Little" href="mailto:sclittle@chromium.org">
	5	<link rel="help" href="https://github.com/whatwg/html/pull/3752">
	6	<script src="/resources/testharness.js"></script>
	7	<script src="/resources/testharnessreport.js"></script>
	8	</head>
	9
	10	<!--
	11	Marked as tentative until https://github.com/whatwg/html/pull/3752 is landed.
	12	-->
	13
	14	<body>
	15	<img id="in_viewport" src="resources/image_1.png" loading="eager">
	16	<div style="height:10000px;"></div>
	17	<img id="below_viewport" src="resources/image_2.png" loading="eager">
	18	</body>
	19
	20	<script>
	21	var t = async_test("Test that both images load immediately and block the window's load event.");
	22
	23	var has_in_viewport_image_loaded = false;
	24	document.getElementById("in_viewport").addEventListener("load",
	25	t.step_func(function() {
	26	assert_false(has_in_viewport_image_loaded);
	27	has_in_viewport_image_loaded = true;
	28	}));
	29
	30	var has_below_viewport_image_loaded = false;
	31	document.getElementById("below_viewport").addEventListener("load",
	32	t.step_func(function() {
	33	assert_false(has_below_viewport_image_loaded);
	34	has_below_viewport_image_loaded = true;
	35	}));
	36
	37	window.addEventListener("load", t.step_func_done(function() {
	38	assert_true(has_in_viewport_image_loaded);
	39	assert_true(has_below_viewport_image_loaded);
	40	}));
	41	</script>