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; }