[SCM] WebKit Debian packaging branch, webkit-1.1, updated. upstream/1.1.15.1-1414-gc69ee75
hyatt at apple.com
hyatt at apple.com
Thu Oct 29 20:42:29 UTC 2009
The following commit has been merged in the webkit-1.1 branch:
commit f10dc6bb40ebb106695f3845d9faa50ecd39f51b
Author: hyatt at apple.com <hyatt at apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date: Fri Oct 9 17:03:48 2009 +0000
Implement beforeload for images. ImageLoadEventSender has been refactored into a more generic
ImageEventSender that can be used by both load and beforeload events. If the document has any
beforeload listeners, then the installation of images onto the renderer becomes asynchronous
and will be held up until the beforeload event can fire at a later date.
Reviewed by Adam Roben.
Both beforeload and load events now fire at the end of the tokenizer write() methods, so that
in the typical parsing case we don't have to put off the beforeload/load events until after
a layout or paint might already have happened. This lets beforeload/load not cause extra
layouts and repaints.
* dom/ContainerNode.cpp:
(WebCore::ContainerNode::dispatchBeforeLoadEvent):
* dom/Document.cpp:
(WebCore::Document::implicitClose):
(WebCore::Document::addListenerTypeIfNeeded):
* dom/Document.h:
(WebCore::Document::):
* dom/XMLTokenizer.cpp:
(WebCore::XMLTokenizer::write):
* html/HTMLImageElement.cpp:
(WebCore::HTMLImageElement::attach):
* html/HTMLInputElement.cpp:
(WebCore::HTMLInputElement::attach):
* html/HTMLTokenizer.cpp:
(WebCore::HTMLTokenizer::write):
* loader/ImageLoader.cpp:
(WebCore::ImageBeforeLoadEventSender::ImageBeforeLoadEventSender):
(WebCore::ImageLoadEventSender::ImageLoadEventSender):
(WebCore::beforeLoadEventSender):
(WebCore::ImageLoader::ImageLoader):
(WebCore::ImageLoader::~ImageLoader):
(WebCore::ImageLoader::setImage):
(WebCore::ImageLoader::setLoadingImage):
(WebCore::ImageLoader::updateFromElement):
(WebCore::ImageLoader::notifyFinished):
(WebCore::ImageLoader::dispatchPendingBeforeLoadEvent):
(WebCore::ImageLoader::dispatchPendingEvents):
(WebCore::ImageEventSender::ImageEventSender):
(WebCore::ImageEventSender::dispatchEventSoon):
(WebCore::ImageEventSender::cancelEvent):
(WebCore::ImageEventSender::dispatchPendingEvents):
(WebCore::ImageEventSender::timerFired):
* loader/ImageLoader.h:
(WebCore::ImageLoader::haveFiredBeforeLoadEvent):
* wml/WMLImageElement.cpp:
(WebCore::WMLImageElement::attach):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@49394 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/LayoutTests/editing/selection/doubleclick-whitespace-img-crash-expected.txt b/LayoutTests/fast/dom/beforeload/image-before-load-expected.txt
similarity index 100%
copy from LayoutTests/editing/selection/doubleclick-whitespace-img-crash-expected.txt
copy to LayoutTests/fast/dom/beforeload/image-before-load-expected.txt
diff --git a/LayoutTests/fast/dom/beforeload/image-before-load.html b/LayoutTests/fast/dom/beforeload/image-before-load.html
new file mode 100644
index 0000000..97c146c
--- /dev/null
+++ b/LayoutTests/fast/dom/beforeload/image-before-load.html
@@ -0,0 +1,26 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<script>
+function print(message, color)
+{
+ var paragraph = document.createElement("div");
+ paragraph.appendChild(document.createTextNode(message));
+ paragraph.style.fontFamily = "monospace";
+ if (color)
+ paragraph.style.color = color;
+ document.getElementById("console").appendChild(paragraph);
+}
+</script>
+</head>
+<body>
+<div id="console"></div>
+<script>
+if (window.layoutTestController) {
+ layoutTestController.dumpAsText();
+}
+</script>
+
+<img style="display:none" onbeforeload="print('PASS', 'green'); return false;" onload="print('FAIL', 'red');" src="../../images/resources/test-load.jpg">
+
+</body>
+</html>
diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog
index 94e46da..aa340ba 100644
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -1,3 +1,54 @@
+2009-10-08 Dave Hyatt <hyatt at apple.com>
+
+ Reviewed by Adam Roben.
+
+ Implement beforeload for images. ImageLoadEventSender has been refactored into a more generic
+ ImageEventSender that can be used by both load and beforeload events. If the document has any
+ beforeload listeners, then the installation of images onto the renderer becomes asynchronous
+ and will be held up until the beforeload event can fire at a later date.
+
+ Both beforeload and load events now fire at the end of the tokenizer write() methods, so that
+ in the typical parsing case we don't have to put off the beforeload/load events until after
+ a layout or paint might already have happened. This lets beforeload/load not cause extra
+ layouts and repaints.
+
+ * dom/ContainerNode.cpp:
+ (WebCore::ContainerNode::dispatchBeforeLoadEvent):
+ * dom/Document.cpp:
+ (WebCore::Document::implicitClose):
+ (WebCore::Document::addListenerTypeIfNeeded):
+ * dom/Document.h:
+ (WebCore::Document::):
+ * dom/XMLTokenizer.cpp:
+ (WebCore::XMLTokenizer::write):
+ * html/HTMLImageElement.cpp:
+ (WebCore::HTMLImageElement::attach):
+ * html/HTMLInputElement.cpp:
+ (WebCore::HTMLInputElement::attach):
+ * html/HTMLTokenizer.cpp:
+ (WebCore::HTMLTokenizer::write):
+ * loader/ImageLoader.cpp:
+ (WebCore::ImageBeforeLoadEventSender::ImageBeforeLoadEventSender):
+ (WebCore::ImageLoadEventSender::ImageLoadEventSender):
+ (WebCore::beforeLoadEventSender):
+ (WebCore::ImageLoader::ImageLoader):
+ (WebCore::ImageLoader::~ImageLoader):
+ (WebCore::ImageLoader::setImage):
+ (WebCore::ImageLoader::setLoadingImage):
+ (WebCore::ImageLoader::updateFromElement):
+ (WebCore::ImageLoader::notifyFinished):
+ (WebCore::ImageLoader::dispatchPendingBeforeLoadEvent):
+ (WebCore::ImageLoader::dispatchPendingEvents):
+ (WebCore::ImageEventSender::ImageEventSender):
+ (WebCore::ImageEventSender::dispatchEventSoon):
+ (WebCore::ImageEventSender::cancelEvent):
+ (WebCore::ImageEventSender::dispatchPendingEvents):
+ (WebCore::ImageEventSender::timerFired):
+ * loader/ImageLoader.h:
+ (WebCore::ImageLoader::haveFiredBeforeLoadEvent):
+ * wml/WMLImageElement.cpp:
+ (WebCore::WMLImageElement::attach):
+
2009-10-09 Pavel Feldman <pfeldman at chromium.org>
Reviewed by Dimitri Glazkov.
diff --git a/WebCore/dom/ContainerNode.cpp b/WebCore/dom/ContainerNode.cpp
index 9d0b0c3..5cd0781 100644
--- a/WebCore/dom/ContainerNode.cpp
+++ b/WebCore/dom/ContainerNode.cpp
@@ -912,6 +912,9 @@ static void dispatchChildRemovalEvents(Node* child)
bool ContainerNode::dispatchBeforeLoadEvent(const String& sourceURL)
{
+ if (!document()->hasListenerType(Document::BEFORELOAD_LISTENER))
+ return true;
+
RefPtr<ContainerNode> protector(this);
RefPtr<BeforeLoadEvent> beforeLoadEvent = BeforeLoadEvent::create(sourceURL);
dispatchEvent(beforeLoadEvent.get());
diff --git a/WebCore/dom/Document.cpp b/WebCore/dom/Document.cpp
index 3e58715..0f4c44a 100644
--- a/WebCore/dom/Document.cpp
+++ b/WebCore/dom/Document.cpp
@@ -1711,7 +1711,7 @@ void Document::implicitClose()
if (f)
f->animation()->resumeAnimations(this);
- ImageLoader::dispatchPendingLoadEvents();
+ ImageLoader::dispatchPendingEvents();
dispatchWindowLoadEvent();
dispatchWindowEvent(PageTransitionEvent::create(eventNames().pageshowEvent, false), this);
if (f)
@@ -2960,6 +2960,8 @@ void Document::addListenerTypeIfNeeded(const AtomicString& eventType)
addListenerType(ANIMATIONITERATION_LISTENER);
else if (eventType == eventNames().webkitTransitionEndEvent)
addListenerType(TRANSITIONEND_LISTENER);
+ else if (eventType == eventNames().beforeloadEvent)
+ addListenerType(BEFORELOAD_LISTENER);
}
CSSStyleDeclaration* Document::getOverrideStyle(Element*, const String&)
diff --git a/WebCore/dom/Document.h b/WebCore/dom/Document.h
index f05c9f9..a583d3e 100644
--- a/WebCore/dom/Document.h
+++ b/WebCore/dom/Document.h
@@ -615,7 +615,8 @@ public:
ANIMATIONEND_LISTENER = 0x100,
ANIMATIONSTART_LISTENER = 0x200,
ANIMATIONITERATION_LISTENER = 0x400,
- TRANSITIONEND_LISTENER = 0x800
+ TRANSITIONEND_LISTENER = 0x800,
+ BEFORELOAD_LISTENER = 0x1000
};
bool hasListenerType(ListenerType listenerType) const { return (m_listenerTypes & listenerType); }
diff --git a/WebCore/dom/XMLTokenizer.cpp b/WebCore/dom/XMLTokenizer.cpp
index 625a9e6..543927d 100644
--- a/WebCore/dom/XMLTokenizer.cpp
+++ b/WebCore/dom/XMLTokenizer.cpp
@@ -40,6 +40,7 @@
#include "HTMLLinkElement.h"
#include "HTMLNames.h"
#include "HTMLStyleElement.h"
+#include "ImageLoader.h"
#include "ProcessingInstruction.h"
#include "ResourceError.h"
#include "ResourceHandle.h"
@@ -105,6 +106,9 @@ void XMLTokenizer::write(const SegmentedString& s, bool /*appendData*/)
}
doWrite(s.toString());
+
+ // After parsing, go ahead and dispatch image beforeload/load events.
+ ImageLoader::dispatchPendingEvents();
}
void XMLTokenizer::handleError(ErrorType type, const char* m, int lineNumber, int columnNumber)
diff --git a/WebCore/html/HTMLImageElement.cpp b/WebCore/html/HTMLImageElement.cpp
index 932e718..d353073 100644
--- a/WebCore/html/HTMLImageElement.cpp
+++ b/WebCore/html/HTMLImageElement.cpp
@@ -118,6 +118,8 @@ void HTMLImageElement::parseMappedAttribute(MappedAttribute* attr)
setAttributeEventListener(eventNames().abortEvent, createAttributeEventListener(this, attr));
else if (attrName == onloadAttr)
setAttributeEventListener(eventNames().loadEvent, createAttributeEventListener(this, attr));
+ else if (attrName == onbeforeloadAttr)
+ setAttributeEventListener(eventNames().beforeloadEvent, createAttributeEventListener(this, attr));
else if (attrName == compositeAttr) {
if (!parseCompositeOperator(attr->value(), m_compositeOperator))
m_compositeOperator = CompositeSourceOver;
@@ -167,7 +169,7 @@ void HTMLImageElement::attach()
{
HTMLElement::attach();
- if (renderer() && renderer()->isImage()) {
+ if (renderer() && renderer()->isImage() && m_imageLoader.haveFiredBeforeLoadEvent()) {
RenderImage* imageObj = toRenderImage(renderer());
if (imageObj->hasImage())
return;
diff --git a/WebCore/html/HTMLInputElement.cpp b/WebCore/html/HTMLInputElement.cpp
index f6d634e..ed3405a 100644
--- a/WebCore/html/HTMLInputElement.cpp
+++ b/WebCore/html/HTMLInputElement.cpp
@@ -862,7 +862,7 @@ void HTMLInputElement::attach()
if (!m_imageLoader)
m_imageLoader.set(new HTMLImageLoader(this));
m_imageLoader->updateFromElement();
- if (renderer()) {
+ if (renderer() && m_imageLoader->haveFiredBeforeLoadEvent()) {
RenderImage* imageObj = toRenderImage(renderer());
imageObj->setCachedImage(m_imageLoader->image());
diff --git a/WebCore/html/HTMLTokenizer.cpp b/WebCore/html/HTMLTokenizer.cpp
index 64f0a64..c03a3fc 100644
--- a/WebCore/html/HTMLTokenizer.cpp
+++ b/WebCore/html/HTMLTokenizer.cpp
@@ -43,6 +43,7 @@
#include "HTMLParser.h"
#include "HTMLScriptElement.h"
#include "HTMLViewSourceDocument.h"
+#include "ImageLoader.h"
#include "InspectorTimelineAgent.h"
#include "MappedAttribute.h"
#include "Page.h"
@@ -1802,6 +1803,9 @@ void HTMLTokenizer::write(const SegmentedString& str, bool appendData)
if (m_noMoreData && !m_inWrite && !state.loadingExtScript() && !m_executingScript && !m_timer.isActive())
end(); // this actually causes us to be deleted
+
+ // After parsing, go ahead and dispatch image beforeload/load events.
+ ImageLoader::dispatchPendingEvents();
}
void HTMLTokenizer::stopParsing()
diff --git a/WebCore/loader/ImageLoader.cpp b/WebCore/loader/ImageLoader.cpp
index b183a66..cdc31bc 100644
--- a/WebCore/loader/ImageLoader.cpp
+++ b/WebCore/loader/ImageLoader.cpp
@@ -31,34 +31,40 @@
namespace WebCore {
-class ImageLoadEventSender {
+class ImageEventSender {
public:
- ImageLoadEventSender();
+ ImageEventSender(const AtomicString& eventType);
- void dispatchLoadEventSoon(ImageLoader*);
- void cancelLoadEvent(ImageLoader*);
+ void dispatchEventSoon(ImageLoader*);
+ void cancelEvent(ImageLoader*);
- void dispatchPendingLoadEvents();
+ void dispatchPendingEvents();
private:
- ~ImageLoadEventSender();
+ void timerFired(Timer<ImageEventSender>*);
- void timerFired(Timer<ImageLoadEventSender>*);
-
- Timer<ImageLoadEventSender> m_timer;
+ AtomicString m_eventType;
+ Timer<ImageEventSender> m_timer;
Vector<ImageLoader*> m_dispatchSoonList;
Vector<ImageLoader*> m_dispatchingList;
};
-static ImageLoadEventSender& loadEventSender()
+static ImageEventSender& beforeLoadEventSender()
+{
+ DEFINE_STATIC_LOCAL(ImageEventSender, sender, (eventNames().beforeloadEvent));
+ return sender;
+}
+
+static ImageEventSender& loadEventSender()
{
- DEFINE_STATIC_LOCAL(ImageLoadEventSender, sender, ());
+ DEFINE_STATIC_LOCAL(ImageEventSender, sender, (eventNames().loadEvent));
return sender;
}
ImageLoader::ImageLoader(Element* element)
: m_element(element)
, m_image(0)
+ , m_firedBeforeLoad(true)
, m_firedLoad(true)
, m_imageComplete(true)
, m_loadManually(false)
@@ -69,7 +75,10 @@ ImageLoader::~ImageLoader()
{
if (m_image)
m_image->removeClient(this);
- loadEventSender().cancelLoadEvent(this);
+ if (!m_firedBeforeLoad)
+ beforeLoadEventSender().cancelEvent(this);
+ if (!m_firedLoad)
+ loadEventSender().cancelEvent(this);
}
void ImageLoader::setImage(CachedImage* newImage)
@@ -78,6 +87,7 @@ void ImageLoader::setImage(CachedImage* newImage)
CachedImage* oldImage = m_image.get();
if (newImage != oldImage) {
setLoadingImage(newImage);
+ m_firedBeforeLoad = true;
m_firedLoad = true;
m_imageComplete = true;
if (newImage)
@@ -89,16 +99,16 @@ void ImageLoader::setImage(CachedImage* newImage)
if (RenderObject* renderer = m_element->renderer()) {
if (!renderer->isImage())
return;
-
toRenderImage(renderer)->resetAnimation();
}
}
void ImageLoader::setLoadingImage(CachedImage* loadingImage)
{
- m_firedLoad = false;
- m_imageComplete = false;
m_image = loadingImage;
+ m_firedBeforeLoad = !loadingImage;
+ m_firedLoad = !loadingImage;
+ m_imageComplete = !loadingImage;
}
void ImageLoader::updateFromElement()
@@ -137,8 +147,13 @@ void ImageLoader::updateFromElement()
CachedImage* oldImage = m_image.get();
if (newImage != oldImage) {
setLoadingImage(newImage);
- if (newImage)
+ if (newImage) {
newImage->addClient(this);
+ if (!m_element->document()->hasListenerType(Document::BEFORELOAD_LISTENER))
+ dispatchPendingBeforeLoadEvent();
+ else
+ beforeLoadEventSender().dispatchEventSoon(this);
+ }
if (oldImage)
oldImage->removeClient(this);
}
@@ -146,7 +161,6 @@ void ImageLoader::updateFromElement()
if (RenderObject* renderer = m_element->renderer()) {
if (!renderer->isImage())
return;
-
toRenderImage(renderer)->resetAnimation();
}
}
@@ -161,16 +175,48 @@ void ImageLoader::updateFromElementIgnoringPreviousError()
void ImageLoader::notifyFinished(CachedResource*)
{
ASSERT(m_failedLoadURL.isEmpty());
+
m_imageComplete = true;
+ if (haveFiredBeforeLoadEvent())
+ updateRenderer();
- loadEventSender().dispatchLoadEventSoon(this);
+ loadEventSender().dispatchEventSoon(this);
+}
+void ImageLoader::updateRenderer()
+{
if (RenderObject* renderer = m_element->renderer()) {
if (!renderer->isImage())
return;
+ RenderImage* imageRenderer = toRenderImage(renderer);
+
+ // Only update the renderer if it doesn't have an image or if what we have
+ // is a complete image. This prevents flickering in the case where a dynamic
+ // change is happening between two images.
+ CachedImage* cachedImage = imageRenderer->cachedImage();
+ if (m_image != cachedImage && (m_imageComplete || !imageRenderer->cachedImage()))
+ imageRenderer->setCachedImage(m_image.get());
+ }
+}
- toRenderImage(renderer)->setCachedImage(m_image.get());
+void ImageLoader::dispatchPendingBeforeLoadEvent()
+{
+ if (m_firedBeforeLoad)
+ return;
+ if (!m_image)
+ return;
+ if (!m_element->document()->attached())
+ return;
+ m_firedBeforeLoad = true;
+ if (m_element->dispatchBeforeLoadEvent(m_image->url())) {
+ updateRenderer();
+ return;
+ }
+ if (m_image) {
+ m_image->removeClient(this);
+ m_image = 0;
}
+ loadEventSender().cancelEvent(this);
}
void ImageLoader::dispatchPendingLoadEvent()
@@ -185,24 +231,26 @@ void ImageLoader::dispatchPendingLoadEvent()
dispatchLoadEvent();
}
-void ImageLoader::dispatchPendingLoadEvents()
+void ImageLoader::dispatchPendingEvents()
{
- loadEventSender().dispatchPendingLoadEvents();
+ beforeLoadEventSender().dispatchPendingEvents();
+ loadEventSender().dispatchPendingEvents();
}
-ImageLoadEventSender::ImageLoadEventSender()
- : m_timer(this, &ImageLoadEventSender::timerFired)
+ImageEventSender::ImageEventSender(const AtomicString& eventType)
+ : m_eventType(eventType)
+ , m_timer(this, &ImageEventSender::timerFired)
{
}
-void ImageLoadEventSender::dispatchLoadEventSoon(ImageLoader* loader)
+void ImageEventSender::dispatchEventSoon(ImageLoader* loader)
{
m_dispatchSoonList.append(loader);
if (!m_timer.isActive())
m_timer.startOneShot(0);
}
-void ImageLoadEventSender::cancelLoadEvent(ImageLoader* loader)
+void ImageEventSender::cancelEvent(ImageLoader* loader)
{
// Remove instances of this loader from both lists.
// Use loops because we allow multiple instances to get into the lists.
@@ -220,7 +268,7 @@ void ImageLoadEventSender::cancelLoadEvent(ImageLoader* loader)
m_timer.stop();
}
-void ImageLoadEventSender::dispatchPendingLoadEvents()
+void ImageEventSender::dispatchPendingEvents()
{
// Need to avoid re-entering this function; if new dispatches are
// scheduled before the parent finishes processing the list, they
@@ -233,15 +281,19 @@ void ImageLoadEventSender::dispatchPendingLoadEvents()
m_dispatchingList.swap(m_dispatchSoonList);
size_t size = m_dispatchingList.size();
for (size_t i = 0; i < size; ++i) {
- if (ImageLoader* loader = m_dispatchingList[i])
- loader->dispatchPendingLoadEvent();
+ if (ImageLoader* loader = m_dispatchingList[i]) {
+ if (m_eventType == eventNames().beforeloadEvent)
+ loader->dispatchPendingBeforeLoadEvent();
+ else
+ loader->dispatchPendingLoadEvent();
+ }
}
m_dispatchingList.clear();
}
-void ImageLoadEventSender::timerFired(Timer<ImageLoadEventSender>*)
+void ImageEventSender::timerFired(Timer<ImageEventSender>*)
{
- dispatchPendingLoadEvents();
+ dispatchPendingEvents();
}
}
diff --git a/WebCore/loader/ImageLoader.h b/WebCore/loader/ImageLoader.h
index 3496f75..7f42e33 100644
--- a/WebCore/loader/ImageLoader.h
+++ b/WebCore/loader/ImageLoader.h
@@ -53,9 +53,10 @@ public:
void setLoadManually(bool loadManually) { m_loadManually = loadManually; }
+ bool haveFiredBeforeLoadEvent() const { return m_firedBeforeLoad; }
bool haveFiredLoadEvent() const { return m_firedLoad; }
- static void dispatchPendingLoadEvents();
+ static void dispatchPendingEvents();
protected:
virtual void notifyFinished(CachedResource*);
@@ -64,14 +65,18 @@ private:
virtual void dispatchLoadEvent() = 0;
virtual String sourceURI(const AtomicString&) const = 0;
- friend class ImageLoadEventSender;
+ friend class ImageEventSender;
+ void dispatchPendingBeforeLoadEvent();
void dispatchPendingLoadEvent();
void setLoadingImage(CachedImage*);
+ void updateRenderer();
+
Element* m_element;
CachedResourceHandle<CachedImage> m_image;
AtomicString m_failedLoadURL;
+ bool m_firedBeforeLoad : 1;
bool m_firedLoad : 1;
bool m_imageComplete : 1;
bool m_loadManually : 1;
diff --git a/WebCore/wml/WMLImageElement.cpp b/WebCore/wml/WMLImageElement.cpp
index d47868a..e577218 100644
--- a/WebCore/wml/WMLImageElement.cpp
+++ b/WebCore/wml/WMLImageElement.cpp
@@ -94,13 +94,12 @@ void WMLImageElement::attach()
{
WMLElement::attach();
- if (renderer() && renderer()->isImage()) {
+ if (renderer() && renderer()->isImage() && m_imageLoader.haveFiredBeforeLoadEvent()) {
RenderImage* imageObj = toRenderImage(renderer());
if (imageObj->hasImage())
return;
-
imageObj->setCachedImage(m_imageLoader.image());
-
+
// If we have no image at all because we have no src attribute, set
// image height and width for the alt text instead.
if (!m_imageLoader.image() && !imageObj->cachedImage())
--
WebKit Debian packaging
More information about the Pkg-webkit-commits
mailing list