Пример #1
0
void IDBKeyData::encode(KeyedEncoder& encoder) const
{
    encoder.encodeBool("null", m_isNull);
    if (m_isNull)
        return;

    encoder.encodeEnum("m_type", m_type);

    switch (m_type) {
    case KeyType::Invalid:
        return;
    case KeyType::Array:
        encoder.encodeObjects("array", m_arrayValue.begin(), m_arrayValue.end(), [](KeyedEncoder& encoder, const IDBKeyData& key) {
            key.encode(encoder);
        });
        return;
    case KeyType::String:
        encoder.encodeString("string", m_stringValue);
        return;
    case KeyType::Date:
    case KeyType::Number:
        encoder.encodeDouble("number", m_numberValue);
        return;
    case KeyType::Max:
    case KeyType::Min:
        return;
    }

    ASSERT_NOT_REACHED();
}
Пример #2
0
void HistoryItem::encodeBackForwardTree(KeyedEncoder& encoder) const
{
    encoder.encodeUInt32("version", backForwardTreeEncodingVersion);

    encoder.encodeObject("root", *this, [](KeyedEncoder& encoder, const HistoryItem& item) {
        item.encodeBackForwardTreeNode(encoder);
    });
}
Пример #3
0
static void encodeElement(KeyedEncoder& encoder, const FormDataElement& element)
{
    encoder.encodeEnum("type", element.m_type);

    switch (element.m_type) {
    case FormDataElement::data:
        encoder.encodeBytes("data", reinterpret_cast<const uint8_t*>(element.m_data.data()), element.m_data.size());
        return;
    case FormDataElement::encodedFile:
        encoder.encodeString("filename", element.m_filename);
        encoder.encodeString("generatedFilename", element.m_generatedFilename);
        encoder.encodeBool("shouldGenerateFile", element.m_shouldGenerateFile);
#if ENABLE(BLOB)
        encoder.encodeInt64("fileStart", element.m_fileStart);
        encoder.encodeInt64("fileLength", element.m_fileLength);
        encoder.encodeDouble("expectedFileModificationTime", element.m_expectedFileModificationTime);
#endif
        return;

#if ENABLE(BLOB)
    case FormDataElement::encodedBlob:
        encoder.encodeString("url", element.m_url.string());
        return;
#endif
    }

    ASSERT_NOT_REACHED();
}
Пример #4
0
void FormData::encode(KeyedEncoder& encoder) const
{
    encoder.encodeBool("alwaysStream", m_alwaysStream);
    encoder.encodeBytes("boundary", reinterpret_cast<const uint8_t*>(m_boundary.data()), m_boundary.size());

    encoder.encodeObjects("elements", m_elements.begin(), m_elements.end(), [](KeyedEncoder& encoder, const FormDataElement& element) {
        encodeElement(encoder, element);
    });

    encoder.encodeInt64("identifier", m_identifier);
}
Пример #5
0
void IDBKeyPath::encode(KeyedEncoder& encoder) const
{
    encoder.encodeEnum("type", m_type);
    switch (m_type) {
    case IDBKeyPath::NullType:
        break;
    case IDBKeyPath::StringType:
        encoder.encodeString("string", m_string);
        break;
    case IDBKeyPath::ArrayType:
        encoder.encodeObjects("array", m_array.begin(), m_array.end(), [](WebCore::KeyedEncoder& encoder, const String& string) {
            encoder.encodeString("string", string);
        });
        break;
    default:
        ASSERT_NOT_REACHED();
    };
}
void WebResourceLoadStatisticsStore::writeEncoderToDisk(KeyedEncoder& encoder, const String& label) const
{
    RefPtr<SharedBuffer> rawData = encoder.finishEncoding();
    if (!rawData)
        return;
    
    String resourceLog = persistentStoragePath(label);
    if (resourceLog.isEmpty())
        return;
    
    if (!m_storagePath.isEmpty())
        makeAllDirectories(m_storagePath);
    
    auto handle = openFile(resourceLog, OpenForWrite);
    if (!handle)
        return;
    
    int64_t writtenBytes = writeToFile(handle, rawData->data(), rawData->size());
    closeFile(handle);
    
    if (writtenBytes != static_cast<int64_t>(rawData->size()))
        WTFLogAlways("WebResourceLoadStatisticsStore: We only wrote %d out of %d bytes to disk", static_cast<unsigned>(writtenBytes), rawData->size());
}
Пример #7
0
void HistoryItem::encodeBackForwardTreeNode(KeyedEncoder& encoder) const
{
    encoder.encodeObjects("children", m_children.begin(), m_children.end(), [](KeyedEncoder& encoder, const RefPtr<HistoryItem>& child) {
        encoder.encodeString("originalURLString", child->m_originalURLString);
        encoder.encodeString("urlString", child->m_urlString);

        child->encodeBackForwardTreeNode(encoder);
    });

    encoder.encodeInt64("documentSequenceNumber", m_documentSequenceNumber);

    encoder.encodeObjects("documentState", m_documentState.begin(), m_documentState.end(), [](KeyedEncoder& encoder, const String& string) {
        encoder.encodeString("string", string);
    });

    encoder.encodeString("formContentType", m_formContentType);

    encoder.encodeConditionalObject("formData", m_formData.get(), [](KeyedEncoder& encoder, const FormData& formData) {
        formData.encode(encoder);
    });

    encoder.encodeInt64("itemSequenceNumber", m_itemSequenceNumber);

    encoder.encodeString("referrer", m_referrer);

    encoder.encodeObject("scrollPoint", m_scrollPoint, [](KeyedEncoder& encoder, const IntPoint& scrollPoint) {
        encoder.encodeInt32("x", scrollPoint.x());
        encoder.encodeInt32("y", scrollPoint.y());
    });

    encoder.encodeFloat("pageScaleFactor", m_pageScaleFactor);

    encoder.encodeConditionalObject("stateObject", m_stateObject.get(), [](KeyedEncoder& encoder, const SerializedScriptValue& stateObject) {
        encoder.encodeBytes("data", stateObject.data().data(), stateObject.data().size());
    });

    encoder.encodeString("target", m_target);
}