Split headerValueForVary into specialized functions for NetworkProcess and WebProcess...
[WebKit-https.git] / Source / WebCore / loader / ImageLoader.h
index c603e00..bd4ba9e 100644 (file)
  *
  */
 
-#ifndef ImageLoader_h
-#define ImageLoader_h
+#pragma once
 
-#include "CachedResourceClient.h"
+#include "CachedImageClient.h"
 #include "CachedResourceHandle.h"
+#include "JSDOMPromiseDeferred.h"
+#include "Timer.h"
+#include <wtf/Vector.h>
 #include <wtf/text/AtomicString.h>
 
 namespace WebCore {
 
 class Element;
-class ImageLoadEventSender;
+class ImageLoader;
 class RenderImageResource;
 
-class ImageLoader : public CachedResourceClient {
+template<typename T> class EventSender;
+typedef EventSender<ImageLoader> ImageEventSender;
+
+class ImageLoader : public CachedImageClient {
+    WTF_MAKE_FAST_ALLOCATED;
 public:
-    ImageLoader(Element*);
     virtual ~ImageLoader();
 
     // This function should be called when the element is attached to a document; starts
@@ -46,46 +51,67 @@ public:
     // doesn't change; starts new load unconditionally (matches Firefox and Opera behavior).
     void updateFromElementIgnoringPreviousError();
 
-    void elementWillMoveToNewOwnerDocument();
+    void elementDidMoveToNewDocument();
+
+    Element& element() { return m_element; }
+    const Element& element() const { return m_element; }
 
-    Element* element() const { return m_element; }
     bool imageComplete() const { return m_imageComplete; }
 
     CachedImage* image() const { return m_image.get(); }
-    void setImage(CachedImage*); // Cancels pending beforeload and load events, and doesn't dispatch new ones.
+    void clearImage(); // Cancels pending beforeload and load events, and doesn't dispatch new ones.
+    
+    void decode(Ref<DeferredPromise>&&);
 
     void setLoadManually(bool loadManually) { m_loadManually = loadManually; }
 
-    bool haveFiredBeforeLoadEvent() const { return m_firedBeforeLoad; }
-    bool haveFiredLoadEvent() const { return m_firedLoad; }
-    bool hasPendingLoadEvent();
+    bool hasPendingBeforeLoadEvent() const { return m_hasPendingBeforeLoadEvent; }
+    bool hasPendingActivity() const { return m_hasPendingLoadEvent || m_hasPendingErrorEvent; }
+
+    void dispatchPendingEvent(ImageEventSender*);
 
     static void dispatchPendingBeforeLoadEvents();
     static void dispatchPendingLoadEvents();
+    static void dispatchPendingErrorEvents();
 
 protected:
-    virtual void notifyFinished(CachedResource*);
+    explicit ImageLoader(Element&);
+    void notifyFinished(CachedResource&) override;
 
 private:
     virtual void dispatchLoadEvent() = 0;
     virtual String sourceURI(const AtomicString&) const = 0;
 
-    friend class ImageEventSender;
+    void updatedHasPendingEvent();
+
     void dispatchPendingBeforeLoadEvent();
     void dispatchPendingLoadEvent();
+    void dispatchPendingErrorEvent();
 
     RenderImageResource* renderImageResource();
     void updateRenderer();
 
-    Element* m_element;
+    void clearImageWithoutConsideringPendingLoadEvent();
+    void clearFailedLoadURL();
+
+    bool hasPendingDecodePromises() const { return !m_decodingPromises.isEmpty(); }
+    void decodeError(const char*);
+    void decode();
+    
+    void timerFired();
+
+    Element& m_element;
     CachedResourceHandle<CachedImage> m_image;
+    Timer m_derefElementTimer;
+    RefPtr<Element> m_protectedElement;
     AtomicString m_failedLoadURL;
-    bool m_firedBeforeLoad : 1;
-    bool m_firedLoad : 1;
+    Vector<RefPtr<DeferredPromise>, 1> m_decodingPromises;
+    bool m_hasPendingBeforeLoadEvent : 1;
+    bool m_hasPendingLoadEvent : 1;
+    bool m_hasPendingErrorEvent : 1;
     bool m_imageComplete : 1;
     bool m_loadManually : 1;
+    bool m_elementIsProtected : 1;
 };
 
 }
-
-#endif