Changeset 151586 in webkit


Ignore:
Timestamp:
Jun 14, 2013 3:59:11 AM (11 years ago)
Author:
Carlos Garcia Campos
Message:

Avoid unnecessary data copies when loading subresources with DoNotBufferData option
​https://bugs.webkit.org/show_bug.cgi?id=115804

Reviewed by Darin Adler.

When DoNotBufferData option is used to load a resource its data
is always copied before sending it to the CachedResource. Most
of the cached resources ignore the incremental data and wait
until all data has been received to save the ResourceBuffer,
that will be NULL anyway when DoNotBufferData is used.
CachedRawResource notifies its clients about the incremental
data, but it doesn't save the data when DoNotBufferData option
is present. In those cases we are unnecessary copying the data.

CachedResource::data has been split into
CachedResource::addDataBuffer() used for incremental data chunks
when buffering data, CachedResource::addData() used for
incremental data chunks when not buffering and
CachedResource::finishLoading() used to finish the loading. This
way we get rid of the allDataReceived boolean parameter and cached
resources not interested in incremenetal data chunks only have to
implement finishLoading() without having to check if all data have
been received or not.

SubresourceLoader::sendDataToResource was always called after
checking if loading multipart content, and then it was checked
again to decided whether to copy the data or not. It has been
removed in favor of calling directly the resource methods,
finishLoading for multipart content, addDataBuffer for data chunks
when buffering and addData for data chunks when not buffering.

No new functionality, covered by existing tests.

  • html/ImageDocument.cpp:

(WebCore::ImageDocumentParser::appendBytes): Update to API changes.
(WebCore::ImageDocumentParser::finish): Ditto.

  • loader/SubresourceLoader.cpp:

(WebCore::SubresourceLoader::didReceiveResponse): Call
finishLoading() for multipart content.
(WebCore::SubresourceLoader::didReceiveDataOrBuffer): Add data to
the resource using addDataBuffer or addData depending on whether
we are buffering or not.
(WebCore::SubresourceLoader::didFinishLoading): Call
finishLoading() for the cached resource instead of data.

  • loader/SubresourceLoader.h:
  • loader/cache/CachedCSSStyleSheet.cpp:

(WebCore::CachedCSSStyleSheet::finishLoading):

  • loader/cache/CachedCSSStyleSheet.h:
  • loader/cache/CachedFont.cpp:

(WebCore::CachedFont::finishLoading):

  • loader/cache/CachedFont.h:
  • loader/cache/CachedImage.cpp:

(WebCore::CachedImage::isValidDecodedImageSize): Helper function
to check if the image size is valid.
(WebCore::CachedImage::addIncrementalDataBuffer): Helper function
to add incremental data buffer.
(WebCore::CachedImage::addDataBuffer): Call
addIncrementalDataBuffer().
(WebCore::CachedImage::addData): Create a ResourceBuffer and call
addIncrementalDataBuffer().
(WebCore::CachedImage::finishLoading):

  • loader/cache/CachedImage.h:
  • loader/cache/CachedRawResource.cpp:

(WebCore::CachedRawResource::calculateIncrementalDataChunk):
Returns a pointer to the data corresponding to the current chunk
and its length.
(WebCore::CachedRawResource::addDataBuffer): Assert to make sure
this is only called when BufferData option is present. Use
calculateIncrementalDataChunk().
(WebCore::CachedRawResource::addData): Assert to make sure this is
only called when DoNotBufferData option is present.
(WebCore::CachedRawResource::finishLoading):
(WebCore::CachedRawResource::notifyClientsDataWasReceived): Helper
private function to notify the clients about data received.

  • loader/cache/CachedRawResource.h:
  • loader/cache/CachedResource.cpp:

(WebCore::CachedResource::addDataBuffer):
(WebCore::CachedResource::addData):
(WebCore::CachedResource::finishLoading):

  • loader/cache/CachedResource.h:
  • loader/cache/CachedSVGDocument.cpp:

(WebCore::CachedSVGDocument::finishLoading):

  • loader/cache/CachedSVGDocument.h:
  • loader/cache/CachedScript.cpp:

(WebCore::CachedScript::finishLoading):

  • loader/cache/CachedScript.h:
  • loader/cache/CachedShader.cpp:

(WebCore::CachedShader::finishLoading):

  • loader/cache/CachedShader.h:
  • loader/cache/CachedTextTrack.cpp:

(WebCore::CachedTextTrack::addDataBuffer):
(WebCore::CachedTextTrack::finishLoading):

  • loader/cache/CachedTextTrack.h:
  • loader/cache/CachedXSLStyleSheet.cpp:

(WebCore::CachedXSLStyleSheet::finishLoading):

  • loader/cache/CachedXSLStyleSheet.h:
Location:
trunk/Source/WebCore
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r151582 r151586  
     12013-06-13  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        Avoid unnecessary data copies when loading subresources with DoNotBufferData option
     4        https://bugs.webkit.org/show_bug.cgi?id=115804
     5
     6        Reviewed by Darin Adler.
     7
     8        When DoNotBufferData option is used to load a resource its data
     9        is always copied before sending it to the CachedResource. Most
     10        of the cached resources ignore the incremental data and wait
     11        until all data has been received to save the ResourceBuffer,
     12        that will be NULL anyway when DoNotBufferData is used.
     13        CachedRawResource notifies its clients about the incremental
     14        data, but it doesn't save the data when DoNotBufferData option
     15        is present. In those cases we are unnecessary copying the data.
     16
     17        CachedResource::data has been split into
     18        CachedResource::addDataBuffer() used for incremental data chunks
     19        when buffering data, CachedResource::addData() used for
     20        incremental data chunks when not buffering and
     21        CachedResource::finishLoading() used to finish the loading. This
     22        way we get rid of the allDataReceived boolean parameter and cached
     23        resources not interested in incremenetal data chunks only have to
     24        implement finishLoading() without having to check if all data have
     25        been received or not.
     26
     27        SubresourceLoader::sendDataToResource was always called after
     28        checking if loading multipart content, and then it was checked
     29        again to decided whether to copy the data or not. It has been
     30        removed in favor of calling directly the resource methods,
     31        finishLoading for multipart content, addDataBuffer for data chunks
     32        when buffering and addData for data chunks when not buffering.
     33
     34        No new functionality, covered by existing tests.
     35
     36        * html/ImageDocument.cpp:
     37        (WebCore::ImageDocumentParser::appendBytes): Update to API changes.
     38        (WebCore::ImageDocumentParser::finish): Ditto.
     39        * loader/SubresourceLoader.cpp:
     40        (WebCore::SubresourceLoader::didReceiveResponse): Call
     41        finishLoading() for multipart content.
     42        (WebCore::SubresourceLoader::didReceiveDataOrBuffer): Add data to
     43        the resource using addDataBuffer or addData depending on whether
     44        we are buffering or not.
     45        (WebCore::SubresourceLoader::didFinishLoading): Call
     46        finishLoading() for the cached resource instead of data.
     47        * loader/SubresourceLoader.h:
     48        * loader/cache/CachedCSSStyleSheet.cpp:
     49        (WebCore::CachedCSSStyleSheet::finishLoading):
     50        * loader/cache/CachedCSSStyleSheet.h:
     51        * loader/cache/CachedFont.cpp:
     52        (WebCore::CachedFont::finishLoading):
     53        * loader/cache/CachedFont.h:
     54        * loader/cache/CachedImage.cpp:
     55        (WebCore::CachedImage::isValidDecodedImageSize): Helper function
     56        to check if the image size is valid.
     57        (WebCore::CachedImage::addIncrementalDataBuffer): Helper function
     58        to add incremental data buffer.
     59        (WebCore::CachedImage::addDataBuffer): Call
     60        addIncrementalDataBuffer().
     61        (WebCore::CachedImage::addData): Create a ResourceBuffer and call
     62        addIncrementalDataBuffer().
     63        (WebCore::CachedImage::finishLoading):
     64        * loader/cache/CachedImage.h:
     65        * loader/cache/CachedRawResource.cpp:
     66        (WebCore::CachedRawResource::calculateIncrementalDataChunk):
     67        Returns a pointer to the data corresponding to the current chunk
     68        and its length.
     69        (WebCore::CachedRawResource::addDataBuffer): Assert to make sure
     70        this is only called when BufferData option is present. Use
     71        calculateIncrementalDataChunk().
     72        (WebCore::CachedRawResource::addData): Assert to make sure this is
     73        only called when DoNotBufferData option is present.
     74        (WebCore::CachedRawResource::finishLoading):
     75        (WebCore::CachedRawResource::notifyClientsDataWasReceived): Helper
     76        private function to notify the clients about data received.
     77        * loader/cache/CachedRawResource.h:
     78        * loader/cache/CachedResource.cpp:
     79        (WebCore::CachedResource::addDataBuffer):
     80        (WebCore::CachedResource::addData):
     81        (WebCore::CachedResource::finishLoading):
     82        * loader/cache/CachedResource.h:
     83        * loader/cache/CachedSVGDocument.cpp:
     84        (WebCore::CachedSVGDocument::finishLoading):
     85        * loader/cache/CachedSVGDocument.h:
     86        * loader/cache/CachedScript.cpp:
     87        (WebCore::CachedScript::finishLoading):
     88        * loader/cache/CachedScript.h:
     89        * loader/cache/CachedShader.cpp:
     90        (WebCore::CachedShader::finishLoading):
     91        * loader/cache/CachedShader.h:
     92        * loader/cache/CachedTextTrack.cpp:
     93        (WebCore::CachedTextTrack::addDataBuffer):
     94        (WebCore::CachedTextTrack::finishLoading):
     95        * loader/cache/CachedTextTrack.h:
     96        * loader/cache/CachedXSLStyleSheet.cpp:
     97        (WebCore::CachedXSLStyleSheet::finishLoading):
     98        * loader/cache/CachedXSLStyleSheet.h:
     99
    11002013-06-14  Michał Pakuła vel Rutka  <m.pakula@samsung.com>
    2101

  • trunk/Source/WebCore/html/ImageDocument.cpp

    r151277 r151586  
    137137    CachedImage* cachedImage = document()->cachedImage();
    138138    RefPtr<ResourceBuffer> resourceData = frame->loader()->documentLoader()->mainResourceData();
    139     cachedImage->data(resourceData.get(), false);
     139    cachedImage->addDataBuffer(resourceData.get());
    140140
    141141    document()->imageUpdated();
    … …  
    153153            data = data->copy();
    154154
    155         cachedImage->data(data.get(), true);
     155        cachedImage->finishLoading(data.get());
    156156        cachedImage->finish();
    157157

  • trunk/Source/WebCore/loader/SubresourceLoader.cpp

    r151277 r151586  
    206206    RefPtr<ResourceBuffer> buffer = resourceData();
    207207    if (m_loadingMultipartContent && buffer && buffer->size()) {
    208         sendDataToResource(buffer->data(), buffer->size());
     208        m_resource->finishLoading(buffer.get());
    209209        clearResourceData();
    210210        // Since a subresource loader does not load multipart sections progressively, data was delivered to the loader all at once.       
    … …  
    241241    ResourceLoader::didReceiveDataOrBuffer(data, length, buffer, encodedDataLength, dataPayloadType);
    242242
    243     if (!m_loadingMultipartContent)
    244         sendDataToResource(buffer ? buffer->data() : data, buffer ? buffer->size() : length);
     243    if (!m_loadingMultipartContent) {
     244        if (ResourceBuffer* resourceData = this->resourceData())
     245            m_resource->addDataBuffer(resourceData);
     246        else
     247            m_resource->addData(buffer ? buffer->data() : data, buffer ? buffer->size() : length);
     248    }
    245249}
    246250
    … …  
    257261}
    258262
    259 void SubresourceLoader::sendDataToResource(const char* data, int length)
    260 {
    261     // There are two cases where we might need to create our own SharedBuffer instead of copying the one in ResourceLoader.
    262     // (1) Multipart content: The loader delivers the data in a multipart section all at once, then sends eof.
    263     //     The resource data will change as the next part is loaded, so we need to make a copy.
    264     // (2) Our client requested that the data not be buffered at the ResourceLoader level via ResourceLoaderOptions. In this case,
    265     //     ResourceLoader::resourceData() will be null. However, unlike the multipart case, we don't want to tell the CachedResource
    266     //     that all data has been received yet.
    267     if (m_loadingMultipartContent || !resourceData()) {
    268         RefPtr<ResourceBuffer> copiedData = ResourceBuffer::create(data, length);
    269         m_resource->data(copiedData.get(), m_loadingMultipartContent);
    270     } else
    271         m_resource->data(resourceData(), false);
    272 }
    273 
    274263void SubresourceLoader::didFinishLoading(double finishTime)
    275264{
    … …  
    286275    m_activityAssertion.clear();
    287276    m_resource->setLoadFinishTime(finishTime);
    288     m_resource->data(resourceData(), true);
     277    m_resource->finishLoading(resourceData());
    289278
    290279    if (wasCancelled())

  • trunk/Source/WebCore/loader/SubresourceLoader.h

    r151193 r151586  
    7575
    7676    bool checkForHTTPStatusCodeError();
    77     void sendDataToResource(const char*, int);
    7877
    7978    void didReceiveDataOrBuffer(const char*, int, PassRefPtr<SharedBuffer>, long long encodedDataLength, DataPayloadType);

  • trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp

    r151277 r151586  
    9494}
    9595
    96 void CachedCSSStyleSheet::data(ResourceBuffer* data, bool allDataReceived)
     96void CachedCSSStyleSheet::finishLoading(ResourceBuffer* data)
    9797{
    98     if (!allDataReceived)
    99         return;
    100 
    10198    m_data = data;
    10299    setEncodedSize(m_data.get() ? m_data->size() : 0);

  • trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.h

    r151310 r151586  
    5656        virtual void setEncoding(const String&) OVERRIDE;
    5757        virtual String encoding() const OVERRIDE;
    58         virtual void data(ResourceBuffer*, bool allDataReceived) OVERRIDE;
     58        virtual void finishLoading(ResourceBuffer*) OVERRIDE;
    5959        virtual void destroyDecodedData() OVERRIDE;
    6060

  • trunk/Source/WebCore/loader/cache/CachedFont.cpp

    r151277 r151586  
    7676}
    7777
    78 void CachedFont::data(ResourceBuffer* data, bool allDataReceived)
     78void CachedFont::finishLoading(ResourceBuffer* data)
    7979{
    80     if (!allDataReceived)
    81         return;
    82 
    8380    m_data = data;
    8481    setEncodedSize(m_data.get() ? m_data->size() : 0);

  • trunk/Source/WebCore/loader/cache/CachedFont.h

    r151310 r151586  
    6464
    6565    virtual void didAddClient(CachedResourceClient*) OVERRIDE;
    66     virtual void data(ResourceBuffer*, bool allDataReceived) OVERRIDE;
     66    virtual void finishLoading(ResourceBuffer*) OVERRIDE;
    6767
    6868    virtual void allClientsRemoved() OVERRIDE;

  • trunk/Source/WebCore/loader/cache/CachedImage.cpp

    r151277 r151586  
    345345}
    346346
    347 size_t CachedImage::maximumDecodedImageSize()
    348 {
     347bool CachedImage::canBeDrawn() const
     348{
     349    if (!m_image || m_image->isNull())
     350        return false;
     351
    349352    if (!m_loader || m_loader->reachedTerminalState())
    350         return 0;
     353        return true;
     354
    351355    Settings* settings = m_loader->frameLoader()->frame()->settings();
    352     return settings ? settings->maximumDecodedImageSize() : 0;
    353 }
    354 
    355 void CachedImage::data(ResourceBuffer* data, bool allDataReceived)
     356    if (!settings)
     357        return true;
     358
     359    size_t estimatedDecodedImageSize = m_image->width() * m_image->height() * 4; // no overflow check
     360    return estimatedDecodedImageSize <= settings->maximumDecodedImageSize();
     361}
     362
     363void CachedImage::addIncrementalDataBuffer(ResourceBuffer* data)
    356364{
    357365    m_data = data;
    358 
    359     if (m_data)
     366    if (!data)
     367        return;
     368
     369    createImage();
     370
     371    // Have the image update its data from its internal buffer.
     372    // It will not do anything now, but will delay decoding until
     373    // queried for info (like size or specific image frames).
     374    bool sizeAvailable = m_image->setData(m_data->sharedBuffer(), false);
     375    if (!sizeAvailable)
     376        return;
     377
     378    if (!canBeDrawn()) {
     379        // There's no image to draw or its decoded size is bigger than the maximum allowed.
     380        error(errorOccurred() ? status() : DecodeError);
     381        if (inCache())
     382            memoryCache()->remove(this);
     383        return;
     384    }
     385
     386    // Go ahead and tell our observers to try to draw.
     387    // Each chunk from the network causes observers to repaint, which will
     388    // force that chunk to decode.
     389    // It would be nice to only redraw the decoded band of the image, but with the current design
     390    // (decoding delayed until painting) that seems hard.
     391    notifyObservers();
     392
     393    setEncodedSize(m_image->data() ? m_image->data()->size() : 0);
     394}
     395
     396void CachedImage::addDataBuffer(ResourceBuffer* data)
     397{
     398    ASSERT(m_options.dataBufferingPolicy == BufferData);
     399    addIncrementalDataBuffer(data);
     400}
     401
     402void CachedImage::addData(const char* data, unsigned length)
     403{
     404    ASSERT(m_options.dataBufferingPolicy == DoNotBufferData);
     405    addIncrementalDataBuffer(ResourceBuffer::create(data, length).get());
     406}
     407
     408void CachedImage::finishLoading(ResourceBuffer* data)
     409{
     410    m_data = data;
     411    if (!m_image && data)
    360412        createImage();
    361413
    362     bool sizeAvailable = false;
    363 
    364     // Have the image update its data from its internal buffer.
    365     // It will not do anything now, but will delay decoding until
    366     // queried for info (like size or specific image frames).
    367     if (m_image)
    368         sizeAvailable = m_image->setData(m_data ? m_data->sharedBuffer() : 0, allDataReceived);
    369 
    370     // Go ahead and tell our observers to try to draw if we have either
    371     // received all the data or the size is known.  Each chunk from the
    372     // network causes observers to repaint, which will force that chunk
    373     // to decode.
    374     if (sizeAvailable || allDataReceived) {
    375         size_t maxDecodedImageSize = maximumDecodedImageSize();
    376         IntSize s = m_image ? m_image->size() : IntSize();
    377         size_t estimatedDecodedImageSize = s.width() * s.height() * 4; // no overflow check
    378         if (!m_image || m_image->isNull() || (maxDecodedImageSize > 0 && estimatedDecodedImageSize > maxDecodedImageSize)) {
    379             error(errorOccurred() ? status() : DecodeError);
    380             if (inCache())
    381                 memoryCache()->remove(this);
    382             return;
    383         }
    384        
    385         // It would be nice to only redraw the decoded band of the image, but with the current design
    386         // (decoding delayed until painting) that seems hard.
    387         notifyObservers();
    388 
    389         if (m_image)
    390             setEncodedSize(m_image->data() ? m_image->data()->size() : 0);
    391     }
    392    
    393     if (allDataReceived) {
    394         setLoading(false);
    395         checkNotify();
    396     }
     414    if (m_image)
     415        m_image->setData(m_data->sharedBuffer(), true);
     416
     417    if (!canBeDrawn()) {
     418        // There's no image to draw or its decoded size is bigger than the maximum allowed.
     419        error(errorOccurred() ? status() : DecodeError);
     420        if (inCache())
     421            memoryCache()->remove(this);
     422        return;
     423    }
     424
     425    notifyObservers();
     426    if (m_image)
     427        setEncodedSize(m_image->data() ? m_image->data()->size() : 0);
     428    CachedResource::finishLoading(data);
    397429}
    398430

  • trunk/Source/WebCore/loader/cache/CachedImage.h

    r151310 r151586  
    6565    bool imageHasRelativeHeight() const;
    6666
    67     virtual void data(ResourceBuffer*, bool allDataReceived) OVERRIDE;
     67    virtual void addDataBuffer(ResourceBuffer*) OVERRIDE;
     68    virtual void finishLoading(ResourceBuffer*) OVERRIDE;
    6869
    6970    // This method takes a zoom multiplier that can be used to increase the natural size of the image by the zoom.
    … …  
    8081    void createImage();
    8182    void clearImage();
    82     size_t maximumDecodedImageSize();
     83    bool canBeDrawn() const;
    8384    // If not null, changeRect is the changed part of the image.
    8485    void notifyObservers(const IntRect* changeRect = 0);
    … …  
    9596    virtual void destroyDecodedData() OVERRIDE;
    9697
     98    virtual void addData(const char* data, unsigned length) OVERRIDE;
    9799    virtual void error(CachedResource::Status) OVERRIDE;
    98100    virtual void responseReceived(const ResourceResponse&) OVERRIDE;
    … …  
    112114    virtual void changedInRect(const Image*, const IntRect&) OVERRIDE;
    113115
     116    void addIncrementalDataBuffer(ResourceBuffer*);
     117
    114118    typedef pair<IntSize, float> SizeAndZoom;
    115119    typedef HashMap<const CachedImageClient*, SizeAndZoom> ContainerSizeRequests;

  • trunk/Source/WebCore/loader/cache/CachedRawResource.cpp

    r151277 r151586  
    4242}
    4343
    44 void CachedRawResource::data(ResourceBuffer* data, bool allDataReceived)
    45 {
    46     CachedResourceHandle<CachedRawResource> protect(this);
    47     const char* incrementalData = 0;
    48     size_t incrementalDataLength = 0;
    49     if (data) {
    50         // If we are buffering data, then we are saving the buffer in m_data and need to manually
    51         // calculate the incremental data. If we are not buffering, then m_data will be null and
    52         // the buffer contains only the incremental data.
    53         size_t previousDataLength = (m_options.dataBufferingPolicy == BufferData) ? encodedSize() : 0;
    54         ASSERT(data->size() >= previousDataLength);
    55         incrementalData = data->data() + previousDataLength;
    56         incrementalDataLength = data->size() - previousDataLength;
    57     }
    58 
    59     if (m_options.dataBufferingPolicy == BufferData) {
     44const char* CachedRawResource::calculateIncrementalDataChunk(ResourceBuffer* data, unsigned& incrementalDataLength)
     45{
     46    incrementalDataLength = 0;
     47    if (!data)
     48        return 0;
     49
     50    unsigned previousDataLength = encodedSize();
     51    ASSERT(data->size() >= previousDataLength);
     52    incrementalDataLength = data->size() - previousDataLength;
     53    return data->data() + previousDataLength;
     54}
     55
     56void CachedRawResource::addDataBuffer(ResourceBuffer* data)
     57{
     58    CachedResourceHandle<CachedRawResource> protect(this);
     59    ASSERT(m_options.dataBufferingPolicy == BufferData);
     60    m_data = data;
     61
     62    unsigned incrementalDataLength;
     63    const char* incrementalData = calculateIncrementalDataChunk(data, incrementalDataLength);
     64    if (data)
     65        setEncodedSize(data->size());
     66    notifyClientsDataWasReceived(incrementalData, incrementalDataLength);
     67    if (m_options.dataBufferingPolicy == DoNotBufferData) {
     68        if (m_loader)
     69            m_loader->setDataBufferingPolicy(DoNotBufferData);
     70        clear();
     71    }
     72}
     73
     74void CachedRawResource::addData(const char* data, unsigned length)
     75{
     76    ASSERT(m_options.dataBufferingPolicy == DoNotBufferData);
     77    notifyClientsDataWasReceived(data, length);
     78}
     79
     80void CachedRawResource::finishLoading(ResourceBuffer* data)
     81{
     82    CachedResourceHandle<CachedRawResource> protect(this);
     83    DataBufferingPolicy dataBufferingPolicy = m_options.dataBufferingPolicy;
     84    if (dataBufferingPolicy == BufferData) {
     85        m_data = data;
     86
     87        unsigned incrementalDataLength;
     88        const char* incrementalData = calculateIncrementalDataChunk(data, incrementalDataLength);
    6089        if (data)
    6190            setEncodedSize(data->size());
    62         m_data = data;
    63     }
    64 
    65     DataBufferingPolicy dataBufferingPolicy = m_options.dataBufferingPolicy;
    66     if (incrementalDataLength) {
    67         CachedResourceClientWalker<CachedRawResourceClient> w(m_clients);
    68         while (CachedRawResourceClient* c = w.next())
    69             c->dataReceived(this, incrementalData, incrementalDataLength);
    70     }
    71     CachedResource::data(data, allDataReceived);
    72 
     91        notifyClientsDataWasReceived(incrementalData, incrementalDataLength);
     92    }
     93
     94    CachedResource::finishLoading(data);
    7395    if (dataBufferingPolicy == BufferData && m_options.dataBufferingPolicy == DoNotBufferData) {
    7496        if (m_loader)
    … …  
    7698        clear();
    7799    }
     100}
     101
     102void CachedRawResource::notifyClientsDataWasReceived(const char* data, unsigned length)
     103{
     104    if (!length)
     105        return;
     106
     107    CachedResourceHandle<CachedRawResource> protect(this);
     108    CachedResourceClientWalker<CachedRawResourceClient> w(m_clients);
     109    while (CachedRawResourceClient* c = w.next())
     110        c->dataReceived(this, data, length);
    78111}
    79112

  • trunk/Source/WebCore/loader/cache/CachedRawResource.h

    r151310 r151586  
    4949private:
    5050    virtual void didAddClient(CachedResourceClient*) OVERRIDE;
    51     virtual void data(ResourceBuffer*, bool allDataReceived) OVERRIDE;
     51    virtual void addDataBuffer(ResourceBuffer*) OVERRIDE;
     52    virtual void addData(const char* data, unsigned length) OVERRIDE;
     53    virtual void finishLoading(ResourceBuffer*) OVERRIDE;
    5254
    5355    virtual bool shouldIgnoreHTTPStatusCodeErrors() const OVERRIDE { return true; }
    … …  
    6264
    6365    virtual bool canReuse(const ResourceRequest&) const OVERRIDE;
     66
     67    const char* calculateIncrementalDataChunk(ResourceBuffer*, unsigned& incrementalDataLength);
     68    void notifyClientsDataWasReceived(const char* data, unsigned length);
    6469
    6570    unsigned long m_identifier;

  • trunk/Source/WebCore/loader/cache/CachedResource.cpp

    r151277 r151586  
    363363}
    364364
    365 void CachedResource::data(ResourceBuffer*, bool allDataReceived)
    366 {
    367     if (!allDataReceived)
    368         return;
    369    
     365void CachedResource::addDataBuffer(ResourceBuffer*)
     366{
     367    ASSERT(m_options.dataBufferingPolicy == BufferData);
     368}
     369
     370void CachedResource::addData(const char*, unsigned)
     371{
     372    ASSERT(m_options.dataBufferingPolicy == DoNotBufferData);
     373}
     374
     375void CachedResource::finishLoading(ResourceBuffer*)
     376{
    370377    setLoading(false);
    371378    checkNotify();

  • trunk/Source/WebCore/loader/cache/CachedResource.h

    r151277 r151586  
    102102    virtual void setEncoding(const String&) { }
    103103    virtual String encoding() const { return String(); }
    104     virtual void data(ResourceBuffer*, bool allDataReceived);
     104    virtual void addDataBuffer(ResourceBuffer*);
     105    virtual void addData(const char* data, unsigned length);
     106    virtual void finishLoading(ResourceBuffer*);
    105107    virtual void error(CachedResource::Status);
    106108

  • trunk/Source/WebCore/loader/cache/CachedSVGDocument.cpp

    r151277 r151586  
    5454}
    5555
    56 void CachedSVGDocument::data(ResourceBuffer* data, bool allDataReceived)
     56void CachedSVGDocument::finishLoading(ResourceBuffer* data)
    5757{
    58     if (!allDataReceived)
    59         return;
    60 
    6158    if (data) {
    6259        StringBuilder decodedText;
    … …  
    6764        m_document->setContent(decodedText.toString());
    6865    }
    69 
    70     setLoading(false);
    71     checkNotify();
     66    CachedResource::finishLoading(data);
    7267}
    7368

  • trunk/Source/WebCore/loader/cache/CachedSVGDocument.h

    r151310 r151586  
    4747    virtual void setEncoding(const String&) OVERRIDE;
    4848    virtual String encoding() const OVERRIDE;
    49     virtual void data(ResourceBuffer*, bool allDataReceived) OVERRIDE;
     49    virtual void finishLoading(ResourceBuffer*) OVERRIDE;
    5050};
    5151

  • trunk/Source/WebCore/loader/cache/CachedScript.cpp

    r151277 r151586  
    8383}
    8484
    85 void CachedScript::data(ResourceBuffer* data, bool allDataReceived)
     85void CachedScript::finishLoading(ResourceBuffer* data)
    8686{
    87     if (!allDataReceived)
    88         return;
    89 
    9087    m_data = data;
    9188    setEncodedSize(m_data.get() ? m_data->size() : 0);
    92     setLoading(false);
    93     checkNotify();
     89    CachedResource::finishLoading(data);
    9490}
    9591

  • trunk/Source/WebCore/loader/cache/CachedScript.h

    r151310 r151586  
    5555        virtual void setEncoding(const String&) OVERRIDE;
    5656        virtual String encoding() const OVERRIDE;
    57         virtual void data(ResourceBuffer*, bool allDataReceived) OVERRIDE;
     57        virtual void finishLoading(ResourceBuffer*) OVERRIDE;
    5858
    5959        virtual void destroyDecodedData() OVERRIDE;

  • trunk/Source/WebCore/loader/cache/CachedShader.cpp

    r151277 r151586  
    6161}
    6262
    63 void CachedShader::data(ResourceBuffer* data, bool allDataReceived)
     63void CachedShader::finishLoading(ResourceBuffer* data)
    6464{
    65     if (allDataReceived)
    66         m_data = data;
    67     CachedResource::data(data, allDataReceived);
     65    m_data = data;
     66    CachedResource::finishLoading(0);
    6867}
    6968

  • trunk/Source/WebCore/loader/cache/CachedShader.h

    r151310 r151586  
    4848private:
    4949    virtual bool mayTryReplaceEncodedData() const OVERRIDE { return true; }
    50     virtual void data(ResourceBuffer*, bool allDataReceived) OVERRIDE;
     50    virtual void finishLoading(ResourceBuffer*) OVERRIDE;
    5151
    5252    RefPtr<TextResourceDecoder> m_decoder;

  • trunk/Source/WebCore/loader/cache/CachedTextTrack.cpp

    r151277 r151586  
    4949}
    5050
    51 void CachedTextTrack::data(ResourceBuffer* data, bool allDataReceived)
     51void CachedTextTrack::addDataBuffer(ResourceBuffer* data)
    5252{
     53    ASSERT(m_options.dataBufferingPolicy == BufferData);
    5354    m_data = data;
    5455    setEncodedSize(m_data.get() ? m_data->size() : 0);
    … …  
    5758    while (CachedResourceClient *client = walker.next())
    5859        client->deprecatedDidReceiveCachedResource(this);
     60}
    5961
    60     if (!allDataReceived)
    61         return;
    62    
    63     setLoading(false);
    64     checkNotify();
     62void CachedTextTrack::finishLoading(ResourceBuffer* data)
     63{
     64    addDataBuffer(data);
     65    CachedResource::finishLoading(data);
    6566}
    6667

  • trunk/Source/WebCore/loader/cache/CachedTextTrack.h

    r151310 r151586  
    4141private:
    4242    virtual bool mayTryReplaceEncodedData() const OVERRIDE { return true; }
    43     virtual void data(ResourceBuffer*, bool allDataReceived) OVERRIDE;
     43    virtual void addDataBuffer(ResourceBuffer*) OVERRIDE;
     44    virtual void finishLoading(ResourceBuffer*) OVERRIDE;
    4445};
    4546

  • trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp

    r151277 r151586  
    6464}
    6565
    66 void CachedXSLStyleSheet::data(ResourceBuffer* data, bool allDataReceived)
     66void CachedXSLStyleSheet::finishLoading(ResourceBuffer* data)
    6767{
    68     if (!allDataReceived)
    69         return;
    70 
    7168    m_data = data;
    7269    setEncodedSize(m_data.get() ? m_data->size() : 0);

  • trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.h

    r151310 r151586  
    5555        virtual void setEncoding(const String&) OVERRIDE;
    5656        virtual String encoding() const OVERRIDE;
    57         virtual void data(ResourceBuffer*, bool allDataReceived) OVERRIDE;
     57        virtual void finishLoading(ResourceBuffer*) OVERRIDE;
    5858    };
    5959
Note: See TracChangeset for help on using the changeset viewer.