Changeset 36712 in webkit


Ignore:
Timestamp:
Sep 20, 2008 1:19:45 PM (16 years ago)
Author:
Nikolas Zimmermann
Message:

Reviewed by Eric.

Refactor HTMLImageLoader/SVGImageLoader code.
Move html/HTMLImageLoader.* to loader/ImageLoader.*

Let HTMLImageLoader & SVGImageLoader inherit from the new base class.
SVGImageLoader used to inherit from HTMLImageLoader which is awkward.

Location:
trunk/WebCore
Files:
15 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r36709 r36712  
     12008-09-20  Nikolas Zimmermann  <zimmermann@kde.org>
     2
     3        Reviewed by Eric.
     4
     5        Refactor HTMLImageLoader/SVGImageLoader code.
     6        Move html/HTMLImageLoader.* to loader/ImageLoader.*
     7
     8        Let HTMLImageLoader & SVGImageLoader inherit from the new base class.
     9        SVGImageLoader used to inherit from HTMLImageLoader which is awkward.
     10
     11        * GNUmakefile.am:
     12        * WebCore.pro:
     13        * WebCore.vcproj/WebCore.vcproj:
     14        * WebCore.xcodeproj/project.pbxproj:
     15        * WebCoreSources.bkl:
     16        * dom/Document.cpp:
     17        (WebCore::Document::dispatchImageLoadEventSoon):
     18        (WebCore::Document::removeImage):
     19        (WebCore::Document::dispatchImageLoadEventsNow):
     20        * dom/Document.h:
     21        * html/HTMLImageLoader.cpp:
     22        (WebCore::HTMLImageLoader::HTMLImageLoader):
     23        (WebCore::HTMLImageLoader::~HTMLImageLoader):
     24        (WebCore::HTMLImageLoader::sourceURI):
     25        (WebCore::HTMLImageLoader::notifyFinished):
     26        * html/HTMLImageLoader.h:
     27        * loader/DocLoader.h:
     28        * loader/ImageLoader.cpp: Copied from html/HTMLImageLoader.cpp.
     29        (WebCore::ImageLoader::ImageLoader):
     30        (WebCore::ImageLoader::~ImageLoader):
     31        (WebCore::ImageLoader::setImage):
     32        (WebCore::ImageLoader::setLoadingImage):
     33        (WebCore::ImageLoader::updateFromElement):
     34        (WebCore::ImageLoader::notifyFinished):
     35        * loader/ImageLoader.h: Copied from html/HTMLImageLoader.h.
     36        * svg/SVGImageElement.cpp:
     37        (WebCore::SVGImageElement::attach):
     38        (WebCore::SVGImageElement::insertedIntoDocument):
     39        (WebCore::SVGImageElement::imageSourceAttributeName):
     40        * svg/SVGImageElement.h:
     41        * svg/SVGImageLoader.cpp:
     42        (WebCore::SVGImageLoader::SVGImageLoader):
     43        (WebCore::SVGImageLoader::dispatchLoadEvent):
     44        (WebCore::SVGImageLoader::sourceURI):
     45        * svg/SVGImageLoader.h:
     46
    1472008-09-20  Holger Hans Peter Freyther  <zecke@selfish.org>
    248

  • trunk/WebCore/GNUmakefile.am

    r36658 r36712  
    13601360        WebCore/loader/ImageDocument.cpp \
    13611361        WebCore/loader/ImageDocument.h \
     1362        WebCore/loader/ImageLoader.cpp \
     1363        WebCore/loader/ImageLoader.h \
    13621364        WebCore/loader/MainResourceLoader.cpp \
    13631365        WebCore/loader/MainResourceLoader.h \

  • trunk/WebCore/WebCore.pro

    r36653 r36712  
    720720    loader/icon/IconLoader.cpp \
    721721    loader/ImageDocument.cpp \
     722    loader/ImageLoader.cpp \
    722723    loader/loader.cpp \
    723724    loader/MainResourceLoader.cpp \

  • trunk/WebCore/WebCore.vcproj/WebCore.vcproj

    r36653 r36712  
    28972897                        </File>
    28982898                        <File
     2899                                RelativePath="..\loader\ImageLoader.cpp"
     2900                                >
     2901                        </File>
     2902                        <File
     2903                                RelativePath="..\loader\ImageLoader.h"
     2904                                >
     2905                        </File>
     2906                        <File
    28992907                                RelativePath="..\loader\loader.cpp"
    29002908                                >

  • trunk/WebCore/WebCore.xcodeproj/project.pbxproj

    r36676 r36712  
    4040                06E81ED70AB5D5E900C87837 /* LocalCurrentGraphicsContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 06E81ED60AB5D5E900C87837 /* LocalCurrentGraphicsContext.h */; };
    4141                06E81EEC0AB5DA9700C87837 /* LocalCurrentGraphicsContext.mm in Sources */ = {isa = PBXBuildFile; fileRef = 06E81EEB0AB5DA9700C87837 /* LocalCurrentGraphicsContext.mm */; };
     42                089582550E857A7E00F82C83 /* ImageLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 089582530E857A7E00F82C83 /* ImageLoader.cpp */; };
     43                089582560E857A7E00F82C83 /* ImageLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 089582540E857A7E00F82C83 /* ImageLoader.h */; };
    4244                08A484770E5272C500C3FE76 /* ScriptElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 08A484750E5272C500C3FE76 /* ScriptElement.cpp */; };
    4345                08A484780E5272C500C3FE76 /* ScriptElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 08A484760E5272C500C3FE76 /* ScriptElement.h */; };
    … …  
    46604662                06E81ED60AB5D5E900C87837 /* LocalCurrentGraphicsContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalCurrentGraphicsContext.h; sourceTree = "<group>"; };
    46614663                06E81EEB0AB5DA9700C87837 /* LocalCurrentGraphicsContext.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = LocalCurrentGraphicsContext.mm; sourceTree = "<group>"; };
     4664                089582530E857A7E00F82C83 /* ImageLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageLoader.cpp; sourceTree = "<group>"; };
     4665                089582540E857A7E00F82C83 /* ImageLoader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageLoader.h; sourceTree = "<group>"; };
    46624666                08A484750E5272C500C3FE76 /* ScriptElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ScriptElement.cpp; sourceTree = "<group>"; };
    46634667                08A484760E5272C500C3FE76 /* ScriptElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScriptElement.h; sourceTree = "<group>"; };
    … …  
    1298012984                                1A820D8F0A13EBA600AF843C /* ImageDocument.cpp */,
    1298112985                                1A820D900A13EBA600AF843C /* ImageDocument.h */,
     12986                                089582530E857A7E00F82C83 /* ImageLoader.cpp */,
     12987                                089582540E857A7E00F82C83 /* ImageLoader.h */,
    1298212988                                BCB16C130979C3BD00467741 /* loader.cpp */,
    1298312989                                BCB16C140979C3BD00467741 /* loader.h */,
    … …  
    1584615852                                BC22747B0E8366E200E7F975 /* SVGRenderStyleDefs.h in Headers */,
    1584715853                                B2F34FE60E82F81400F627CD /* DNS.h in Headers */,
     15854                                089582560E857A7E00F82C83 /* ImageLoader.h in Headers */,
    1584815855                        );
    1584915856                        runOnlyForDeploymentPostprocessing = 0;
    … …  
    1767917686                                B2F34FE90E82F82700F627CD /* DNSCFNet.cpp in Sources */,
    1768017687                                BCEF869F0E844E9D00A85CD5 /* ScrollbarThemeMac.mm in Sources */,
     17688                                089582550E857A7E00F82C83 /* ImageLoader.cpp in Sources */,
    1768117689                        );
    1768217690                        runOnlyForDeploymentPostprocessing = 0;

  • trunk/WebCore/WebCoreSources.bkl

    r36630 r36712  
    600600        loader/FTPDirectoryParser.cpp
    601601        loader/ImageDocument.cpp
     602        loader/ImageLoader.cpp
    602603        loader/MainResourceLoader.cpp
    603604        loader/MediaDocument.cpp

  • trunk/WebCore/dom/Document.cpp

    r36706 r36712  
    6161#include "HTMLFrameOwnerElement.h"
    6262#include "HTMLHeadElement.h"
    63 #include "HTMLImageLoader.h"
    6463#include "HTMLInputElement.h"
    6564#include "HTMLLinkElement.h"
    … …  
    7372#include "HitTestRequest.h"
    7473#include "HitTestResult.h"
     74#include "ImageLoader.h"
    7575#include "KeyboardEvent.h"
    7676#include "Logging.h"
    … …  
    27772777}
    27782778
    2779 void Document::dispatchImageLoadEventSoon(HTMLImageLoader *image)
     2779void Document::dispatchImageLoadEventSoon(ImageLoader* image)
    27802780{
    27812781    m_imageLoadEventDispatchSoonList.append(image);
    … …  
    27842784}
    27852785
    2786 void Document::removeImage(HTMLImageLoader* image)
     2786void Document::removeImage(ImageLoader* image)
    27872787{
    27882788    // Remove instances of this image from both lists.
    … …  
    27992799    // scheduled before the parent finishes processing the list, they
    28002800    // will set a timer and eventually be processed
    2801     if (!m_imageLoadEventDispatchingList.isEmpty()) {
    2802         return;
    2803     }
     2801    if (!m_imageLoadEventDispatchingList.isEmpty())
     2802        return;
    28042803
    28052804    m_imageLoadEventTimer.stop();
    … …  
    28072806    m_imageLoadEventDispatchingList = m_imageLoadEventDispatchSoonList;
    28082807    m_imageLoadEventDispatchSoonList.clear();
    2809     for (DeprecatedPtrListIterator<HTMLImageLoader> it(m_imageLoadEventDispatchingList); it.current();) {
    2810         HTMLImageLoader* image = it.current();
     2808    for (DeprecatedPtrListIterator<ImageLoader> it(m_imageLoadEventDispatchingList); it.current();) {
     2809        ImageLoader* image = it.current();
    28112810        // Must advance iterator *before* dispatching call.
    28122811        // Otherwise, it might be advanced automatically if dispatching the call had a side effect
    2813         // of destroying the current HTMLImageLoader, and then we would advance past the *next* item,
     2812        // of destroying the current ImageLoader, and then we would advance past the *next* item,
    28142813        // missing one altogether.
    28152814        ++it;

  • trunk/WebCore/dom/Document.h

    r36706 r36712  
    8181    class HTMLFormElement;
    8282    class HTMLHeadElement;
    83     class HTMLImageLoader;
    8483    class HTMLInputElement;
    8584    class HTMLMapElement;
     85    class ImageLoader;
    8686    class IntPoint;
    8787    class JSNode;
    … …  
    611611    void processHttpEquiv(const String& equiv, const String& content);
    612612   
    613     void dispatchImageLoadEventSoon(HTMLImageLoader*);
     613    void dispatchImageLoadEventSoon(ImageLoader*);
    614614    void dispatchImageLoadEventsNow();
    615     void removeImage(HTMLImageLoader*);
     615    void removeImage(ImageLoader*);
    616616   
    617617    // Returns the owning element in the parent document.
    … …  
    886886    mutable AXObjectCache* m_axObjectCache;
    887887   
    888     DeprecatedPtrList<HTMLImageLoader> m_imageLoadEventDispatchSoonList;
    889     DeprecatedPtrList<HTMLImageLoader> m_imageLoadEventDispatchingList;
     888    DeprecatedPtrList<ImageLoader> m_imageLoadEventDispatchSoonList;
     889    DeprecatedPtrList<ImageLoader> m_imageLoadEventDispatchingList;
    890890    Timer<Document> m_imageLoadEventTimer;
    891891

  • trunk/WebCore/html/HTMLImageLoader.cpp

    r36466 r36712  
    2525#include "CSSHelper.h"
    2626#include "CachedImage.h"
    27 #include "DocLoader.h"
    28 #include "Document.h"
    2927#include "Element.h"
    3028#include "EventNames.h"
    3129#include "HTMLNames.h"
    3230#include "HTMLObjectElement.h"
    33 #include "RenderImage.h"
    34 
    35 using namespace std;
    3631
    3732namespace WebCore {
    3833
    3934using namespace EventNames;
    40 using namespace HTMLNames;
    4135
    42 HTMLImageLoader::HTMLImageLoader(Element* elt)
    43     : m_element(elt)
    44     , m_image(0)
    45     , m_firedLoad(true)
    46     , m_imageComplete(true)
    47     , m_loadManually(false)
     36HTMLImageLoader::HTMLImageLoader(Element* node)
     37    : ImageLoader(node)
    4838{
    4939}
    … …  
    5141HTMLImageLoader::~HTMLImageLoader()
    5242{
    53     if (m_image)
    54         m_image->removeClient(this);
    55     m_element->document()->removeImage(this);
    56 }
    57 
    58 void HTMLImageLoader::setImage(CachedImage *newImage)
    59 {
    60     CachedImage *oldImage = m_image.get();
    61     if (newImage != oldImage) {
    62         setLoadingImage(newImage);
    63         m_firedLoad = true;
    64         m_imageComplete = true;
    65         if (newImage)
    66             newImage->addClient(this);
    67         if (oldImage)
    68             oldImage->removeClient(this);
    69     }
    70 
    71     if (RenderObject* renderer = element()->renderer())
    72         if (renderer->isImage())
    73             static_cast<RenderImage*>(renderer)->resetAnimation();
    74 }
    75 
    76 void HTMLImageLoader::setLoadingImage(CachedImage *loadingImage)
    77 {
    78     m_firedLoad = false;
    79     m_imageComplete = false;
    80     m_image = loadingImage;
    81 }
    82 
    83 void HTMLImageLoader::updateFromElement()
    84 {
    85     // If we're not making renderers for the page, then don't load images.  We don't want to slow
    86     // down the raw HTML parsing case by loading images we don't intend to display.
    87     Element* elem = element();
    88     Document* doc = elem->document();
    89     if (!doc->renderer())
    90         return;
    91 
    92     AtomicString attr = elem->getAttribute(elem->imageSourceAttributeName());
    93    
    94     // Do not load any image if the 'src' attribute is missing or if it is
    95     // an empty string referring to a local file. The latter condition is
    96     // a quirk that preserves old behavior that Dashboard widgets
    97     // need (<rdar://problem/5994621>).
    98     CachedImage *newImage = 0;
    99     if (!(attr.isNull() || attr.isEmpty() && doc->baseURI().isLocalFile())) {
    100         if (m_loadManually) {
    101             doc->docLoader()->setAutoLoadImages(false);
    102             newImage = new CachedImage(parseURL(attr));
    103             newImage->setLoading(true);
    104             newImage->setDocLoader(doc->docLoader());
    105             doc->docLoader()->m_docResources.set(newImage->url(), newImage);
    106         } else
    107             newImage = doc->docLoader()->requestImage(parseURL(attr));
    108     }
    109    
    110     CachedImage *oldImage = m_image.get();
    111     if (newImage != oldImage) {
    112 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
    113         if (!doc->ownerElement() && newImage)
    114             printf("Image requested at %d\n", doc->elapsedTime());
    115 #endif
    116         setLoadingImage(newImage);
    117         if (newImage)
    118             newImage->addClient(this);
    119         if (oldImage)
    120             oldImage->removeClient(this);
    121     }
    122 
    123     if (RenderObject* renderer = elem->renderer())
    124         if (renderer->isImage())
    125             static_cast<RenderImage*>(renderer)->resetAnimation();
    12643}
    12744
    … …  
    13451}
    13552
    136 void HTMLImageLoader::notifyFinished(CachedResource *image)
     53String HTMLImageLoader::sourceURI(const AtomicString& attr) const
    13754{
    138     m_imageComplete = true;
     55    return parseURL(attr);
     56}
     57
     58void HTMLImageLoader::notifyFinished(CachedResource* image)
     59{
    13960    Element* elem = element();
    140     Document* doc = elem->document();
    141     doc->dispatchImageLoadEventSoon(this);
    142 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
    143         if (!doc->ownerElement())
    144             printf("Image loaded at %d\n", doc->elapsedTime());
    145 #endif
    146     if (RenderObject* renderer = elem->renderer())
    147         if (renderer->isImage())
    148             static_cast<RenderImage*>(renderer)->setCachedImage(m_image.get());
    149            
    150     if (image->errorOccurred() && elem->hasTagName(objectTag))
     61    ImageLoader::notifyFinished(image);
     62
     63    if (image->errorOccurred() && elem->hasTagName(HTMLNames::objectTag))
    15164        static_cast<HTMLObjectElement*>(elem)->renderFallbackContent();
    15265}

  • trunk/WebCore/html/HTMLImageLoader.h

    r36109 r36712  
    2626#define HTMLImageLoader_h
    2727
    28 #include "CachedResourceClient.h"
    29 #include "CachedResourceHandle.h"
     28#include "ImageLoader.h"
    3029
    3130namespace WebCore {
    3231
    33 class Element;
    34 
    35 class HTMLImageLoader : public CachedResourceClient {
     32class HTMLImageLoader : public ImageLoader {
    3633public:
    3734    HTMLImageLoader(Element*);
    3835    virtual ~HTMLImageLoader();
    3936
    40     virtual void updateFromElement();
     37    virtual void dispatchLoadEvent();
     38    virtual String sourceURI(const AtomicString&) const;
    4139
    42     virtual void dispatchLoadEvent();
    43 
    44     Element* element() const { return m_element; }
    45     bool imageComplete() const { return m_imageComplete; }
    46 
    47     CachedImage* image() const { return m_image.get(); }
    48     void setImage(CachedImage*);
    49 
    50     void setLoadManually(bool loadManually) { m_loadManually = loadManually; }
    51 
    52     // CachedResourceClient API
    5340    virtual void notifyFinished(CachedResource*);
    54 
    55     bool haveFiredLoadEvent() const { return m_firedLoad; }
    56 protected:
    57     void setLoadingImage(CachedImage*);
    58    
    59     void setHaveFiredLoadEvent(bool firedLoad) { m_firedLoad = firedLoad; }
    60 
    61 private:
    62     Element* m_element;
    63     CachedResourceHandle<CachedImage> m_image;
    64     bool m_firedLoad : 1;
    65     bool m_imageComplete : 1;
    66     bool m_loadManually : 1;
    6741};
    6842
    69 } //namespace
     43}
    7044
    7145#endif

  • trunk/WebCore/loader/DocLoader.h

    r35801 r36712  
    4242class Document;
    4343class Frame;
    44 class HTMLImageLoader;
     44class ImageLoader;
    4545class KURL;
    4646
    … …  
    4949{
    5050friend class Cache;
    51 friend class HTMLImageLoader;
     51friend class ImageLoader;
    5252
    5353public:

  • trunk/WebCore/loader/ImageLoader.cpp

    r36711 r36712  
    2121
    2222#include "config.h"
    23 #include "HTMLImageLoader.h"
     23#include "ImageLoader.h"
    2424
    2525#include "CSSHelper.h"
    … …  
    2929#include "Element.h"
    3030#include "EventNames.h"
    31 #include "HTMLNames.h"
    32 #include "HTMLObjectElement.h"
    3331#include "RenderImage.h"
    34 
    35 using namespace std;
    3632
    3733namespace WebCore {
    3834
    3935using namespace EventNames;
    40 using namespace HTMLNames;
    4136
    42 HTMLImageLoader::HTMLImageLoader(Element* elt)
     37ImageLoader::ImageLoader(Element* elt)
    4338    : m_element(elt)
    4439    , m_image(0)
    … …  
    4944}
    5045
    51 HTMLImageLoader::~HTMLImageLoader()
     46ImageLoader::~ImageLoader()
    5247{
    5348    if (m_image)
    … …  
    5651}
    5752
    58 void HTMLImageLoader::setImage(CachedImage *newImage)
     53void ImageLoader::setImage(CachedImage* newImage)
    5954{
    60     CachedImage *oldImage = m_image.get();
     55    CachedImage* oldImage = m_image.get();
    6156    if (newImage != oldImage) {
    6257        setLoadingImage(newImage);
    … …  
    6964    }
    7065
    71     if (RenderObject* renderer = element()->renderer())
    72         if (renderer->isImage())
    73             static_cast<RenderImage*>(renderer)->resetAnimation();
     66    if (RenderObject* renderer = element()->renderer()) {
     67        if (!renderer->isImage())
     68            return;
     69
     70        static_cast<RenderImage*>(renderer)->resetAnimation();
     71    }
    7472}
    7573
    76 void HTMLImageLoader::setLoadingImage(CachedImage *loadingImage)
     74void ImageLoader::setLoadingImage(CachedImage* loadingImage)
    7775{
    7876    m_firedLoad = false;
    … …  
    8179}
    8280
    83 void HTMLImageLoader::updateFromElement()
     81void ImageLoader::updateFromElement()
    8482{
    8583    // If we're not making renderers for the page, then don't load images.  We don't want to slow
    … …  
    9189
    9290    AtomicString attr = elem->getAttribute(elem->imageSourceAttributeName());
    93    
     91
    9492    // Do not load any image if the 'src' attribute is missing or if it is
    9593    // an empty string referring to a local file. The latter condition is
    9694    // a quirk that preserves old behavior that Dashboard widgets
    9795    // need (<rdar://problem/5994621>).
    98     CachedImage *newImage = 0;
     96    CachedImage* newImage = 0;
    9997    if (!(attr.isNull() || attr.isEmpty() && doc->baseURI().isLocalFile())) {
    10098        if (m_loadManually) {
    10199            doc->docLoader()->setAutoLoadImages(false);
    102             newImage = new CachedImage(parseURL(attr));
     100            newImage = new CachedImage(sourceURI(attr));
    103101            newImage->setLoading(true);
    104102            newImage->setDocLoader(doc->docLoader());
    105103            doc->docLoader()->m_docResources.set(newImage->url(), newImage);
    106104        } else
    107             newImage = doc->docLoader()->requestImage(parseURL(attr));
     105            newImage = doc->docLoader()->requestImage(sourceURI(attr));
    108106    }
    109107   
    110     CachedImage *oldImage = m_image.get();
     108    CachedImage* oldImage = m_image.get();
    111109    if (newImage != oldImage) {
    112 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
    113         if (!doc->ownerElement() && newImage)
    114             printf("Image requested at %d\n", doc->elapsedTime());
    115 #endif
    116110        setLoadingImage(newImage);
    117111        if (newImage)
    … …  
    121115    }
    122116
    123     if (RenderObject* renderer = elem->renderer())
    124         if (renderer->isImage())
    125             static_cast<RenderImage*>(renderer)->resetAnimation();
    126 }
     117    if (RenderObject* renderer = elem->renderer()) {
     118        if (!renderer->isImage())
     119            return;
    127120
    128 void HTMLImageLoader::dispatchLoadEvent()
    129 {
    130     if (!haveFiredLoadEvent() && image()) {
    131         setHaveFiredLoadEvent(true);
    132         element()->dispatchEventForType(image()->errorOccurred() ? errorEvent : loadEvent, false, false);
     121        static_cast<RenderImage*>(renderer)->resetAnimation();
    133122    }
    134123}
    135124
    136 void HTMLImageLoader::notifyFinished(CachedResource *image)
     125void ImageLoader::notifyFinished(CachedResource *image)
    137126{
    138127    m_imageComplete = true;
     128
    139129    Element* elem = element();
    140     Document* doc = elem->document();
    141     doc->dispatchImageLoadEventSoon(this);
    142 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
    143         if (!doc->ownerElement())
    144             printf("Image loaded at %d\n", doc->elapsedTime());
    145 #endif
    146     if (RenderObject* renderer = elem->renderer())
    147         if (renderer->isImage())
    148             static_cast<RenderImage*>(renderer)->setCachedImage(m_image.get());
    149            
    150     if (image->errorOccurred() && elem->hasTagName(objectTag))
    151         static_cast<HTMLObjectElement*>(elem)->renderFallbackContent();
     130    elem->document()->dispatchImageLoadEventSoon(this);
     131
     132    if (RenderObject* renderer = elem->renderer()) {
     133        if (!renderer->isImage())
     134            return;
     135
     136        static_cast<RenderImage*>(renderer)->setCachedImage(m_image.get());
     137    }
    152138}
    153139

  • trunk/WebCore/loader/ImageLoader.h

    r36711 r36712  
    2323 */
    2424
    25 #ifndef HTMLImageLoader_h
    26 #define HTMLImageLoader_h
     25#ifndef ImageLoader_h
     26#define ImageLoader_h
    2727
    2828#include "CachedResourceClient.h"
    … …  
    3131namespace WebCore {
    3232
     33class AtomicString;
    3334class Element;
    3435
    35 class HTMLImageLoader : public CachedResourceClient {
     36class ImageLoader : public CachedResourceClient {
    3637public:
    37     HTMLImageLoader(Element*);
    38     virtual ~HTMLImageLoader();
     38    ImageLoader(Element*);
     39    virtual ~ImageLoader();
    3940
    40     virtual void updateFromElement();
     41    void updateFromElement();
    4142
    42     virtual void dispatchLoadEvent();
     43    virtual void dispatchLoadEvent() = 0;
     44    virtual String sourceURI(const AtomicString&) const = 0;
    4345
    4446    Element* element() const { return m_element; }
    … …  
    6769};
    6870
    69 } //namespace
     71}
    7072
    7173#endif

  • trunk/WebCore/svg/SVGImageElement.cpp

    r35679 r36712  
    132132{
    133133    SVGStyledTransformableElement::attach();
     134
     135    if (RenderSVGImage* imageObj = static_cast<RenderSVGImage*>(renderer())) {
     136        if (imageObj->hasImage())
     137            return;
     138
     139        imageObj->setCachedImage(m_imageLoader.image());
     140    }
     141}
     142
     143void SVGImageElement::insertedIntoDocument()
     144{
     145    SVGStyledTransformableElement::insertedIntoDocument();
     146
     147    // Update image loader, as soon as we're living in the tree.
     148    // We can only resolve base URIs properly, after that!
    134149    m_imageLoader.updateFromElement();
    135     if (RenderSVGImage* imageObj = static_cast<RenderSVGImage*>(renderer()))
    136         imageObj->setCachedImage(m_imageLoader.image());
     150}
     151
     152const QualifiedName& SVGImageElement::imageSourceAttributeName() const
     153{
     154    return XLinkNames::hrefAttr;
    137155}
    138156

  • trunk/WebCore/svg/SVGImageElement.h

    r35248 r36712  
    5252
    5353        virtual void attach();
     54        virtual void insertedIntoDocument();
    5455
    5556        virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    56        
     57 
     58        virtual const QualifiedName& imageSourceAttributeName() const;       
    5759        virtual void getSubresourceAttributeStrings(Vector<String>&) const;
    5860

  • trunk/WebCore/svg/SVGImageLoader.cpp

    r32738 r36712  
    2222
    2323#include "config.h"
     24
    2425#if ENABLE(SVG)
     26#include "SVGImageLoader.h"
    2527
    26 #include "Attr.h"
    27 #include "DocLoader.h"
    28 #include "Document.h"
    29 
     28#include "EventNames.h"
    3029#include "SVGImageElement.h"
    31 #include "SVGLength.h"
    32 #include "SVGNames.h"
    33 
    3430#include "RenderImage.h"
    3531
    … …  
    3733
    3834SVGImageLoader::SVGImageLoader(SVGImageElement* node)
    39     : HTMLImageLoader(node)
     35    : ImageLoader(node)
    4036{
    4137}
    … …  
    4541}
    4642
    47 // FIXME - Refactor most of this code into WebCore::HTMLImageLoader or a shared WebCore::ImageLoader base class
    48 void SVGImageLoader::updateFromElement()
    49 {
    50     SVGImageElement *imageElement = static_cast<SVGImageElement *>(element());
    51     WebCore::Document* doc = imageElement->ownerDocument();
    52    
    53     CachedImage *newImage = 0;
    54     if (!imageElement->href().isEmpty()) {
    55         KURL uri = imageElement->baseURI();
    56         if (!uri.isEmpty())
    57             uri = KURL(uri, imageElement->href());
    58         else
    59             uri = KURL(imageElement->href());
    60         newImage = doc->docLoader()->requestImage(uri.string());
    61     }
    62 
    63     CachedImage* oldImage = image();
    64     if (newImage != oldImage) {
    65         setLoadingImage(newImage);
    66         if (newImage)
    67             newImage->addClient(this);
    68         if (oldImage)
    69             oldImage->removeClient(this);
    70     }
    71 
    72     if (RenderImage* renderer = static_cast<RenderImage*>(imageElement->renderer()))
    73         renderer->resetAnimation();
    74 }
    75 
    7643void SVGImageLoader::dispatchLoadEvent()
    7744{
    7845    if (!haveFiredLoadEvent() && image()) {
    7946        setHaveFiredLoadEvent(true);
    80         if (image()->errorOccurred()) {
    81             // FIXME: We're supposed to put the document in an "error state" per the spec.
    82         } else if (static_cast<SVGImageElement*>(element())->externalResourcesRequiredBaseValue())
    83             static_cast<SVGElement*>(element())->sendSVGLoadEventIfPossible(true);
     47       
     48        if (image()->errorOccurred())
     49            element()->dispatchEventForType(EventNames::errorEvent, false, false);
     50        else {
     51            SVGImageElement* imageElement = static_cast<SVGImageElement*>(element());
     52            if (imageElement->externalResourcesRequiredBaseValue())
     53                imageElement->sendSVGLoadEventIfPossible(true);
     54        }
    8455    }
     56}
     57
     58String SVGImageLoader::sourceURI(const AtomicString& attr) const
     59{
     60    return parseURL(KURL(element()->baseURI(), attr).string());
    8561}
    8662

  • trunk/WebCore/svg/SVGImageLoader.h

    r28258 r36712  
    2222#ifndef SVGImageLoader_h
    2323#define SVGImageLoader_h
     24
    2425#if ENABLE(SVG)
    25 
    26 #include "HTMLImageLoader.h"
     26#include "ImageLoader.h"
    2727
    2828namespace WebCore {
    … …  
    3030    class SVGImageElement;
    3131
    32     class SVGImageLoader : public HTMLImageLoader {
     32    class SVGImageLoader : public ImageLoader {
    3333    public:
    3434        SVGImageLoader(SVGImageElement*);
    3535        virtual ~SVGImageLoader();
    36        
    37         virtual void updateFromElement();
     36
    3837        virtual void dispatchLoadEvent();
     38        virtual String sourceURI(const AtomicString&) const;
    3939    };
    4040
    … …  
    4343#endif // ENABLE(SVG)
    4444#endif // SVGImageLoader_h
    45 
    46 // vim:ts=4:noet
Note: See TracChangeset for help on using the changeset viewer.