Allow eviction of ImageBitmaps that are created from ImageElements.

Source/core/loader/ImageLoader.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2009 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.
  *
  */
 
 #ifndef ImageLoader_h
 #define ImageLoader_h
 
 #include "core/loader/cache/CachedImage.h"
 #include "core/loader/cache/CachedImageClient.h"
 #include "core/loader/cache/CachedResourceHandle.h"
+#include "wtf/HashSet.h"
 #include "wtf/text/AtomicString.h"
 
 namespace WebCore {
 
+class ImageLoaderClient {
+public:
+    virtual void notifyImageSourceChanged() = 0;
+
+    // Notifies whether the observed CachedImage should have higher priority in the decoded resources cache.
+    virtual bool isHighPriorityImageLoaderClient() = 0;

[Justin Novosad, 2013/07/29 15:29:43]

the "ImageLoaderClient" part of themname does not provide any useful
information, and it is not clear form the name that we are referring to cache
priority. Suggestion: requestsHighCachePriority
Also, it is not necessary to make this pure virtual.  Default implementation
should return false.

+
+protected:
+    ImageLoaderClient() { }
+};
+
 class Element;
 class ImageLoader;
 class RenderImageResource;
 
 template<typename T> class EventSender;
 typedef EventSender<ImageLoader> ImageEventSender;
 
 class ImageLoader : public CachedImageClient {
 public:
     explicit ImageLoader(Element*);
@@ skipping 19 matching lines @@
 
     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();
 
+    void addClient(ImageLoaderClient*);
+    void removeClient(ImageLoaderClient*);
+
 protected:
     virtual void notifyFinished(CachedResource*);
 
 private:
     virtual void dispatchLoadEvent() = 0;
     virtual String sourceURI(const AtomicString&) const = 0;
 
     void updatedHasPendingEvent();
 
     void dispatchPendingBeforeLoadEvent();
     void dispatchPendingLoadEvent();
     void dispatchPendingErrorEvent();
 
     RenderImageResource* renderImageResource();
     void updateRenderer();
 
     void setImageWithoutConsideringPendingLoadEvent(CachedImage*);
+    void sourceImageChanged();
     void clearFailedLoadURL();
 
     void timerFired(Timer<ImageLoader>*);
 
     Element* m_element;
     CachedResourceHandle<CachedImage> m_image;
+    HashSet<ImageLoaderClient*> m_clients;
     Timer<ImageLoader> m_derefElementTimer;
     AtomicString m_failedLoadURL;
     bool m_hasPendingBeforeLoadEvent : 1;
     bool m_hasPendingLoadEvent : 1;
     bool m_hasPendingErrorEvent : 1;
     bool m_imageComplete : 1;
     bool m_loadManually : 1;
     bool m_elementIsProtected : 1;
+    unsigned m_highPriorityClientCount;
 };
 
 }
 
 #endif