diff -r 000000000000 -r 4f2f89ce4247 WebCore/loader/ImageLoader.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/loader/ImageLoader.cpp	Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,353 @@
+/*
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ *           (C) 1999 Antti Koivisto (koivisto@kde.org)
+ * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 Apple Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "ImageLoader.h"
+
+#include "CSSHelper.h"
+#include "CachedImage.h"
+#include "DocLoader.h"
+#include "Document.h"
+#include "Element.h"
+#include "HTMLNames.h"
+#include "HTMLObjectElement.h"
+#include "RenderImage.h"
+
+#if !ASSERT_DISABLED
+// ImageLoader objects are allocated as members of other objects, so generic pointer check would always fail.
+namespace WTF {
+
+template<> struct ValueCheck<WebCore::ImageLoader*> {
+    typedef WebCore::ImageLoader* TraitType;
+    static void checkConsistency(const WebCore::ImageLoader* p)
+    {
+        if (!p)
+            return;
+        ASSERT(p->element());
+        ValueCheck<WebCore::Element*>::checkConsistency(p->element());
+    }
+};
+
+}
+#endif
+
+namespace WebCore {
+
+class ImageEventSender : public Noncopyable {
+public:
+    ImageEventSender(const AtomicString& eventType);
+
+    void dispatchEventSoon(ImageLoader*);
+    void cancelEvent(ImageLoader*);
+
+    void dispatchPendingEvents();
+
+#if !ASSERT_DISABLED
+    bool hasPendingEvents(ImageLoader* loader) { return m_dispatchSoonList.find(loader) != notFound; }
+#endif
+
+private:
+    void timerFired(Timer<ImageEventSender>*);
+
+    AtomicString m_eventType;
+    Timer<ImageEventSender> m_timer;
+    Vector<ImageLoader*> m_dispatchSoonList;
+    Vector<ImageLoader*> m_dispatchingList;
+};
+
+static ImageEventSender& beforeLoadEventSender()
+{
+    DEFINE_STATIC_LOCAL(ImageEventSender, sender, (eventNames().beforeloadEvent));
+    return sender;
+}
+
+static ImageEventSender& loadEventSender()
+{
+    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)
+{
+}
+
+ImageLoader::~ImageLoader()
+{
+    if (m_image)
+        m_image->removeClient(this);
+
+    ASSERT(!m_firedBeforeLoad || !beforeLoadEventSender().hasPendingEvents(this));
+    if (!m_firedBeforeLoad)
+        beforeLoadEventSender().cancelEvent(this);
+
+    ASSERT(!m_firedLoad || !loadEventSender().hasPendingEvents(this));
+    if (!m_firedLoad)
+        loadEventSender().cancelEvent(this);
+}
+
+void ImageLoader::setImage(CachedImage* newImage)
+{
+    ASSERT(m_failedLoadURL.isEmpty());
+    CachedImage* oldImage = m_image.get();
+    if (newImage != oldImage) {
+        m_image = newImage;
+        if (!m_firedBeforeLoad) {
+            beforeLoadEventSender().cancelEvent(this);
+            m_firedBeforeLoad = true;
+        }
+        if (!m_firedLoad) {
+            loadEventSender().cancelEvent(this);
+            m_firedLoad = true;
+        }
+        m_imageComplete = true;
+        if (newImage)
+            newImage->addClient(this);
+        if (oldImage)
+            oldImage->removeClient(this);
+    }
+
+    if (RenderObject* renderer = m_element->renderer()) {
+        if (!renderer->isImage())
+            return;
+        toRenderImage(renderer)->resetAnimation();
+    }
+}
+
+void ImageLoader::updateFromElement()
+{
+    // If we're not making renderers for the page, then don't load images.  We don't want to slow
+    // down the raw HTML parsing case by loading images we don't intend to display.
+    Document* document = m_element->document();
+    if (!document->renderer())
+        return;
+
+    AtomicString attr = m_element->getAttribute(m_element->imageSourceAttributeName());
+
+    if (attr == m_failedLoadURL)
+        return;
+
+    // Do not load any image if the 'src' attribute is missing or if it is
+    // an empty string referring to a local file. The latter condition is
+    // a quirk that preserves old behavior that Dashboard widgets
+    // need (<rdar://problem/5994621>).
+    CachedImage* newImage = 0;
+    if (!(attr.isNull() || (attr.isEmpty() && document->baseURI().isLocalFile()))) {
+        if (m_loadManually) {
+            bool autoLoadOtherImages = document->docLoader()->autoLoadImages();
+            document->docLoader()->setAutoLoadImages(false);
+            newImage = new CachedImage(sourceURI(attr));
+            newImage->setLoading(true);
+            newImage->setDocLoader(document->docLoader());
+            document->docLoader()->m_documentResources.set(newImage->url(), newImage);
+            document->docLoader()->setAutoLoadImages(autoLoadOtherImages);
+        } else
+            newImage = document->docLoader()->requestImage(sourceURI(attr));
+
+        // If we do not have an image here, it means that a cross-site
+        // violation occurred.
+        m_failedLoadURL = !newImage ? attr : AtomicString();
+    }
+    
+    CachedImage* oldImage = m_image.get();
+    if (newImage != oldImage) {
+        if (!m_firedBeforeLoad)
+            beforeLoadEventSender().cancelEvent(this);
+        if (!m_firedLoad)
+            loadEventSender().cancelEvent(this);
+
+        m_image = newImage;
+        m_firedBeforeLoad = !newImage;
+        m_firedLoad = !newImage;
+        m_imageComplete = !newImage;
+
+        if (newImage) {
+            newImage->addClient(this);
+            if (!m_element->document()->hasListenerType(Document::BEFORELOAD_LISTENER))
+                dispatchPendingBeforeLoadEvent();
+            else
+                beforeLoadEventSender().dispatchEventSoon(this);
+        }
+        if (oldImage)
+            oldImage->removeClient(this);
+    }
+
+    if (RenderObject* renderer = m_element->renderer()) {
+        if (!renderer->isImage())
+            return;
+        toRenderImage(renderer)->resetAnimation();
+    }
+}
+
+void ImageLoader::updateFromElementIgnoringPreviousError()
+{
+    // Clear previous error.
+    m_failedLoadURL = AtomicString();
+    updateFromElement();
+}
+
+void ImageLoader::notifyFinished(CachedResource*)
+{
+    ASSERT(m_failedLoadURL.isEmpty());
+
+    m_imageComplete = true;
+    if (haveFiredBeforeLoadEvent())
+        updateRenderer();
+
+    if (m_firedLoad)
+        return;
+
+    loadEventSender().dispatchEventSoon(this);
+}
+
+void ImageLoader::updateRenderer()
+{
+    if (RenderObject* renderer = m_element->renderer()) {
+        if (!renderer->isImage() && !renderer->isVideo())
+            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 || !cachedImage))
+            imageRenderer->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);
+    
+    if (m_element->hasTagName(HTMLNames::objectTag))
+        static_cast<HTMLObjectElement*>(m_element)->renderFallbackContent();
+}
+
+void ImageLoader::dispatchPendingLoadEvent()
+{
+    if (m_firedLoad)
+        return;
+    if (!m_image)
+        return;
+    if (!m_element->document()->attached())
+        return;
+    m_firedLoad = true;
+    dispatchLoadEvent();
+}
+
+void ImageLoader::dispatchPendingBeforeLoadEvents()
+{
+    beforeLoadEventSender().dispatchPendingEvents();
+}
+
+void ImageLoader::dispatchPendingLoadEvents()
+{
+    loadEventSender().dispatchPendingEvents();
+}
+
+void ImageLoader::elementWillMoveToNewOwnerDocument()
+{
+    setImage(0);
+}
+
+ImageEventSender::ImageEventSender(const AtomicString& eventType)
+    : m_eventType(eventType)
+    , m_timer(this, &ImageEventSender::timerFired)
+{
+}
+
+void ImageEventSender::dispatchEventSoon(ImageLoader* loader)
+{
+    m_dispatchSoonList.append(loader);
+    if (!m_timer.isActive())
+        m_timer.startOneShot(0);
+}
+
+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.
+    size_t size = m_dispatchSoonList.size();
+    for (size_t i = 0; i < size; ++i) {
+        if (m_dispatchSoonList[i] == loader)
+            m_dispatchSoonList[i] = 0;
+    }
+    size = m_dispatchingList.size();
+    for (size_t i = 0; i < size; ++i) {
+        if (m_dispatchingList[i] == loader)
+            m_dispatchingList[i] = 0;
+    }
+    if (m_dispatchSoonList.isEmpty())
+        m_timer.stop();
+}
+
+void ImageEventSender::dispatchPendingEvents()
+{
+    // Need to avoid re-entering this function; if new dispatches are
+    // scheduled before the parent finishes processing the list, they
+    // will set a timer and eventually be processed.
+    if (!m_dispatchingList.isEmpty())
+        return;
+
+    m_timer.stop();
+
+    m_dispatchSoonList.checkConsistency();
+
+    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]) {
+            if (m_eventType == eventNames().beforeloadEvent)
+                loader->dispatchPendingBeforeLoadEvent();
+            else
+                loader->dispatchPendingLoadEvent();
+        }
+    }
+    m_dispatchingList.clear();
+}
+
+void ImageEventSender::timerFired(Timer<ImageEventSender>*)
+{
+    dispatchPendingEvents();
+}
+
+}