Changeset 182019 in webkit


Ignore:
Timestamp:
Mar 26, 2015 11:39:22 AM (9 years ago)
Author:
Antti Koivisto
Message:

Rename Storage::Entry to Storage::Record
​https://bugs.webkit.org/show_bug.cgi?id=143101

Reviewed by Chris Dumez.

Lets have just one type called Entry in the cache code.

  • NetworkProcess/cache/NetworkCache.cpp:

(WebKit::NetworkCache::Cache::retrieve):
(WebKit::NetworkCache::Cache::store):
(WebKit::NetworkCache::Cache::update):
(WebKit::NetworkCache::Cache::traverse):
(WebKit::NetworkCache::Cache::dumpContentsToFile):

  • NetworkProcess/cache/NetworkCacheEntry.cpp:

(WebKit::NetworkCache::Entry::Entry):
(WebKit::NetworkCache::Entry::encodeAsStorageRecord):
(WebKit::NetworkCache::Entry::decodeStorageRecord):
(WebKit::NetworkCache::Entry::initializeBufferFromStorageRecord):
(WebKit::NetworkCache::Entry::buffer):
(WebKit::NetworkCache::Entry::shareableResourceHandle):
(WebKit::NetworkCache::Entry::encode): Deleted.
(WebKit::NetworkCache::Entry::decode): Deleted.
(WebKit::NetworkCache::Entry::initializeBufferFromStorageEntry): Deleted.

  • NetworkProcess/cache/NetworkCacheEntry.h:

(WebKit::NetworkCache::Entry::sourceStorageRecord):
(WebKit::NetworkCache::Entry::sourceStorageEntry): Deleted.

  • NetworkProcess/cache/NetworkCacheStorage.cpp:

(WebKit::NetworkCache::RecordMetaData::RecordMetaData):
(WebKit::NetworkCache::decodeRecordMetaData):
(WebKit::NetworkCache::decodeRecordHeader):
(WebKit::NetworkCache::decodeRecord):
(WebKit::NetworkCache::encodeRecordMetaData):
(WebKit::NetworkCache::encodeRecordHeader):
(WebKit::NetworkCache::Storage::dispatchReadOperation):
(WebKit::NetworkCache::retrieveFromMemory):
(WebKit::NetworkCache::Storage::store):
(WebKit::NetworkCache::Storage::update):
(WebKit::NetworkCache::Storage::traverse):
(WebKit::NetworkCache::Storage::dispatchPendingWriteOperations):
(WebKit::NetworkCache::Storage::dispatchFullWriteOperation):
(WebKit::NetworkCache::Storage::dispatchHeaderWriteOperation):
(WebKit::NetworkCache::EntryMetaData::EntryMetaData): Deleted.
(WebKit::NetworkCache::decodeEntryMetaData): Deleted.
(WebKit::NetworkCache::decodeEntryHeader): Deleted.
(WebKit::NetworkCache::decodeEntry): Deleted.
(WebKit::NetworkCache::encodeEntryMetaData): Deleted.
(WebKit::NetworkCache::encodeEntryHeader): Deleted.

  • NetworkProcess/cache/NetworkCacheStorage.h:
Location:
trunk/Source/WebKit2
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r182011 r182019  
     12015-03-26  Antti Koivisto  <antti@apple.com>
     2
     3        Rename Storage::Entry to Storage::Record
     4        https://bugs.webkit.org/show_bug.cgi?id=143101
     5
     6        Reviewed by Chris Dumez.
     7
     8        Lets have just one type called Entry in the cache code.
     9
     10        * NetworkProcess/cache/NetworkCache.cpp:
     11        (WebKit::NetworkCache::Cache::retrieve):
     12        (WebKit::NetworkCache::Cache::store):
     13        (WebKit::NetworkCache::Cache::update):
     14        (WebKit::NetworkCache::Cache::traverse):
     15        (WebKit::NetworkCache::Cache::dumpContentsToFile):
     16        * NetworkProcess/cache/NetworkCacheEntry.cpp:
     17        (WebKit::NetworkCache::Entry::Entry):
     18        (WebKit::NetworkCache::Entry::encodeAsStorageRecord):
     19        (WebKit::NetworkCache::Entry::decodeStorageRecord):
     20        (WebKit::NetworkCache::Entry::initializeBufferFromStorageRecord):
     21        (WebKit::NetworkCache::Entry::buffer):
     22        (WebKit::NetworkCache::Entry::shareableResourceHandle):
     23        (WebKit::NetworkCache::Entry::encode): Deleted.
     24        (WebKit::NetworkCache::Entry::decode): Deleted.
     25        (WebKit::NetworkCache::Entry::initializeBufferFromStorageEntry): Deleted.
     26        * NetworkProcess/cache/NetworkCacheEntry.h:
     27        (WebKit::NetworkCache::Entry::sourceStorageRecord):
     28        (WebKit::NetworkCache::Entry::sourceStorageEntry): Deleted.
     29        * NetworkProcess/cache/NetworkCacheStorage.cpp:
     30        (WebKit::NetworkCache::RecordMetaData::RecordMetaData):
     31        (WebKit::NetworkCache::decodeRecordMetaData):
     32        (WebKit::NetworkCache::decodeRecordHeader):
     33        (WebKit::NetworkCache::decodeRecord):
     34        (WebKit::NetworkCache::encodeRecordMetaData):
     35        (WebKit::NetworkCache::encodeRecordHeader):
     36        (WebKit::NetworkCache::Storage::dispatchReadOperation):
     37        (WebKit::NetworkCache::retrieveFromMemory):
     38        (WebKit::NetworkCache::Storage::store):
     39        (WebKit::NetworkCache::Storage::update):
     40        (WebKit::NetworkCache::Storage::traverse):
     41        (WebKit::NetworkCache::Storage::dispatchPendingWriteOperations):
     42        (WebKit::NetworkCache::Storage::dispatchFullWriteOperation):
     43        (WebKit::NetworkCache::Storage::dispatchHeaderWriteOperation):
     44        (WebKit::NetworkCache::EntryMetaData::EntryMetaData): Deleted.
     45        (WebKit::NetworkCache::decodeEntryMetaData): Deleted.
     46        (WebKit::NetworkCache::decodeEntryHeader): Deleted.
     47        (WebKit::NetworkCache::decodeEntry): Deleted.
     48        (WebKit::NetworkCache::encodeEntryMetaData): Deleted.
     49        (WebKit::NetworkCache::encodeEntryHeader): Deleted.
     50        * NetworkProcess/cache/NetworkCacheStorage.h:
     51
    1522015-03-26  Chris Dumez  <cdumez@apple.com>
    253

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp

    r182010 r182019  
    227227    unsigned priority = originalRequest.priority();
    228228
    229     m_storage->retrieve(storageKey, priority, [this, originalRequest, completionHandler, startTime, storageKey, webPageID](std::unique_ptr<Storage::Entry> storageEntry) {
    230         if (!storageEntry) {
     229    m_storage->retrieve(storageKey, priority, [this, originalRequest, completionHandler, startTime, storageKey, webPageID](std::unique_ptr<Storage::Record> record) {
     230        if (!record) {
    231231            LOG(NetworkCache, "(NetworkProcess) not found in storage");
    232232
    … …  
    238238        }
    239239
    240         ASSERT(storageEntry->key == storageKey);
    241 
    242         auto cacheEntry = Entry::decode(*storageEntry);
    243 
    244         auto useDecision = cacheEntry ? canUse(*cacheEntry, originalRequest) : UseDecision::NoDueToDecodeFailure;
     240        ASSERT(record->key == storageKey);
     241
     242        auto entry = Entry::decodeStorageRecord(*record);
     243
     244        auto useDecision = entry ? canUse(*entry, originalRequest) : UseDecision::NoDueToDecodeFailure;
    245245        switch (useDecision) {
    246246        case UseDecision::Use:
    247247            break;
    248248        case UseDecision::Validate:
    249             cacheEntry->setNeedsValidation();
     249            entry->setNeedsValidation();
    250250            break;
    251251        default:
    252             cacheEntry = nullptr;
     252            entry = nullptr;
    253253        };
    254254
    255255#if !LOG_DISABLED
    256256        auto elapsedMS = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - startTime).count();
    257 #endif
    258257        LOG(NetworkCache, "(NetworkProcess) retrieve complete useDecision=%d priority=%u time=%lldms", useDecision, originalRequest.priority(), elapsedMS);
    259         completionHandler(WTF::move(cacheEntry));
     258#endif
     259        completionHandler(WTF::move(entry));
    260260
    261261        if (m_statistics)
    … …  
    316316    Entry cacheEntry(makeCacheKey(originalRequest), response, WTF::move(responseData), collectVaryingRequestHeaders(originalRequest, response));
    317317
    318     auto storageEntry = cacheEntry.encode();
    319 
    320     m_storage->store(storageEntry, [completionHandler](bool success, const Data& bodyData) {
     318    auto record = cacheEntry.encodeAsStorageRecord();
     319
     320    m_storage->store(record, [completionHandler](bool success, const Data& bodyData) {
    321321        MappedBody mappedBody;
    322322#if ENABLE(SHAREABLE_RESOURCE)
    … …  
    342342    Entry updateEntry(existingEntry.key(), response, existingEntry.buffer(), collectVaryingRequestHeaders(originalRequest, response));
    343343
    344     auto updateStorageEntry = updateEntry.encode();
    345 
    346     m_storage->update(updateStorageEntry, existingEntry.sourceStorageEntry(), [](bool success, const Data&) {
     344    auto updateRecord = updateEntry.encodeAsStorageRecord();
     345
     346    m_storage->update(updateRecord, existingEntry.sourceStorageRecord(), [](bool success, const Data&) {
    347347        LOG(NetworkCache, "(NetworkProcess) updated, success=%d", success);
    348348    });
    … …  
    360360    ASSERT(isEnabled());
    361361
    362     m_storage->traverse([traverseHandler](const Storage::Entry* storageEntry) {
    363         if (!storageEntry) {
     362    m_storage->traverse([traverseHandler](const Storage::Record* record) {
     363        if (!record) {
    364364            traverseHandler(nullptr);
    365365            return;
    366366        }
    367367
    368         auto cacheEntry = Entry::decode(*storageEntry);
    369         if (!cacheEntry)
     368        auto entry = Entry::decodeStorageRecord(*record);
     369        if (!entry)
    370370            return;
    371371
    372         traverseHandler(cacheEntry.get());
     372        traverseHandler(entry.get());
    373373    });
    374374}
    … …  
    387387        return;
    388388    WebCore::writeToFile(dumpFileHandle, "[\n", 2);
    389     m_storage->traverse([dumpFileHandle](const Storage::Entry* entry) {
    390         if (!entry) {
     389    m_storage->traverse([dumpFileHandle](const Storage::Record* record) {
     390        if (!record) {
    391391            WebCore::writeToFile(dumpFileHandle, "{}\n]\n", 5);
    392392            auto handle = dumpFileHandle;
    … …  
    394394            return;
    395395        }
    396         auto cacheEntry = Entry::decode(*entry);
    397         if (!cacheEntry)
     396        auto entry = Entry::decodeStorageRecord(*record);
     397        if (!entry)
    398398            return;
    399399        StringBuilder json;
    400         cacheEntry->asJSON(json);
     400        entry->asJSON(json);
    401401        json.append(",\n");
    402402        auto writeData = json.toString().utf8();

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheEntry.cpp

    r181970 r182019  
    5050}
    5151
    52 Entry::Entry(const Storage::Entry& storageEntry)
     52Entry::Entry(const Storage::Record& storageEntry)
    5353    : m_key(storageEntry.key)
    5454    , m_timeStamp(storageEntry.timeStamp)
    55     , m_sourceStorageEntry(storageEntry)
     55    , m_sourceStorageRecord(storageEntry)
    5656{
    5757}
    5858
    59 Storage::Entry Entry::encode() const
     59Storage::Record Entry::encodeAsStorageRecord() const
    6060{
    6161    Encoder encoder;
    … …  
    7777}
    7878
    79 std::unique_ptr<Entry> Entry::decode(const Storage::Entry& storageEntry)
     79std::unique_ptr<Entry> Entry::decodeStorageRecord(const Storage::Record& storageEntry)
    8080{
    8181    std::unique_ptr<Entry> entry(new Entry(storageEntry));
    … …  
    103103}
    104104
    105 void Entry::initializeBufferFromStorageEntry() const
     105void Entry::initializeBufferFromStorageRecord() const
    106106{
    107     auto* data = m_sourceStorageEntry.body.data();
    108     size_t size = m_sourceStorageEntry.body.size();
     107    auto* data = m_sourceStorageRecord.body.data();
     108    size_t size = m_sourceStorageRecord.body.size();
    109109#if ENABLE(SHAREABLE_RESOURCE)
    110     RefPtr<SharedMemory> sharedMemory = m_sourceStorageEntry.body.isMap() ? SharedMemory::createFromVMBuffer(const_cast<uint8_t*>(data), size) : nullptr;
    111     RefPtr<ShareableResource> shareableResource = sharedMemory ? ShareableResource::create(sharedMemory.release(), 0, m_sourceStorageEntry.body.size()) : nullptr;
     110    RefPtr<SharedMemory> sharedMemory = m_sourceStorageRecord.body.isMap() ? SharedMemory::createFromVMBuffer(const_cast<uint8_t*>(data), size) : nullptr;
     111    RefPtr<ShareableResource> shareableResource = sharedMemory ? ShareableResource::create(sharedMemory.release(), 0, m_sourceStorageRecord.body.size()) : nullptr;
    112112
    113113    if (shareableResource && shareableResource->createHandle(m_shareableResourceHandle))
    … …  
    121121{
    122122    if (!m_buffer)
    123         initializeBufferFromStorageEntry();
     123        initializeBufferFromStorageRecord();
    124124
    125125    return m_buffer.get();
    … …  
    129129{
    130130    if (!m_buffer)
    131         initializeBufferFromStorageEntry();
     131        initializeBufferFromStorageRecord();
    132132
    133133    return m_shareableResourceHandle;

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheEntry.h

    r181970 r182019  
    4848    Entry(const Key&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&, const Vector<std::pair<String, String>>& varyingRequestHeaders);
    4949
    50     Storage::Entry encode() const;
    51     static std::unique_ptr<Entry> decode(const Storage::Entry&);
     50    Storage::Record encodeAsStorageRecord() const;
     51    static std::unique_ptr<Entry> decodeStorageRecord(const Storage::Record&);
    5252
    5353    const Key& key() const { return m_key; }
    … …  
    6464    void setNeedsValidation();
    6565
    66     const Storage::Entry& sourceStorageEntry() const { return m_sourceStorageEntry; }
     66    const Storage::Record& sourceStorageRecord() const { return m_sourceStorageRecord; }
    6767
    6868    void asJSON(StringBuilder&) const;
    6969
    7070private:
    71     Entry(const Storage::Entry&);
    72     void initializeBufferFromStorageEntry() const;
     71    Entry(const Storage::Record&);
     72    void initializeBufferFromStorageRecord() const;
    7373
    7474    Key m_key;
    … …  
    8282#endif
    8383
    84     Storage::Entry m_sourceStorageEntry { };
     84    Storage::Record m_sourceStorageRecord { };
    8585};
    8686

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheStorage.cpp

    r181895 r182019  
    132132}
    133133
    134 struct EntryMetaData {
    135     EntryMetaData() { }
    136     explicit EntryMetaData(const Key& key)
     134struct RecordMetaData {
     135    RecordMetaData() { }
     136    explicit RecordMetaData(const Key& key)
    137137        : cacheStorageVersion(Storage::version)
    138138        , key(key)
    … …  
    150150};
    151151
    152 static bool decodeEntryMetaData(EntryMetaData& metaData, const Data& fileData)
     152static bool decodeRecordMetaData(RecordMetaData& metaData, const Data& fileData)
    153153{
    154154    bool success = false;
    … …  
    179179}
    180180
    181 static bool decodeEntryHeader(const Data& fileData, EntryMetaData& metaData, Data& data)
    182 {
    183     if (!decodeEntryMetaData(metaData, fileData)) {
     181static bool decodeRecordHeader(const Data& fileData, RecordMetaData& metaData, Data& data)
     182{
     183    if (!decodeRecordMetaData(metaData, fileData)) {
    184184        LOG(NetworkCacheStorage, "(NetworkProcess) meta data decode failure");
    185185        return false;
    … …  
    204204}
    205205
    206 static std::unique_ptr<Storage::Entry> decodeEntry(const Data& fileData, int fd, const Key& key)
    207 {
    208     EntryMetaData metaData;
     206static std::unique_ptr<Storage::Record> decodeRecord(const Data& fileData, int fd, const Key& key)
     207{
     208    RecordMetaData metaData;
    209209    Data headerData;
    210     if (!decodeEntryHeader(fileData, metaData, headerData))
     210    if (!decodeRecordHeader(fileData, metaData, headerData))
    211211        return nullptr;
    212212
    … …  
    231231    }
    232232
    233     return std::make_unique<Storage::Entry>(Storage::Entry {
     233    return std::make_unique<Storage::Record>(Storage::Record {
    234234        metaData.key,
    235235        metaData.timeStamp,
    … …  
    239239}
    240240
    241 static Data encodeEntryMetaData(const EntryMetaData& entry)
     241static Data encodeRecordMetaData(const RecordMetaData& metaData)
    242242{
    243243    Encoder encoder;
    244244
    245     encoder << entry.cacheStorageVersion;
    246     encoder << entry.key;
    247     encoder << entry.timeStamp;
    248     encoder << entry.headerChecksum;
    249     encoder << entry.headerSize;
    250     encoder << entry.bodyChecksum;
    251     encoder << entry.bodySize;
     245    encoder << metaData.cacheStorageVersion;
     246    encoder << metaData.key;
     247    encoder << metaData.timeStamp;
     248    encoder << metaData.headerChecksum;
     249    encoder << metaData.headerSize;
     250    encoder << metaData.bodyChecksum;
     251    encoder << metaData.bodySize;
    252252
    253253    encoder.encodeChecksum();
    … …  
    256256}
    257257
    258 static Data encodeEntryHeader(const Storage::Entry& entry)
    259 {
    260     EntryMetaData metaData(entry.key);
    261     metaData.timeStamp = entry.timeStamp;
    262     metaData.headerChecksum = hashData(entry.header);
    263     metaData.headerSize = entry.header.size();
    264     metaData.bodyChecksum = hashData(entry.body);
    265     metaData.bodySize = entry.body.size();
    266 
    267     auto encodedMetaData = encodeEntryMetaData(metaData);
    268     auto headerData = concatenate(encodedMetaData, entry.header);
    269     if (!entry.body.size())
     258static Data encodeRecordHeader(const Storage::Record& record)
     259{
     260    RecordMetaData metaData(record.key);
     261    metaData.timeStamp = record.timeStamp;
     262    metaData.headerChecksum = hashData(record.header);
     263    metaData.headerSize = record.header.size();
     264    metaData.bodyChecksum = hashData(record.body);
     265    metaData.bodySize = record.body.size();
     266
     267    auto encodedMetaData = encodeRecordMetaData(metaData);
     268    auto headerData = concatenate(encodedMetaData, record.header);
     269    if (!record.body.size())
    270270        return { headerData };
    271271
    … …  
    314314                read.completionHandler(nullptr);
    315315            } else {
    316                 auto entry = decodeEntry(fileData, channel->fileDescriptor(), read.key);
    317                 bool success = read.completionHandler(WTF::move(entry));
     316                auto record = decodeRecord(fileData, channel->fileDescriptor(), read.key);
     317                bool success = read.completionHandler(WTF::move(record));
    318318                if (success)
    319319                    updateFileAccessTime(*channel);
    … …  
    355355{
    356356    for (auto& operation : operations) {
    357         if (operation->entry.key == key) {
     357        if (operation->record.key == key) {
    358358            LOG(NetworkCacheStorage, "(NetworkProcess) found write operation in progress");
    359             auto entry = operation->entry;
    360             RunLoop::main().dispatch([entry, completionHandler] {
    361                 completionHandler(std::make_unique<Storage::Entry>(entry));
     359            auto record = operation->record;
     360            RunLoop::main().dispatch([record, completionHandler] {
     361                completionHandler(std::make_unique<Storage::Record>(record));
    362362            });
    363363            return true;
    … …  
    392392}
    393393
    394 void Storage::store(const Entry& entry, StoreCompletionHandler&& completionHandler)
    395 {
    396     ASSERT(RunLoop::isMain());
    397     ASSERT(!entry.key.isNull());
     394void Storage::store(const Record& record, StoreCompletionHandler&& completionHandler)
     395{
     396    ASSERT(RunLoop::isMain());
     397    ASSERT(!record.key.isNull());
    398398
    399399    if (!m_maximumSize) {
    … …  
    402402    }
    403403
    404     m_pendingWriteOperations.append(new WriteOperation { entry, { }, WTF::move(completionHandler) });
     404    m_pendingWriteOperations.append(new WriteOperation { record, { }, WTF::move(completionHandler) });
    405405
    406406    // Add key to the filter already here as we do lookups from the pending operations too.
    407     m_contentsFilter.add(entry.key.shortHash());
     407    m_contentsFilter.add(record.key.shortHash());
    408408
    409409    dispatchPendingWriteOperations();
    410410}
    411411
    412 void Storage::update(const Entry& updateEntry, const Entry& existingEntry, StoreCompletionHandler&& completionHandler)
    413 {
    414     ASSERT(RunLoop::isMain());
    415     ASSERT(!existingEntry.key.isNull());
    416     ASSERT(existingEntry.key == updateEntry.key);
     412void Storage::update(const Record& updateRecord, const Record& existingRecord, StoreCompletionHandler&& completionHandler)
     413{
     414    ASSERT(RunLoop::isMain());
     415    ASSERT(!existingRecord.key.isNull());
     416    ASSERT(existingRecord.key == updateRecord.key);
    417417
    418418    if (!m_maximumSize) {
    … …  
    421421    }
    422422
    423     m_pendingWriteOperations.append(new WriteOperation { updateEntry, existingEntry, WTF::move(completionHandler) });
     423    m_pendingWriteOperations.append(new WriteOperation { updateRecord, existingRecord, WTF::move(completionHandler) });
    424424
    425425    dispatchPendingWriteOperations();
    426426}
    427427
    428 void Storage::traverse(std::function<void (const Entry*)>&& traverseHandler)
     428void Storage::traverse(std::function<void (const Record*)>&& traverseHandler)
    429429{
    430430    StringCapture cachePathCapture(m_directoryPath);
    … …  
    437437            // FIXME: Traversal is slower than it should be due to lack of parallelism.
    438438            channel->readSync(0, headerReadSize, [this, &traverseHandler](Data& fileData, int) {
    439                 EntryMetaData metaData;
     439                RecordMetaData metaData;
    440440                Data headerData;
    441                 if (decodeEntryHeader(fileData, metaData, headerData)) {
    442                     Entry entry { metaData.key, metaData.timeStamp, headerData, { } };
    443                     traverseHandler(&entry);
     441                if (decodeRecordHeader(fileData, metaData, headerData)) {
     442                    Record record { metaData.key, metaData.timeStamp, headerData, { } };
     443                    traverseHandler(&record);
    444444                }
    445445            });
    … …  
    466466        m_activeWriteOperations.add(WTF::move(writeOperation));
    467467
    468         if (write.existingEntry && cacheMayContain(write.entry.key.shortHash())) {
     468        if (write.existingRecord && cacheMayContain(write.record.key.shortHash())) {
    469469            dispatchHeaderWriteOperation(write);
    470470            continue;
    … …  
    479479    ASSERT(m_activeWriteOperations.contains(&write));
    480480
    481     if (!m_contentsFilter.mayContain(write.entry.key.shortHash()))
    482         m_contentsFilter.add(write.entry.key.shortHash());
     481    if (!m_contentsFilter.mayContain(write.record.key.shortHash()))
     482        m_contentsFilter.add(write.record.key.shortHash());
    483483
    484484    StringCapture cachePathCapture(m_directoryPath);
    485485    backgroundIOQueue().dispatch([this, &write, cachePathCapture] {
    486         auto encodedHeader = encodeEntryHeader(write.entry);
    487         auto headerAndBodyData = concatenate(encodedHeader, write.entry.body);
    488 
    489         auto channel = openFileForKey(write.entry.key, IOChannel::Type::Create, cachePathCapture.string());
     486        auto encodedHeader = encodeRecordHeader(write.record);
     487        auto headerAndBodyData = concatenate(encodedHeader, write.record.body);
     488
     489        auto channel = openFileForKey(write.record.key, IOChannel::Type::Create, cachePathCapture.string());
    490490        int fd = channel->fileDescriptor();
    491491        size_t bodyOffset = encodedHeader.size();
    … …  
    494494            LOG(NetworkCacheStorage, "(NetworkProcess) write complete error=%d", error);
    495495            if (error) {
    496                 if (m_contentsFilter.mayContain(write.entry.key.shortHash()))
    497                     m_contentsFilter.remove(write.entry.key.shortHash());
     496                if (m_contentsFilter.mayContain(write.record.key.shortHash()))
     497                    m_contentsFilter.remove(write.record.key.shortHash());
    498498            }
    499             size_t bodySize = write.entry.body.size();
     499            size_t bodySize = write.record.body.size();
    500500            size_t totalSize = bodyOffset + bodySize;
    501501
    … …  
    519519{
    520520    ASSERT(RunLoop::isMain());
    521     ASSERT(write.existingEntry);
     521    ASSERT(write.existingRecord);
    522522    ASSERT(m_activeWriteOperations.contains(&write));
    523     ASSERT(cacheMayContain(write.entry.key.shortHash()));
     523    ASSERT(cacheMayContain(write.record.key.shortHash()));
    524524
    525525    // Try to update the header of an existing entry.
    526526    StringCapture cachePathCapture(m_directoryPath);
    527527    backgroundIOQueue().dispatch([this, &write, cachePathCapture] {
    528         auto headerData = encodeEntryHeader(write.entry);
    529         auto existingHeaderData = encodeEntryHeader(write.existingEntry.value());
     528        auto headerData = encodeRecordHeader(write.record);
     529        auto existingHeaderData = encodeRecordHeader(write.existingRecord.value());
    530530
    531531        bool pageRoundedHeaderSizeChanged = headerData.size() != existingHeaderData.size();
    … …  
    538538        }
    539539
    540         auto channel = openFileForKey(write.entry.key, IOChannel::Type::Write, cachePathCapture.string());
     540        auto channel = openFileForKey(write.record.key, IOChannel::Type::Write, cachePathCapture.string());
    541541        channel->write(0, headerData, [this, &write](int error) {
    542542            LOG(NetworkCacheStorage, "(NetworkProcess) update complete error=%d", error);
    543543
    544544            if (error)
    545                 remove(write.entry.key);
     545                remove(write.record.key);
    546546
    547547            write.completionHandler(!error, { });

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheStorage.h

    r181816 r182019  
    4848    static std::unique_ptr<Storage> open(const String& cachePath);
    4949
    50     struct Entry {
     50    struct Record {
    5151        Key key;
    5252        std::chrono::milliseconds timeStamp;
    … …  
    5555    };
    5656    // This may call completion handler synchronously on failure.
    57     typedef std::function<bool (std::unique_ptr<Entry>)> RetrieveCompletionHandler;
     57    typedef std::function<bool (std::unique_ptr<Record>)> RetrieveCompletionHandler;
    5858    void retrieve(const Key&, unsigned priority, RetrieveCompletionHandler&&);
    5959
    6060    typedef std::function<void (bool success, const Data& mappedBody)> StoreCompletionHandler;
    61     void store(const Entry&, StoreCompletionHandler&&);
    62     void update(const Entry& updateEntry, const Entry& existingEntry, StoreCompletionHandler&&);
     61    void store(const Record&, StoreCompletionHandler&&);
     62    void update(const Record& updateRecord, const Record& existingRecord, StoreCompletionHandler&&);
    6363
    6464    void remove(const Key&);
    6565
    6666    // Null entry signals end.
    67     void traverse(std::function<void (const Entry*)>&&);
     67    void traverse(std::function<void (const Record*)>&&);
    6868
    6969    void setMaximumSize(size_t);
    … …  
    9090
    9191    struct WriteOperation {
    92         Entry entry;
    93         Optional<Entry> existingEntry;
     92        Record record;
     93        Optional<Record> existingRecord;
    9494        StoreCompletionHandler completionHandler;
    9595    };
Note: See TracChangeset for help on using the changeset viewer.