uint32_t encodedSize(const Variant& value)
{
switch (value.getType()) {
case VAR_VOID:
return 0;
case VAR_BOOL:
case VAR_UINT8:
case VAR_INT8:
return 1;
case VAR_UINT16:
case VAR_INT16:
return 2;
break;
case VAR_UINT32:
case VAR_INT32:
case VAR_FLOAT:
return 4;
case VAR_UINT64:
case VAR_INT64:
case VAR_DOUBLE:
return 8;
case VAR_UUID:
return 16;
case VAR_MAP:
return encodedSize(value.asMap());
case VAR_LIST:
return encodedSize(value.asList());
case VAR_STRING:
return encodedSize(value.getString());
default:
throw Exception("Couldn't encode Variant: Illegal type code");
}
}
const String& CachedScript::script()
{
ASSERT(!isPurgeable());
if (!m_script && m_data) {
m_script = m_decoder->decode(m_data->data(), encodedSize());
m_script.append(m_decoder->flush());
#if ENABLE(MEMORY_OUT_HANDLING)
// If we fail to decode the script (because of lack of memory)
// and return an empty string the Lexer will barf. It
// assumes that the data ptr is not going to be null.
if (encodedSize() > 0 && m_script.length() == 0)
m_script = " ";
#endif
setDecodedSize(m_script.sizeInBytes());
}
#if !ENABLE(MEMORY_OUT_HANDLING)
// If memory out handling is enabled, don't delete the decoded data.
// JS parser assumes that if a script has been decoded once we'll always
// be able to decode it.
m_decodedDataDeletionTimer.startOneShot(0);
#endif
return m_script;
}
uint32_t encodedSize(const Variant::Map& values, const std::string& efield, const Variant& evalue)
{
uint32_t size = 4/*size field*/ + 4/*count field*/;
for(Variant::Map::const_iterator i = values.begin(); i != values.end(); ++i) {
size += 1/*size of key*/ + (i->first).size() + 1/*typecode*/ + encodedSize(i->second);
}
size += 1/*size of key*/ + efield.size() + 1/*typecode*/ + encodedSize(evalue);
return size;
}
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 qpid::framing::AMQContentBody::print(std::ostream& out) const
{
out << "content (" << encodedSize() << " bytes)";
const size_t max = 32;
out << " " << data.substr(0, max);
if (data.size() > max) out << "...";
}
void Resource::onMemoryDump(WebMemoryDumpLevelOfDetail levelOfDetail, WebProcessMemoryDump* memoryDump) const
{
static const size_t kMaxURLReportLength = 128;
const String dumpName = getMemoryDumpName();
WebMemoryAllocatorDump* dump = memoryDump->createMemoryAllocatorDump(dumpName);
dump->addScalar("encoded_size", "bytes", m_encodedSize);
if (canDelete()) {
dump->addScalar("dead_size", "bytes", m_encodedSize);
} else {
dump->addScalar("live_size", "bytes", m_encodedSize);
}
if (m_data) {
dump->addScalar("purgeable_size", "bytes", isPurgeable() && !wasPurged() ? encodedSize() + overheadSize() : 0);
m_data->onMemoryDump(dumpName, memoryDump);
}
if (levelOfDetail == WebMemoryDumpLevelOfDetail::Detailed) {
String urlToReport = url().string();
if (urlToReport.length() > kMaxURLReportLength) {
urlToReport.truncate(kMaxURLReportLength);
urlToReport = urlToReport + "...";
}
dump->addString("url", "", urlToReport);
}
const String overheadName = dumpName + "/metadata";
WebMemoryAllocatorDump* overheadDump = memoryDump->createMemoryAllocatorDump(overheadName);
overheadDump->addScalar("size", "bytes", overheadSize());
memoryDump->addSuballocation(overheadDump->guid(), String(WTF::Partitions::kAllocatedObjectPoolName));
}
StringView CachedScript::script()
{
if (!m_data)
return { };
if (m_decodingState == NeverDecoded
&& TextEncoding(encoding()).isByteBasedEncoding()
&& m_data->size()
&& charactersAreAllASCII(reinterpret_cast<const LChar*>(m_data->data()), m_data->size())) {
m_decodingState = DataAndDecodedStringHaveSameBytes;
// If the encoded and decoded data are the same, there is no decoded data cost!
setDecodedSize(0);
m_decodedDataDeletionTimer.stop();
m_scriptHash = StringHasher::computeHashAndMaskTop8Bits(reinterpret_cast<const LChar*>(m_data->data()), m_data->size());
}
if (m_decodingState == DataAndDecodedStringHaveSameBytes)
return { reinterpret_cast<const LChar*>(m_data->data()), m_data->size() };
if (!m_script) {
m_script = m_decoder->decodeAndFlush(m_data->data(), encodedSize());
m_scriptHash = m_script.impl()->hash();
m_decodingState = DataAndDecodedStringHaveDifferentBytes;
setDecodedSize(m_script.sizeInBytes());
}
m_decodedDataDeletionTimer.restart();
return m_script;
}
void Resource::onMemoryDump(WebMemoryDumpLevelOfDetail levelOfDetail, WebProcessMemoryDump* memoryDump) const
{
static const size_t kMaxURLReportLength = 128;
static const int kMaxResourceClientToShowInMemoryInfra = 10;
const String dumpName = getMemoryDumpName();
WebMemoryAllocatorDump* dump = memoryDump->createMemoryAllocatorDump(dumpName);
dump->addScalar("encoded_size", "bytes", m_encodedSize);
if (canDelete()) {
dump->addScalar("dead_size", "bytes", m_encodedSize);
} else {
dump->addScalar("live_size", "bytes", m_encodedSize);
}
if (m_data) {
dump->addScalar("purgeable_size", "bytes", isPurgeable() && !wasPurged() ? encodedSize() + overheadSize() : 0);
m_data->onMemoryDump(dumpName, memoryDump);
}
if (levelOfDetail == WebMemoryDumpLevelOfDetail::Detailed) {
String urlToReport = url().string();
if (urlToReport.length() > kMaxURLReportLength) {
urlToReport.truncate(kMaxURLReportLength);
urlToReport = urlToReport + "...";
}
dump->addString("url", "", urlToReport);
dump->addString("reason_not_deletable", "", reasonNotDeletable());
Vector<String> clientNames;
ResourceClientWalker<ResourceClient> walker(m_clients);
while (ResourceClient* client = walker.next())
clientNames.append(client->debugName());
ResourceClientWalker<ResourceClient> walker2(m_clientsAwaitingCallback);
while (ResourceClient* client = walker2.next())
clientNames.append("(awaiting) " + client->debugName());
ResourceClientWalker<ResourceClient> walker3(m_finishedClients);
while (ResourceClient* client = walker3.next())
clientNames.append("(finished) " + client->debugName());
std::sort(clientNames.begin(), clientNames.end(), codePointCompareLessThan);
StringBuilder builder;
for (size_t i = 0; i < clientNames.size() && i < kMaxResourceClientToShowInMemoryInfra; ++i) {
if (i > 0)
builder.append(" / ");
builder.append(clientNames[i]);
}
if (clientNames.size() > kMaxResourceClientToShowInMemoryInfra) {
builder.append(" / and ");
builder.appendNumber(clientNames.size() - kMaxResourceClientToShowInMemoryInfra);
builder.append(" more");
}
dump->addString("ResourceClient", "", builder.toString());
}
const String overheadName = dumpName + "/metadata";
WebMemoryAllocatorDump* overheadDump = memoryDump->createMemoryAllocatorDump(overheadName);
overheadDump->addScalar("size", "bytes", overheadSize());
memoryDump->addSuballocation(overheadDump->guid(), String(WTF::Partitions::kAllocatedObjectPoolName));
}
size_t MessageEncoder::getEncodedSizeForElements(const qpid::types::Variant::Map& map)
{
size_t total = 0;
for (qpid::types::Variant::Map::const_iterator i = map.begin(); i != map.end(); ++i) {
total += 1/*code*/ + encodedSize(i->first);
switch (i->second.getType()) {
case qpid::types::VAR_MAP:
case qpid::types::VAR_LIST:
case qpid::types::VAR_VOID:
case qpid::types::VAR_BOOL:
total += 1;
break;
case qpid::types::VAR_UINT8:
case qpid::types::VAR_INT8:
total += 2;
break;
case qpid::types::VAR_UINT16:
case qpid::types::VAR_INT16:
total += 3;
break;
case qpid::types::VAR_UINT32:
case qpid::types::VAR_INT32:
case qpid::types::VAR_FLOAT:
total += 5;
break;
case qpid::types::VAR_UINT64:
case qpid::types::VAR_INT64:
case qpid::types::VAR_DOUBLE:
total += 9;
break;
case qpid::types::VAR_UUID:
total += 17;
break;
case qpid::types::VAR_STRING:
total += 1/*code*/ + encodedSize(i->second);
break;
}
}
return total;
}
uint32_t encodedSize(const Variant::List& values)
{
uint32_t size = 4/*size field*/ + 4/*count field*/;
for(Variant::List::const_iterator i = values.begin(); i != values.end(); ++i) {
size += 1/*typecode*/ + encodedSize(*i);
}
return size;
}
void FieldTable::encode(Buffer& buffer) const {
buffer.putLong(encodedSize() - 4);
buffer.putLong(values.size());
for (ValueMap::const_iterator i = values.begin(); i!=values.end(); ++i) {
buffer.putShortString(i->first);
i->second->encode(buffer);
}
}
size_t MessageEncoder::getEncodedSizeForElements(const qpid::types::Variant::Map& map)
{
size_t total = 0;
for (qpid::types::Variant::Map::const_iterator i = map.begin(); i != map.end(); ++i) {
total += 1/*code*/ + encodedSize(i->first) + getEncodedSizeForValue(i->second);
}
return total;
}
const String& CachedScript::script()
{
if (!m_script && m_data) {
m_script = m_decoder->decodeAndFlush(m_data->data(), encodedSize());
setDecodedSize(m_script.sizeInBytes());
}
m_decodedDataDeletionTimer.restart();
return m_script;
}
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();
}
size_t MessageEncoder::getEncodedSize(const Properties& p, const qpid::types::Variant::Map& ap, const std::string& d)
{
size_t total(getEncodedSize(p));
//application-properties:
total += 3/*descriptor*/ + getEncodedSize(ap, true);
//body:
if (d.size()) total += 3/*descriptor*/ + 1/*code*/ + encodedSize(d);
return total;
}
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();
}
size_t MessageEncoder::getEncodedSize(const Properties& p)
{
//NOTE: this does not take optional optimisation into account,
//i.e. it is a 'worst case' estimate for required buffer space
size_t total(3/*descriptor*/ + 1/*code*/ + 4/*size*/ + 4/*count*/ + 13/*codes for each field*/);
if (p.hasMessageId()) total += encodedSize(p.getMessageId());
if (p.hasUserId()) total += encodedSize(p.getUserId());
if (p.hasTo()) total += encodedSize(p.getTo());
if (p.hasSubject()) total += encodedSize(p.getSubject());
if (p.hasReplyTo()) total += encodedSize(p.getReplyTo());
if (p.hasCorrelationId()) total += encodedSize(p.getCorrelationId());
if (p.hasContentType()) total += encodedSize(p.getContentType());
if (p.hasContentEncoding()) total += encodedSize(p.getContentEncoding());
if (p.hasAbsoluteExpiryTime()) total += 8;
if (p.hasCreationTime()) total += 8;
if (p.hasGroupId()) total += encodedSize(p.getGroupId());
if (p.hasGroupSequence()) total += 4;
if (p.hasReplyToGroupId()) total += encodedSize(p.getReplyToGroupId());
return total;
}
const char* CachedRawResource::calculateIncrementalDataChunk(SharedBuffer* data, unsigned& incrementalDataLength)
{
incrementalDataLength = 0;
if (!data)
return 0;
unsigned previousDataLength = encodedSize();
ASSERT(data->size() >= previousDataLength);
incrementalDataLength = data->size() - previousDataLength;
return data->data() + previousDataLength;
}
const String& CachedScript::script()
{
ASSERT(!isPurgeable());
if (!m_script && m_data) {
m_script = m_decoder->decode(m_data->data(), encodedSize());
m_script += m_decoder->flush();
setDecodedSize(m_script.length() * sizeof(UChar));
}
m_decodedDataDeletionTimer.startOneShot(0);
return m_script;
}
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();
}
const String& CachedScript::script()
{
ASSERT(!isPurgeable());
if (!m_script && m_data) {
m_script = m_decoder->decode(m_data->data(), encodedSize());
m_script.append(m_decoder->flush());
setDecodedSize(m_script.sizeInBytes());
}
m_decodedDataDeletionTimer.startOneShot(0);
return m_script;
}
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 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();
}
size_t MessageEncoder::getEncodedSizeForValue(const qpid::types::Variant& value)
{
size_t total = 0;
switch (value.getType()) {
case qpid::types::VAR_MAP:
total += getEncodedSize(value.asMap(), true);
break;
case qpid::types::VAR_LIST:
total += getEncodedSize(value.asList(), true);
break;
case qpid::types::VAR_VOID:
case qpid::types::VAR_BOOL:
total += 1;
break;
case qpid::types::VAR_UINT8:
case qpid::types::VAR_INT8:
total += 2;
break;
case qpid::types::VAR_UINT16:
case qpid::types::VAR_INT16:
total += 3;
break;
case qpid::types::VAR_UINT32:
case qpid::types::VAR_INT32:
case qpid::types::VAR_FLOAT:
total += 5;
break;
case qpid::types::VAR_UINT64:
case qpid::types::VAR_INT64:
case qpid::types::VAR_DOUBLE:
total += 9;
break;
case qpid::types::VAR_UUID:
total += 17;
break;
case qpid::types::VAR_STRING:
total += 1/*code*/ + encodedSize(value.getString());
break;
}
return total;
}
const String& ScriptResource::script()
{
ASSERT(!isPurgeable());
ASSERT(isLoaded());
if (!m_script && m_data) {
String script = m_decoder->decode(m_data->data(), encodedSize());
script.append(m_decoder->flush());
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 = 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 translate(const Variant::Map& from, const std::string& efield, const Variant& evalue, FieldTable& to)
{
// Create buffer of correct size to encode Variant::Map
uint32_t len = encodedSize(from, efield, evalue);
std::vector<char> space(len);
qpid::framing::Buffer buff(&space[0], len);
// Encode Variant::Map into buffer directly -
// We pass the already calculated length in to avoid
// recalculating it.
encode(from, efield, evalue, len, buff);
// Give buffer to FieldTable
// Could speed this up a bit by avoiding copying
// the buffer we just created into the FieldTable
assert( len == buff.getPosition() );
buff.reset();
to.decode(buff);
}
StringView CachedScript::script()
{
if (!m_script && m_data) {
if (m_ASCIIOptimizationState == Unknown
&& encodingMayBeAllASCII(encoding())
&& m_data->size()
&& charactersAreAllASCII(reinterpret_cast<const LChar*>(m_data->data()), m_data->size())) {
m_script = StringImpl::createWithoutCopying(reinterpret_cast<const LChar*>(m_data->data()), m_data->size());
m_ASCIIOptimizationState = DataAndDecodedStringHaveSameBytes;
// If the encoded and decoded data are the same, there is no decoded data cost!
setDecodedSize(0);
m_decodedDataDeletionTimer.stop();
return m_script;
}
m_script = m_decoder->decodeAndFlush(m_data->data(), encodedSize());
m_ASCIIOptimizationState = DataAndDecodedStringHaveDifferentBytes;
setDecodedSize(m_script.sizeInBytes());
}
if (m_ASCIIOptimizationState == DataAndDecodedStringHaveDifferentBytes)
m_decodedDataDeletionTimer.restart();
return m_script;
}
void encode(const Variant& value, qpid::framing::Buffer& buffer)
{
switch (value.getType()) {
case VAR_VOID:
buffer.putOctet(0xf0);
break;
case VAR_BOOL:
buffer.putOctet(0x08);
buffer.putOctet(value.asBool());
break;
case VAR_INT8:
buffer.putOctet(0x01);
buffer.putInt8(value.asInt8());
break;
case VAR_UINT8:
buffer.putOctet(0x02);
buffer.putOctet(value.asUint8());
break;
case VAR_INT16:
buffer.putOctet(0x11);
buffer.putInt16(value.asInt16());
break;
case VAR_UINT16:
buffer.putOctet(0x12);
buffer.putShort(value.asUint16());
break;
case VAR_INT32:
buffer.putOctet(0x21);
buffer.putInt32(value.asInt32());
break;
case VAR_UINT32:
buffer.putOctet(0x22);
buffer.putLong(value.asUint32());
break;
case VAR_FLOAT:
buffer.putOctet(0x23);
buffer.putFloat(value.asFloat());
break;
case VAR_INT64:
buffer.putOctet(0x31);
buffer.putInt64(value.asInt64());
break;
case VAR_UINT64:
buffer.putOctet(0x32);
buffer.putLongLong(value.asUint64());
break;
case VAR_DOUBLE:
buffer.putOctet(0x33);
buffer.putDouble(value.asDouble());
break;
case VAR_UUID:
buffer.putOctet(0x48);
buffer.putBin128(value.asUuid().data());
break;
case VAR_MAP:
buffer.putOctet(0xa8);
encode(value.asMap(), encodedSize(value.asMap()), buffer);
break;
case VAR_LIST:
buffer.putOctet(0xa9);
encode(value.asList(), encodedSize(value.asList()), buffer);
break;
case VAR_STRING:
encode(value.getString(), value.getEncoding(), buffer);
break;
}
}
size_t MessageEncoder::getEncodedSizeForContent(const std::string& d)
{
if (d.size()) return 3/*descriptor*/ + 1/*code*/ + encodedSize(d);
else return 0;
}
