webengine/osswebengine/WebCore/loader/CachedImage.cpp
changeset 13 10e98eab6f85
parent 0 dd21522fd290
child 16 a359256acfc6
equal deleted inserted replaced
8:7c90e6132015 13:10e98eab6f85
    46 
    46 
    47 using std::max;
    47 using std::max;
    48 
    48 
    49 namespace WebCore {
    49 namespace WebCore {
    50 
    50 
    51 CachedImage::CachedImage(DocLoader* docLoader, const String& url, bool forCache)
    51 CachedImage::CachedImage(const String& url)
    52     : CachedResource(url, ImageResource, forCache)
    52     : CachedResource(url, ImageResource)
    53 {
    53 {
    54     m_image = 0;
    54     m_image = 0;
    55     m_status = Unknown;
    55     m_status = Unknown;
    56     if (!docLoader || docLoader->autoLoadImages())  {
       
    57         m_loading = true;
       
    58         cache()->loader()->load(docLoader, this, true);
       
    59     } else
       
    60         m_loading = false;
       
    61 }
    56 }
    62 
    57 
    63 CachedImage::CachedImage(Image* image)
    58 CachedImage::CachedImage(Image* image)
    64     : CachedResource(String(), ImageResource, false /* not for cache */)
    59     : CachedResource(String(), ImageResource)
    65 {
    60 {
    66     m_image = image;
    61     m_image = image;
    67     m_status = Cached;
    62     m_status = Cached;
    68     m_loading = false;
    63     m_loading = false;
    69 }
    64 }
    71 CachedImage::~CachedImage()
    66 CachedImage::~CachedImage()
    72 {
    67 {
    73     delete m_image;
    68     delete m_image;
    74 }
    69 }
    75 
    70 
       
    71 void CachedImage::load(DocLoader* docLoader) 
       
    72 { 
       
    73     if (!docLoader || docLoader->autoLoadImages()) 
       
    74         CachedResource::load(docLoader, true, false, true); 
       
    75     else 
       
    76         m_loading = false; 
       
    77 } 
       
    78 
    76 void CachedImage::ref(CachedResourceClient* c)
    79 void CachedImage::ref(CachedResourceClient* c)
    77 {
    80 {
    78     CachedResource::ref(c);
    81     CachedResource::ref(c);
    79 
    82 
    80     if (!imageRect().isEmpty())
    83     if (!imageRect().isEmpty())
    90         m_image->resetAnimation();
    93         m_image->resetAnimation();
    91 }
    94 }
    92 
    95 
    93 static Image* brokenImage()
    96 static Image* brokenImage()
    94 {
    97 {
    95     static Image* brokenImage;
    98     static OwnPtr<Image*> brokenImage;
    96     if (!brokenImage)
    99     if (!brokenImage) {
    97         brokenImage = Image::loadPlatformResource("missingImage");
   100         brokenImage.set(Image::loadPlatformResource("missingImage"));
    98     return brokenImage;
   101     }
       
   102     Image* ret = brokenImage.get();
       
   103     return ret;
    99 }
   104 }
   100 
   105 
   101 static Image* nullImage()
   106 static Image* nullImage()
   102 {
   107 {
   103     static BitmapImage nullImage;
   108     static BitmapImage nullImage;
   295 
   300 
   296 void CachedImage::animationFrameReady(int size_)
   301 void CachedImage::animationFrameReady(int size_)
   297 {
   302 {
   298     setDecodedSize(size_);
   303     setDecodedSize(size_);
   299     notifyObservers();
   304     notifyObservers();
       
   305 	checkNotify();
   300 }
   306 }
   301 
   307 
   302 void CachedImage::setMimeType(const String& mime_)
   308 void CachedImage::setMimeType(const String& mime_)
   303 {
   309 {
   304     m_response.setMimeType(mime_);
   310     m_response.setMimeType(mime_);