Simplify CachedResource::data

Source/WebCore/loader/cache/CachedImage.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007 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
@@ skipping 40 matching lines @@
 #include "RuntimeEnabledFeatures.h"
 #endif
 
 using std::max;
 
 namespace WebCore {
 
 CachedImage::CachedImage(const ResourceRequest& resourceRequest)
     : CachedResource(resourceRequest, ImageResource)
     , m_image(0)
+    , m_loadingMultipartContent(false)
 {
     setStatus(Unknown);
     setCustomAcceptHeader();
 }
 
 CachedImage::CachedImage(Image* image)
     : CachedResource(ResourceRequest(), ImageResource)
     , m_image(image)
 {
     setStatus(Cached);
@@ skipping 263 matching lines @@
 
 inline void CachedImage::clearImage()
 {
     // If our Image has an observer, it's always us so we need to clear the back pointer
     // before dropping our reference.
     if (m_image)
         m_image->setImageObserver(0);
     m_image.clear();
 }
 
-void CachedImage::data(PassRefPtr<ResourceBuffer> data, bool allDataReceived)
+void CachedImage::data(PassRefPtr<ResourceBuffer> data)
 {
-    m_data = data;
+    CachedResource::data(data);
+    if (!m_loadingMultipartContent)
+        updateImage(false);
+}
 
+void CachedImage::updateImage(bool allDataReceived)
+{
     if (m_data)
         createImage();
 
     bool sizeAvailable = false;
 
     // Have the image update its data from its internal buffer.
     // It will not do anything now, but will delay decoding until 
     // queried for info (like size or specific image frames).
     if (m_image)
         sizeAvailable = m_image->setData(m_data ? m_data->sharedBuffer() : 0, allDataReceived);
 
     // Go ahead and tell our observers to try to draw if we have either
     // received all the data or the size is known.  Each chunk from the
     // network causes observers to repaint, which will force that chunk
     // to decode.
     if (sizeAvailable || allDataReceived) {
         if (!m_image || m_image->isNull()) {
             error(errorOccurred() ? status() : DecodeError);
             if (inCache())
                 memoryCache()->remove(this);
             return;
         }
         
         // It would be nice to only redraw the decoded band of the image, but with the current design
         // (decoding delayed until painting) that seems hard.
         notifyObservers();
+    }
+}
 
-        if (m_image)
-            setEncodedSize(m_image->data() ? m_image->data()->size() : 0);
-    }
-    
-    if (allDataReceived) {
-        setLoading(false);
-        checkNotify();
-    }
+void CachedImage::finishOnePart()
+{
+    updateImage(true);
+    CachedResource::finishOnePart();
 }
 
 void CachedImage::error(CachedResource::Status status)
 {
     clear();
     CachedResource::error(status);
     notifyObservers();
 }
 
 void CachedImage::responseReceived(const ResourceResponse& response)
 {
     if (!m_response.isNull())
         clear();
+    if (response.isMultipart())
+        m_loadingMultipartContent = true;
     CachedResource::responseReceived(response);
 }
 
 void CachedImage::destroyDecodedData()
 {
     bool canDeleteImage = !m_image || (m_image->hasOneRef() && m_image->isBitmapImage());
     if (isSafeToMakePurgeable() && canDeleteImage && !isLoading()) {
         // Image refs the data buffer so we should not make it purgeable while the image is alive. 
         // Invoking addClient() will reconstruct the image object.
         m_image = 0;
@@ skipping 66 matching lines @@
 
 bool CachedImage::currentFrameKnownToBeOpaque(const RenderObject* renderer)
 {
     Image* image = imageForRenderer(renderer);
     if (image->isBitmapImage())
         image->nativeImageForCurrentFrame(); // force decode
     return image->currentFrameKnownToBeOpaque();
 }
 
 } // namespace WebCore