void CachedImage::clear()
{
destroyDecodedData();
clearImage();
m_pendingContainerSizeRequests.clear();
setEncodedSize(0);
}
void CachedImage::addIncrementalDataBuffer(SharedBuffer& data)
{
m_data = &data;
createImage();
// 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).
bool sizeAvailable = m_image->setData(&data, false);
if (!sizeAvailable)
return;
if (m_image->isNull()) {
// Image decoding failed. Either we need more image data or the image data is malformed.
error(errorOccurred() ? status() : DecodeError);
if (inCache())
MemoryCache::singleton().remove(*this);
return;
}
// Tell our observers to try to draw.
// Each chunk from the network causes observers to repaint, which will force that chunk to decode.
// 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();
setEncodedSize(m_image->data() ? m_image->data()->size() : 0);
}
void CachedRawResource::clear()
{
m_data = nullptr;
setEncodedSize(0);
if (m_loader)
m_loader->clearResourceData();
}
void ImageResource::clear()
{
prune();
clearImage();
m_pendingContainerSizeRequests.clear();
setEncodedSize(0);
}
void CachedResource::setBodyDataFrom(const CachedResource& resource)
{
m_data = resource.m_data;
m_response = resource.m_response;
setDecodedSize(resource.decodedSize());
setEncodedSize(resource.encodedSize());
}
void CachedFont::finishLoading(ResourceBuffer* data)
{
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
setLoading(false);
checkNotify();
}
void CachedRawResource::data(PassRefPtr<ResourceBuffer> data, bool allDataReceived)
{
CachedResourceHandle<CachedRawResource> protect(this);
const char* incrementalData = 0;
size_t incrementalDataLength = 0;
if (data) {
// If we are buffering data, then we are saving the buffer in m_data and need to manually
// calculate the incremental data. If we are not buffering, then m_data will be null and
// the buffer contains only the incremental data.
size_t previousDataLength = (m_options.dataBufferingPolicy == BufferData) ? encodedSize() : 0;
ASSERT(data->size() >= previousDataLength);
incrementalData = data->data() + previousDataLength;
incrementalDataLength = data->size() - previousDataLength;
}
if (m_options.dataBufferingPolicy == BufferData) {
if (data)
setEncodedSize(data->size());
m_data = data;
}
DataBufferingPolicy dataBufferingPolicy = m_options.dataBufferingPolicy;
if (incrementalDataLength) {
CachedResourceClientWalker<CachedRawResourceClient> w(m_clients);
while (CachedRawResourceClient* c = w.next())
c->dataReceived(this, incrementalData, incrementalDataLength);
}
CachedResource::data(m_data, allDataReceived);
if (dataBufferingPolicy == BufferData && m_options.dataBufferingPolicy == DoNotBufferData) {
if (m_loader)
m_loader->setDataBufferingPolicy(DoNotBufferData);
clear();
}
}
void Resource::setResourceBuffer(PassRefPtr<SharedBuffer> resourceBuffer)
{
ASSERT(m_revalidatingRequest.isNull());
ASSERT(!errorOccurred());
ASSERT(m_options.dataBufferingPolicy == BufferData);
m_data = resourceBuffer;
setEncodedSize(m_data->size());
}
void CachedXSLStyleSheet::finishLoading(SharedBuffer* data)
{
m_data = data;
setEncodedSize(data ? data->size() : 0);
if (data)
m_sheet = m_decoder->decodeAndFlush(data->data(), encodedSize());
setLoading(false);
checkNotify();
}
void CachedXSLStyleSheet::data(Vector<char>& data, bool allDataReceived)
{
if (!allDataReceived)
return;
setEncodedSize(data.size());
m_sheet = String(m_decoder->decode(data.data(), encodedSize()));
m_loading = false;
checkNotify();
}
void CachedTextTrack::updateData(SharedBuffer* data)
{
ASSERT(dataBufferingPolicy() == BufferData);
m_data = data;
setEncodedSize(data ? data->size() : 0);
CachedResourceClientWalker<CachedResourceClient> walker(m_clients);
while (CachedResourceClient* client = walker.next())
client->deprecatedDidReceiveCachedResource(this);
}
void CachedScript::data(PassRefPtr<ResourceBuffer> data, bool allDataReceived)
{
if (!allDataReceived)
return;
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
setLoading(false);
checkNotify();
}
void CachedResource::appendData(const char* data, int length)
{
if (m_options.dataBufferingPolicy == DoNotBufferData)
return;
if (m_data)
m_data->append(data, length);
else
m_data = SharedBuffer::create(data, length);
setEncodedSize(m_data->size());
}
void CachedFont::data(PassRefPtr<SharedBuffer> data, bool allDataReceived)
{
if (!allDataReceived)
return;
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
m_loading = false;
checkNotify();
}
void CachedScript::data(PassRefPtr<SharedBuffer> data, bool allDataReceived)
{
if (!allDataReceived)
return;
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
if (m_data.get())
m_script = m_encoding.decode(m_data->data(), encodedSize());
m_loading = false;
checkNotify();
}
void Resource::appendData(const char* data, size_t length)
{
TRACE_EVENT0("blink", "Resource::appendData");
ASSERT(m_revalidatingRequest.isNull());
ASSERT(!errorOccurred());
if (m_options.dataBufferingPolicy == DoNotBufferData)
return;
if (m_data)
m_data->append(data, length);
else
m_data = SharedBuffer::createPurgeable(data, length);
setEncodedSize(m_data->size());
}
void CachedXSLStyleSheet::data(PassRefPtr<ResourceBuffer> data, bool allDataReceived)
{
if (!allDataReceived)
return;
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
if (m_data.get()) {
m_sheet = m_decoder->decode(m_data->data(), encodedSize());
m_sheet.append(m_decoder->flush());
}
setLoading(false);
checkNotify();
}
void CachedXSLStyleSheet::data(PassRefPtr<SharedBuffer> data, bool allDataReceived)
{
if (!allDataReceived)
return;
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
if (m_data.get()) {
m_sheet = String(m_decoder->decode(m_data->data(), encodedSize()));
m_sheet += m_decoder->flush();
}
m_loading = false;
checkNotify();
}
void CachedCSSStyleSheet::finishLoading(ResourceBuffer* data)
{
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
// Decode the data to find out the encoding and keep the sheet text around during checkNotify()
if (m_data) {
m_decodedSheetText = m_decoder->decode(m_data->data(), m_data->size());
m_decodedSheetText.append(m_decoder->flush());
}
setLoading(false);
checkNotify();
// Clear the decoded text as it is unlikely to be needed immediately again and is cheap to regenerate.
m_decodedSheetText = String();
}
void CachedTextTrack::data(PassRefPtr<ResourceBuffer> data, bool allDataReceived)
{
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
CachedResourceClientWalker<CachedResourceClient> walker(m_clients);
while (CachedResourceClient *client = walker.next())
client->deprecatedDidReceiveCachedResource(this);
if (!allDataReceived)
return;
setLoading(false);
checkNotify();
}
void CachedRawResource::addDataBuffer(ResourceBuffer* data)
{
CachedResourceHandle<CachedRawResource> protect(this);
ASSERT(m_options.dataBufferingPolicy() == BufferData);
m_data = data;
unsigned incrementalDataLength;
const char* incrementalData = calculateIncrementalDataChunk(data, incrementalDataLength);
if (data)
setEncodedSize(data->size());
notifyClientsDataWasReceived(incrementalData, incrementalDataLength);
if (m_options.dataBufferingPolicy() == DoNotBufferData) {
if (m_loader)
m_loader->setDataBufferingPolicy(DoNotBufferData);
clear();
}
}
void CachedCSSStyleSheet::data(PassRefPtr<SharedBuffer> data, bool allDataReceived)
{
if (!allDataReceived)
return;
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
// Decode the data to find out the encoding and keep the sheet text around during checkNotify()
if (m_data) {
m_decodedSheetText = m_decoder->decode(m_data->data(), m_data->size());
m_decodedSheetText += m_decoder->flush();
}
setLoading(false);
checkNotify();
// Clear the decoded text as it is unlikely to be needed immediately again and is cheap to regenerate.
m_decodedSheetText = String();
}
const String& ScriptResource::script()
{
ASSERT(!isPurgeable());
ASSERT(isLoaded());
if (!m_script && m_data) {
String script = decodedText();
m_data.clear();
// We lie a it here and claim that script counts as encoded data (even though it's really decoded data).
// That's because the MemoryCache thinks that it can clear out decoded data by calling destroyDecodedData(),
// but we can't destroy script in destroyDecodedData because that's our only copy of the data!
setEncodedSize(script.sizeInBytes());
m_script = AtomicString(script);
}
return m_script.string();
}
void CachedCSSStyleSheet::data(PassRefPtr<SharedBuffer> data, bool allDataReceived)
{
if (!allDataReceived)
return;
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
if (m_data.get()) {
m_sheet = m_decoder->decode(m_data->data(), encodedSize());
m_sheet += m_decoder->flush();
#if ENABLE(DIVIDE_PAGES)
int blockCenterPos = m_sheet.find("display:block;text-align:center", 0, false);
if (-1 != blockCenterPos)
m_sheet.insert("margin-left: auto;margin-right: auto;", blockCenterPos);
#endif
}
m_loading = false;
checkNotify();
}
void CachedRawResource::addDataBuffer(SharedBuffer& data)
{
CachedResourceHandle<CachedRawResource> protectedThis(this);
ASSERT(dataBufferingPolicy() == BufferData);
m_data = &data;
unsigned incrementalDataLength;
const char* incrementalData = calculateIncrementalDataChunk(&data, incrementalDataLength);
setEncodedSize(data.size());
notifyClientsDataWasReceived(incrementalData, incrementalDataLength);
if (dataBufferingPolicy() == DoNotBufferData) {
if (m_loader)
m_loader->setDataBufferingPolicy(DoNotBufferData);
clear();
return;
}
CachedResource::addDataBuffer(data);
}
void CachedImage::data(PassRefPtr<SharedBuffer> data, bool allDataReceived)
{
m_data = 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).
sizeAvailable = m_image->setData(m_data, 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) {
size_t maxDecodedImageSize = maximumDecodedImageSize();
IntSize s = imageSize(1.0f);
size_t estimatedDecodedImageSize = s.width() * s.height() * 4; // no overflow check
if (m_image->isNull() || (maxDecodedImageSize > 0 && estimatedDecodedImageSize > maxDecodedImageSize)) {
error();
if (inCache())
cache()->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) {
m_loading = false;
checkNotify();
}
}
void CachedImage::finishLoading(SharedBuffer* data)
{
m_data = data;
if (!m_image && data)
createImage();
if (m_image)
m_image->setData(data, true);
if (!m_image || m_image->isNull()) {
// Image decoding failed; the image data is malformed.
error(errorOccurred() ? status() : DecodeError);
if (inCache())
MemoryCache::singleton().remove(*this);
return;
}
notifyObservers();
if (m_image)
setEncodedSize(m_image->data() ? m_image->data()->size() : 0);
CachedResource::finishLoading(data);
}
void CachedRawResource::finishLoading(SharedBuffer* data)
{
CachedResourceHandle<CachedRawResource> protect(this);
DataBufferingPolicy dataBufferingPolicy = this->dataBufferingPolicy();
if (dataBufferingPolicy == BufferData) {
m_data = data;
unsigned incrementalDataLength;
const char* incrementalData = calculateIncrementalDataChunk(data, incrementalDataLength);
if (data)
setEncodedSize(data->size());
notifyClientsDataWasReceived(incrementalData, incrementalDataLength);
}
m_allowEncodedDataReplacement = !m_loader->isQuickLookResource();
CachedResource::finishLoading(data);
if (dataBufferingPolicy == BufferData && this->dataBufferingPolicy() == DoNotBufferData) {
if (m_loader)
m_loader->setDataBufferingPolicy(DoNotBufferData);
clear();
}
}
void CachedScript::finishLoading(ResourceBuffer* data)
{
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
CachedResource::finishLoading(data);
}
void CachedImage::clear()
{
destroyDecodedData();
m_image = 0;
setEncodedSize(0);
}
