Changeset 181970 in webkit


Ignore:
Timestamp:
Mar 25, 2015 1:59:18 PM (9 years ago)
Author:
Antti Koivisto
Message:

Separate entry decoding from validation
​https://bugs.webkit.org/show_bug.cgi?id=143052

Reviewed by Chris Dumez.

Make NetworkCache::Cache a class and move it to a file of its own.
Move the encoding/decoding code there.

  • NetworkProcess/NetworkProcess.cpp:

(WebKit::fetchDiskCacheEntries):
(WebKit::clearDiskCacheEntries):

  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::sendReplyToSynchronousRequest):
(WebKit::NetworkResourceLoader::start):
(WebKit::NetworkResourceLoader::sendBufferMaybeAborting):
(WebKit::NetworkResourceLoader::didRetrieveCacheEntry):
(WebKit::NetworkResourceLoader::validateCacheEntry):

  • NetworkProcess/NetworkResourceLoader.h:
  • NetworkProcess/cache/NetworkCache.cpp:

(WebKit::NetworkCache::collectVaryingRequestHeaders):
(WebKit::NetworkCache::canUse):

Focused function for deciding if we can use a cache entry and if it needs validation.

(WebKit::NetworkCache::Cache::retrieve):
(WebKit::NetworkCache::Cache::store):
(WebKit::NetworkCache::Cache::update):
(WebKit::NetworkCache::Cache::traverse):
(WebKit::NetworkCache::encodeStorageEntry): Deleted.
(WebKit::NetworkCache::decodeStorageEntry): Deleted.

  • NetworkProcess/cache/NetworkCache.h:
  • NetworkProcess/cache/NetworkCacheEntry.cpp: Added.

(WebKit::NetworkCache::Entry::Entry):
(WebKit::NetworkCache::Entry::encode):
(WebKit::NetworkCache::Entry::decode):
(WebKit::NetworkCache::Entry::initializeBufferFromStorageEntry):
(WebKit::NetworkCache::Entry::buffer):
(WebKit::NetworkCache::Entry::shareableResourceHandle):
(WebKit::NetworkCache::Entry::needsValidation):
(WebKit::NetworkCache::Entry::setNeedsValidation):

  • NetworkProcess/cache/NetworkCacheEntry.h: Added.

(WebKit::NetworkCache::Entry::key):
(WebKit::NetworkCache::Entry::timeStamp):
(WebKit::NetworkCache::Entry::response):
(WebKit::NetworkCache::Entry::varyingRequestHeaders):
(WebKit::NetworkCache::Entry::sourceStorageEntry):

  • NetworkProcess/cache/NetworkCacheStatistics.h:
  • NetworkProcess/cache/NetworkCacheStatisticsCocoa.mm:

(WebKit::NetworkCache::cachedEntryReuseFailureToDiagnosticKey):
(WebKit::NetworkCache::Statistics::recordRetrievedCachedEntry):

  • WebKit2.xcodeproj/project.pbxproj:
Location:
trunk/Source/WebKit2
Files:
2 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r181959 r181970  
     12015-03-25  Antti Koivisto  <antti@apple.com>
     2
     3        Separate entry decoding from validation
     4        https://bugs.webkit.org/show_bug.cgi?id=143052
     5
     6        Reviewed by Chris Dumez.
     7
     8        Make NetworkCache::Cache a class and move it to a file of its own.
     9        Move the encoding/decoding code there.
     10
     11        * NetworkProcess/NetworkProcess.cpp:
     12        (WebKit::fetchDiskCacheEntries):
     13        (WebKit::clearDiskCacheEntries):
     14        * NetworkProcess/NetworkResourceLoader.cpp:
     15        (WebKit::sendReplyToSynchronousRequest):
     16        (WebKit::NetworkResourceLoader::start):
     17        (WebKit::NetworkResourceLoader::sendBufferMaybeAborting):
     18        (WebKit::NetworkResourceLoader::didRetrieveCacheEntry):
     19        (WebKit::NetworkResourceLoader::validateCacheEntry):
     20        * NetworkProcess/NetworkResourceLoader.h:
     21        * NetworkProcess/cache/NetworkCache.cpp:
     22        (WebKit::NetworkCache::collectVaryingRequestHeaders):
     23        (WebKit::NetworkCache::canUse):
     24
     25            Focused function for deciding if we can use a cache entry and if it needs validation.
     26
     27        (WebKit::NetworkCache::Cache::retrieve):
     28        (WebKit::NetworkCache::Cache::store):
     29        (WebKit::NetworkCache::Cache::update):
     30        (WebKit::NetworkCache::Cache::traverse):
     31        (WebKit::NetworkCache::encodeStorageEntry): Deleted.
     32        (WebKit::NetworkCache::decodeStorageEntry): Deleted.
     33        * NetworkProcess/cache/NetworkCache.h:
     34        * NetworkProcess/cache/NetworkCacheEntry.cpp: Added.
     35        (WebKit::NetworkCache::Entry::Entry):
     36        (WebKit::NetworkCache::Entry::encode):
     37        (WebKit::NetworkCache::Entry::decode):
     38        (WebKit::NetworkCache::Entry::initializeBufferFromStorageEntry):
     39        (WebKit::NetworkCache::Entry::buffer):
     40        (WebKit::NetworkCache::Entry::shareableResourceHandle):
     41        (WebKit::NetworkCache::Entry::needsValidation):
     42        (WebKit::NetworkCache::Entry::setNeedsValidation):
     43        * NetworkProcess/cache/NetworkCacheEntry.h: Added.
     44        (WebKit::NetworkCache::Entry::key):
     45        (WebKit::NetworkCache::Entry::timeStamp):
     46        (WebKit::NetworkCache::Entry::response):
     47        (WebKit::NetworkCache::Entry::varyingRequestHeaders):
     48        (WebKit::NetworkCache::Entry::sourceStorageEntry):
     49        * NetworkProcess/cache/NetworkCacheStatistics.h:
     50        * NetworkProcess/cache/NetworkCacheStatisticsCocoa.mm:
     51        (WebKit::NetworkCache::cachedEntryReuseFailureToDiagnosticKey):
     52        (WebKit::NetworkCache::Statistics::recordRetrievedCachedEntry):
     53        * WebKit2.xcodeproj/project.pbxproj:
     54
    1552015-03-25  David Hyatt  <hyatt@apple.com>
    256

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

    r181775 r181970  
    288288            }
    289289
    290             origins->add(SecurityOrigin::create(entry->response.url()));
     290            origins->add(SecurityOrigin::create(entry->response().url()));
    291291        });
    292292
    … …  
    380380
    381381            if (entry) {
    382                 if (originsToDelete->contains(SecurityOrigin::create(entry->response.url())))
    383                     cacheKeysToDelete->append(entry->storageEntry.key);
     382                if (originsToDelete->contains(SecurityOrigin::create(entry->response().url())))
     383                    cacheKeysToDelete->append(entry->key());
    384384                return;
    385385            }

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp

    r181688 r181970  
    7070};
    7171
    72 static void sendReplyToSynchronousRequest(NetworkResourceLoader::SynchronousLoadData& data, WebCore::SharedBuffer* buffer)
     72static void sendReplyToSynchronousRequest(NetworkResourceLoader::SynchronousLoadData& data, const WebCore::SharedBuffer* buffer)
    7373{
    7474    ASSERT(data.delayedReply);
    … …  
    151151            return;
    152152        }
    153         if (loader->m_parameters.needsCertificateInfo && !entry->response.containsCertificateInfo()) {
     153        if (loader->m_parameters.needsCertificateInfo && !entry->response().containsCertificateInfo()) {
    154154            loader->startNetworkLoad();
    155155            return;
    156156        }
    157         if (entry->needsRevalidation) {
     157        if (entry->needsValidation()) {
    158158            loader->validateCacheEntry(WTF::move(entry));
    159159            return;
    … …  
    530530}
    531531
    532 bool NetworkResourceLoader::sendBufferMaybeAborting(WebCore::SharedBuffer& buffer, size_t encodedDataLength)
     532bool NetworkResourceLoader::sendBufferMaybeAborting(const WebCore::SharedBuffer& buffer, size_t encodedDataLength)
    533533{
    534534    ASSERT(!isSynchronous());
    … …  
    536536#if PLATFORM(COCOA)
    537537    ShareableResource::Handle shareableResourceHandle;
    538     NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(shareableResourceHandle, buffer);
     538    NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(shareableResourceHandle, const_cast<WebCore::SharedBuffer&>(buffer));
    539539    if (!shareableResourceHandle.isNull()) {
    540540        send(Messages::WebResourceLoader::DidReceiveResource(shareableResourceHandle, currentTime()));
    … …  
    544544#endif
    545545
    546     IPC::SharedBufferDataReference dataReference(&buffer);
     546    IPC::SharedBufferDataReference dataReference(&const_cast<WebCore::SharedBuffer&>(buffer));
    547547    return sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength));
    548548}
    … …  
    552552{
    553553    if (isSynchronous()) {
    554         m_synchronousLoadData->response = entry->response;
    555         sendReplyToSynchronousRequest(*m_synchronousLoadData, entry->buffer.get());
     554        m_synchronousLoadData->response = entry->response();
     555        sendReplyToSynchronousRequest(*m_synchronousLoadData, entry->buffer());
    556556    } else {
    557         sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponse(entry->response, m_parameters.isMainResource));
     557        sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponse(entry->response(), m_parameters.isMainResource));
    558558
    559559#if ENABLE(SHAREABLE_RESOURCE)
    560         if (!entry->shareableResourceHandle.isNull())
    561             send(Messages::WebResourceLoader::DidReceiveResource(entry->shareableResourceHandle, currentTime()));
     560        if (!entry->shareableResourceHandle().isNull())
     561            send(Messages::WebResourceLoader::DidReceiveResource(entry->shareableResourceHandle(), currentTime()));
    562562        else {
    563563#endif
    564             bool shouldContinue = sendBufferMaybeAborting(*entry->buffer, entry->buffer->size());
     564            bool shouldContinue = sendBufferMaybeAborting(*entry->buffer(), entry->buffer()->size());
    565565            if (!shouldContinue)
    566566                return;
    … …  
    578578    ASSERT(!m_handle);
    579579
    580     String eTag = entry->response.httpHeaderField(WebCore::HTTPHeaderName::ETag);
    581     String lastModified = entry->response.httpHeaderField(WebCore::HTTPHeaderName::LastModified);
     580    String eTag = entry->response().httpHeaderField(WebCore::HTTPHeaderName::ETag);
     581    String lastModified = entry->response().httpHeaderField(WebCore::HTTPHeaderName::LastModified);
    582582    if (!eTag.isEmpty())
    583583        m_currentRequest.setHTTPHeaderField(WebCore::HTTPHeaderName::IfNoneMatch, eTag);

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h

    r179373 r181970  
    162162    void startBufferingTimerIfNeeded();
    163163    void bufferingTimerFired();
    164     bool sendBufferMaybeAborting(WebCore::SharedBuffer&, size_t encodedDataLength);
     164    bool sendBufferMaybeAborting(const WebCore::SharedBuffer&, size_t encodedDataLength);
    165165
    166166    bool isSynchronous() const;

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

    r181926 r181970  
    3030
    3131#include "Logging.h"
    32 #include "NetworkCacheCoders.h"
    3332#include "NetworkCacheStatistics.h"
    3433#include "NetworkCacheStorage.h"
    35 #include "NetworkResourceLoader.h"
    36 #include "WebCoreArgumentCoders.h"
    37 #include <JavaScriptCore/JSONObject.h>
    3834#include <WebCore/CacheValidation.h>
    3935#include <WebCore/FileSystem.h>
    … …  
    4137#include <WebCore/NetworkStorageSession.h>
    4238#include <WebCore/PlatformCookieJar.h>
     39#include <WebCore/ResourceRequest.h>
    4340#include <WebCore/ResourceResponse.h>
    4441#include <WebCore/SharedBuffer.h>
    4542#include <wtf/NeverDestroyed.h>
    46 #include <wtf/StringHasher.h>
    4743#include <wtf/text/StringBuilder.h>
    4844
    … …  
    111107}
    112108
    113 static Storage::Entry encodeStorageEntry(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response, PassRefPtr<WebCore::SharedBuffer> responseData)
    114 {
    115     Encoder encoder;
    116     encoder << response;
    117 
     109static Vector<std::pair<String, String>> collectVaryingRequestHeaders(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
     110{
    118111    String varyValue = response.httpHeaderField(WebCore::HTTPHeaderName::Vary);
    119     bool hasVaryingRequestHeaders = !varyValue.isEmpty();
    120 
    121     encoder << hasVaryingRequestHeaders;
    122 
    123     if (hasVaryingRequestHeaders) {
    124         Vector<String> varyingHeaderNames;
    125         varyValue.split(',', false, varyingHeaderNames);
    126 
    127         Vector<std::pair<String, String>> varyingRequestHeaders;
    128         for (auto& varyHeaderName : varyingHeaderNames) {
    129             String headerName = varyHeaderName.stripWhiteSpace();
    130             String headerValue = headerValueForVary(request, headerName);
    131             varyingRequestHeaders.append(std::make_pair(headerName, headerValue));
    132         }
    133         encoder << varyingRequestHeaders;
    134     }
    135     encoder.encodeChecksum();
    136 
    137     auto timeStamp = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch());
    138     Data header(encoder.buffer(), encoder.bufferSize());
    139     Data body;
    140     if (responseData)
    141         body = { reinterpret_cast<const uint8_t*>(responseData->data()), responseData->size() };
    142 
    143     return { makeCacheKey(request), timeStamp, header, body };
     112    if (varyValue.isEmpty())
     113        return { };
     114    Vector<String> varyingHeaderNames;
     115    varyValue.split(',', /*allowEmptyEntries*/ false, varyingHeaderNames);
     116    Vector<std::pair<String, String>> varyingRequestHeaders;
     117    varyingRequestHeaders.reserveCapacity(varyingHeaderNames.size());
     118    for (auto& varyHeaderName : varyingHeaderNames) {
     119        String headerName = varyHeaderName.stripWhiteSpace();
     120        String headerValue = headerValueForVary(request, headerName);
     121        varyingRequestHeaders.append(std::make_pair(headerName, headerValue));
     122    }
     123    return varyingRequestHeaders;
    144124}
    145125
    … …  
    171151}
    172152
    173 static std::unique_ptr<Entry> decodeStorageEntry(const Storage::Entry& storageEntry, const WebCore::ResourceRequest& request, CachedEntryReuseFailure& failure)
    174 {
    175     Decoder decoder(storageEntry.header.data(), storageEntry.header.size());
    176 
    177     WebCore::ResourceResponse cachedResponse;
    178     if (!decoder.decode(cachedResponse)) {
    179         LOG(NetworkCache, "(NetworkProcess) response decoding failed\n");
    180         failure = CachedEntryReuseFailure::Other;
    181         return nullptr;
    182     }
    183 
    184     bool hasVaryingRequestHeaders;
    185     if (!decoder.decode(hasVaryingRequestHeaders)) {
    186         failure = CachedEntryReuseFailure::Other;
    187         return nullptr;
    188     }
    189 
    190     if (hasVaryingRequestHeaders) {
    191         Vector<std::pair<String, String>> varyingRequestHeaders;
    192         if (!decoder.decode(varyingRequestHeaders)) {
    193             failure = CachedEntryReuseFailure::Other;
    194             return nullptr;
    195         }
    196 
    197         if (!verifyVaryingRequestHeaders(varyingRequestHeaders, request)) {
    198             LOG(NetworkCache, "(NetworkProcess) varying header mismatch\n");
    199             failure = CachedEntryReuseFailure::VaryingHeaderMismatch;
    200             return nullptr;
    201         }
    202     }
    203     if (!decoder.verifyChecksum()) {
    204         LOG(NetworkCache, "(NetworkProcess) checksum verification failure\n");
    205         failure = CachedEntryReuseFailure::Other;
    206         return nullptr;
     153static UseDecision canUse(const Entry& entry, const WebCore::ResourceRequest& request)
     154{
     155    if (!verifyVaryingRequestHeaders(entry.varyingRequestHeaders(), request)) {
     156        LOG(NetworkCache, "(NetworkProcess) varying header mismatch\n");
     157        return UseDecision::NoDueToVaryingHeaderMismatch;
    207158    }
    208159
    209160    bool allowExpired = cachePolicyAllowsExpired(request.cachePolicy());
    210     auto timeStamp = std::chrono::duration_cast<std::chrono::duration<double>>(storageEntry.timeStamp);
    211     double age = WebCore::computeCurrentAge(cachedResponse, timeStamp.count());
    212     double lifetime = WebCore::computeFreshnessLifetimeForHTTPFamily(cachedResponse, timeStamp.count());
     161    auto doubleTimeStamp = std::chrono::duration<double>(entry.timeStamp());
     162    double age = WebCore::computeCurrentAge(entry.response(), doubleTimeStamp.count());
     163    double lifetime = WebCore::computeFreshnessLifetimeForHTTPFamily(entry.response(), doubleTimeStamp.count());
    213164    bool isExpired = age > lifetime;
    214165    // We never revalidate in the case of a history navigation (i.e. allowExpired is true).
    215     bool needsRevalidation = !allowExpired && (cachedResponse.cacheControlContainsNoCache() || isExpired);
    216 
    217     if (needsRevalidation) {
    218         bool hasValidatorFields = cachedResponse.hasCacheValidatorFields();
    219         LOG(NetworkCache, "(NetworkProcess) needsRevalidation hasValidatorFields=%d isExpired=%d age=%f lifetime=%f", isExpired, hasValidatorFields, age, lifetime);
    220         if (!hasValidatorFields) {
    221             failure = CachedEntryReuseFailure::MissingValidatorFields;
    222             return nullptr;
    223         }
    224     }
    225 
    226     auto entry = std::make_unique<Entry>();
    227     entry->storageEntry = storageEntry;
    228     entry->needsRevalidation = needsRevalidation;
    229 
    230     cachedResponse.setSource(needsRevalidation ? WebCore::ResourceResponse::Source::DiskCacheAfterValidation : WebCore::ResourceResponse::Source::DiskCache);
    231     entry->response = cachedResponse;
    232 
    233 #if ENABLE(SHAREABLE_RESOURCE)
    234     RefPtr<SharedMemory> sharedMemory = storageEntry.body.isMap() ? SharedMemory::createFromVMBuffer(const_cast<uint8_t*>(storageEntry.body.data()), storageEntry.body.size()) : nullptr;
    235     RefPtr<ShareableResource> shareableResource = sharedMemory ? ShareableResource::create(sharedMemory.release(), 0, storageEntry.body.size()) : nullptr;
    236 
    237     if (shareableResource && shareableResource->createHandle(entry->shareableResourceHandle))
    238         entry->buffer = entry->shareableResourceHandle.tryWrapInSharedBuffer();
    239     else
    240 #endif
    241         entry->buffer = WebCore::SharedBuffer::create(storageEntry.body.data(), storageEntry.body.size());
    242 
    243     return entry;
     166    bool needsRevalidation = !allowExpired && (entry.response().cacheControlContainsNoCache() || isExpired);
     167    if (!needsRevalidation)
     168        return UseDecision::Use;
     169
     170    bool hasValidatorFields = entry.response().hasCacheValidatorFields();
     171    LOG(NetworkCache, "(NetworkProcess) needsRevalidation hasValidatorFields=%d isExpired=%d age=%f lifetime=%f", isExpired, hasValidatorFields, age, lifetime);
     172    if (!hasValidatorFields)
     173        return UseDecision::NoDueToMissingValidatorFields;
     174
     175    return UseDecision::Validate;
    244176}
    245177
    … …  
    281213    unsigned priority = originalRequest.priority();
    282214
    283     m_storage->retrieve(storageKey, priority, [this, originalRequest, completionHandler, startTime, storageKey, webPageID](std::unique_ptr<Storage::Entry> entry) {
    284         if (!entry) {
     215    m_storage->retrieve(storageKey, priority, [this, originalRequest, completionHandler, startTime, storageKey, webPageID](std::unique_ptr<Storage::Entry> storageEntry) {
     216        if (!storageEntry) {
    285217            LOG(NetworkCache, "(NetworkProcess) not found in storage");
    286218
    … …  
    291223            return false;
    292224        }
    293         ASSERT(entry->key == storageKey);
    294 
    295         CachedEntryReuseFailure failure = CachedEntryReuseFailure::None;
    296         auto decodedEntry = decodeStorageEntry(*entry, originalRequest, failure);
    297         bool success = !!decodedEntry;
    298         if (m_statistics)
    299             m_statistics->recordRetrievedCachedEntry(webPageID, storageKey, originalRequest, failure);
     225
     226        ASSERT(storageEntry->key == storageKey);
     227
     228        auto cacheEntry = Entry::decode(*storageEntry);
     229
     230        auto useDecision = cacheEntry ? canUse(*cacheEntry, originalRequest) : UseDecision::NoDueToDecodeFailure;
     231        switch (useDecision) {
     232        case UseDecision::Use:
     233            break;
     234        case UseDecision::Validate:
     235            cacheEntry->setNeedsValidation();
     236            break;
     237        default:
     238            cacheEntry = nullptr;
     239        };
    300240
    301241#if !LOG_DISABLED
    302242        auto elapsedMS = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - startTime).count();
    303243#endif
    304         LOG(NetworkCache, "(NetworkProcess) retrieve complete success=%d priority=%u time=%lldms", success, originalRequest.priority(), elapsedMS);
    305         completionHandler(WTF::move(decodedEntry));
    306         return success;
     244        LOG(NetworkCache, "(NetworkProcess) retrieve complete useDecision=%d priority=%u time=%lldms", useDecision, originalRequest.priority(), elapsedMS);
     245        completionHandler(WTF::move(cacheEntry));
     246
     247        if (m_statistics)
     248            m_statistics->recordRetrievedCachedEntry(webPageID, storageKey, originalRequest, useDecision);
     249        return useDecision != UseDecision::NoDueToDecodeFailure;
    307250    });
    308251}
    … …  
    357300    }
    358301
    359     auto storageEntry = encodeStorageEntry(originalRequest, response, WTF::move(responseData));
     302    Entry cacheEntry(makeCacheKey(originalRequest), response, WTF::move(responseData), collectVaryingRequestHeaders(originalRequest, response));
     303
     304    auto storageEntry = cacheEntry.encode();
    360305
    361306    m_storage->store(storageEntry, [completionHandler](bool success, const Data& bodyData) {
    … …  
    374319}
    375320
    376 void Cache::update(const WebCore::ResourceRequest& originalRequest, const Entry& entry, const WebCore::ResourceResponse& validatingResponse)
     321void Cache::update(const WebCore::ResourceRequest& originalRequest, const Entry& existingEntry, const WebCore::ResourceResponse& validatingResponse)
    377322{
    378323    LOG(NetworkCache, "(NetworkProcess) updating %s", originalRequest.url().string().latin1().data());
    379324
    380     WebCore::ResourceResponse response = entry.response;
     325    WebCore::ResourceResponse response = existingEntry.response();
    381326    WebCore::updateResponseHeadersAfterRevalidation(response, validatingResponse);
    382327
    383     auto updateEntry = encodeStorageEntry(originalRequest, response, entry.buffer);
    384 
    385     m_storage->update(updateEntry, entry.storageEntry, [](bool success, const Data&) {
     328    Entry updateEntry(existingEntry.key(), response, existingEntry.buffer(), collectVaryingRequestHeaders(originalRequest, response));
     329
     330    auto updateStorageEntry = updateEntry.encode();
     331
     332    m_storage->update(updateStorageEntry, existingEntry.sourceStorageEntry(), [](bool success, const Data&) {
    386333        LOG(NetworkCache, "(NetworkProcess) updated, success=%d", success);
    387334    });
    … …  
    399346    ASSERT(isEnabled());
    400347
    401     m_storage->traverse([traverseHandler](const Storage::Entry* entry) {
    402         if (!entry) {
     348    m_storage->traverse([traverseHandler](const Storage::Entry* storageEntry) {
     349        if (!storageEntry) {
    403350            traverseHandler(nullptr);
    404351            return;
    405352        }
    406353
    407         Entry cacheEntry;
    408         cacheEntry.storageEntry = *entry;
    409 
    410         Decoder decoder(cacheEntry.storageEntry.header.data(), cacheEntry.storageEntry.header.size());
    411         if (!decoder.decode(cacheEntry.response))
     354        auto cacheEntry = Entry::decode(*storageEntry);
     355        if (!cacheEntry)
    412356            return;
    413357
    414         traverseHandler(&cacheEntry);
     358        traverseHandler(cacheEntry.get());
    415359    });
    416360}
    … …  
    419363{
    420364    return WebCore::pathByAppendingComponent(m_storage->baseDirectoryPath(), "dump.json");
    421 }
    422 
    423 static bool entryAsJSON(StringBuilder& json, const Storage::Entry& entry)
    424 {
    425     Decoder decoder(entry.header.data(), entry.header.size());
    426     WebCore::ResourceResponse cachedResponse;
    427     if (!decoder.decode(cachedResponse))
    428         return false;
    429     json.append("{\n");
    430     json.append("\"hash\": ");
    431     JSC::appendQuotedJSONStringToBuilder(json, entry.key.hashAsString());
    432     json.append(",\n");
    433     json.append("\"partition\": ");
    434     JSC::appendQuotedJSONStringToBuilder(json, entry.key.partition());
    435     json.append(",\n");
    436     json.append("\"timestamp\": ");
    437     json.appendNumber(entry.timeStamp.count());
    438     json.append(",\n");
    439     json.append("\"URL\": ");
    440     JSC::appendQuotedJSONStringToBuilder(json, cachedResponse.url().string());
    441     json.append(",\n");
    442     json.append("\"headers\": {\n");
    443     bool firstHeader = true;
    444     for (auto& header : cachedResponse.httpHeaderFields()) {
    445         if (!firstHeader)
    446             json.append(",\n");
    447         firstHeader = false;
    448         json.append("    ");
    449         JSC::appendQuotedJSONStringToBuilder(json, header.key);
    450         json.append(": ");
    451         JSC::appendQuotedJSONStringToBuilder(json, header.value);
    452     }
    453     json.append("\n}\n");
    454     json.append("}");
    455     return true;
    456365}
    457366
    … …  
    471380            return;
    472381        }
     382        auto cacheEntry = Entry::decode(*entry);
     383        if (!cacheEntry)
     384            return;
    473385        StringBuilder json;
    474         if (!entryAsJSON(json, *entry))
    475             return;
     386        cacheEntry->asJSON(json);
    476387        json.append(",\n");
    477388        auto writeData = json.toString().utf8();

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

    r181756 r181970  
    2929#if ENABLE(NETWORK_CACHE)
    3030
     31#include "NetworkCacheEntry.h"
    3132#include "NetworkCacheStorage.h"
    3233#include "ShareableResource.h"
    … …  
    5556};
    5657
    57 struct Entry {
    58     Storage::Entry storageEntry;
    59     WebCore::ResourceResponse response;
    60     RefPtr<WebCore::SharedBuffer> buffer;
    61 #if ENABLE(SHAREABLE_RESOURCE)
    62     ShareableResource::Handle shareableResourceHandle;
    63 #endif
    64     bool needsRevalidation;
    65 };
    66 
    6758enum class RetrieveDecision {
    6859    Yes,
    … …  
    8172};
    8273
    83 enum class CachedEntryReuseFailure {
    84     None,
    85     VaryingHeaderMismatch,
    86     MissingValidatorFields,
    87     Other,
     74enum class UseDecision {
     75    Use,
     76    Validate,
     77    NoDueToVaryingHeaderMismatch,
     78    NoDueToMissingValidatorFields,
     79    NoDueToDecodeFailure,
    8880};
    8981

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

    r181689 r181970  
    5252    void recordNotUsingCacheForRequest(uint64_t webPageID, const Key&, const WebCore::ResourceRequest&, RetrieveDecision);
    5353    void recordRetrievalFailure(uint64_t webPageID, const Key&, const WebCore::ResourceRequest&);
    54     void recordRetrievedCachedEntry(uint64_t webPageID, const Key&, const WebCore::ResourceRequest&, CachedEntryReuseFailure);
     54    void recordRetrievedCachedEntry(uint64_t webPageID, const Key&, const WebCore::ResourceRequest&, UseDecision);
    5555
    5656private:

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheStatisticsCocoa.mm

    r181702 r181970  
    263263}
    264264
    265 static String cachedEntryReuseFailureToDiagnosticKey(CachedEntryReuseFailure failure)
    266 {
    267     switch (failure) {
    268     case CachedEntryReuseFailure::VaryingHeaderMismatch:
     265static String cachedEntryReuseFailureToDiagnosticKey(UseDecision decision)
     266{
     267    switch (decision) {
     268    case UseDecision::NoDueToVaryingHeaderMismatch:
    269269        return WebCore::DiagnosticLoggingKeys::varyingHeaderMismatchKey();
    270     case CachedEntryReuseFailure::MissingValidatorFields:
     270    case UseDecision::NoDueToMissingValidatorFields:
    271271        return WebCore::DiagnosticLoggingKeys::missingValidatorFieldsKey();
    272     case CachedEntryReuseFailure::Other:
     272    case UseDecision::NoDueToDecodeFailure:
    273273        return WebCore::DiagnosticLoggingKeys::otherKey();
    274     case CachedEntryReuseFailure::None:
     274    case UseDecision::Use:
     275    case UseDecision::Validate:
    275276        ASSERT_NOT_REACHED();
    276277        break;
    … …  
    279280}
    280281
    281 void Statistics::recordRetrievedCachedEntry(uint64_t webPageID, const Key& key, const WebCore::ResourceRequest& request, CachedEntryReuseFailure failure)
     282void Statistics::recordRetrievedCachedEntry(uint64_t webPageID, const Key& key, const WebCore::ResourceRequest& request, UseDecision decision)
    282283{
    283284    WebCore::URL requestURL = request.url();
    284     if (failure == CachedEntryReuseFailure::None) {
     285    if (decision == UseDecision::Use || decision == UseDecision::Validate) {
    285286        LOG(NetworkCache, "(NetworkProcess) webPageID %llu: %s is in the cache and is used", webPageID, requestURL.string().ascii().data());
    286287        NetworkProcess::singleton().logDiagnosticMessageWithResult(webPageID, WebCore::DiagnosticLoggingKeys::networkCacheKey(), WebCore::DiagnosticLoggingKeys::retrievalKey(), WebCore::DiagnosticLoggingResultPass, WebCore::ShouldSample::Yes);
    … …  
    288289    }
    289290
    290     String diagnosticKey = cachedEntryReuseFailureToDiagnosticKey(failure);
     291    String diagnosticKey = cachedEntryReuseFailureToDiagnosticKey(decision);
    291292    LOG(NetworkCache, "(NetworkProcess) webPageID %llu: %s is in the cache but wasn't used, reason: %s", webPageID, requestURL.string().ascii().data(), diagnosticKey.utf8().data());
    292293    NetworkProcess::singleton().logDiagnosticMessageWithValue(webPageID, WebCore::DiagnosticLoggingKeys::networkCacheKey(), WebCore::DiagnosticLoggingKeys::unusableCachedEntryKey(), diagnosticKey, WebCore::ShouldSample::Yes);

  • trunk/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj

    r181777 r181970  
    17671767                E1EE53E311F8CFC000CCBEE4 /* InjectedBundlePageEditorClient.h in Headers */ = {isa = PBXBuildFile; fileRef = E1EE53DC11F8CF9F00CCBEE4 /* InjectedBundlePageEditorClient.h */; };
    17681768                E1EE53E711F8CFFB00CCBEE4 /* InjectedBundlePageEditorClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E1EE53E611F8CFFB00CCBEE4 /* InjectedBundlePageEditorClient.cpp */; };
     1769                E413F59D1AC1ADC400345360 /* NetworkCacheEntry.h in Headers */ = {isa = PBXBuildFile; fileRef = E413F59B1AC1ADB600345360 /* NetworkCacheEntry.h */; };
     1770                E413F59F1AC1AF9D00345360 /* NetworkCacheEntry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E413F59E1AC1AF9D00345360 /* NetworkCacheEntry.cpp */; };
    17691771                E42E060F1AA7523400B11699 /* NetworkCacheIOChannelCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = E42E060D1AA750E500B11699 /* NetworkCacheIOChannelCocoa.mm */; };
    17701772                E42E06101AA7523B00B11699 /* NetworkCacheIOChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = E42E060B1AA7440D00B11699 /* NetworkCacheIOChannel.h */; };
    … …  
    40164018                E1FEF39A190F76F300731658 /* com.apple.WebKit.Databases.sb.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = com.apple.WebKit.Databases.sb.in; sourceTree = "<group>"; };
    40174019                E1FEF39C190F791C00731658 /* DatabaseProcessIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = DatabaseProcessIOS.mm; sourceTree = "<group>"; };
     4020                E413F59B1AC1ADB600345360 /* NetworkCacheEntry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkCacheEntry.h; sourceTree = "<group>"; };
     4021                E413F59E1AC1AF9D00345360 /* NetworkCacheEntry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkCacheEntry.cpp; sourceTree = "<group>"; };
    40184022                E42E060B1AA7440D00B11699 /* NetworkCacheIOChannel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkCacheIOChannel.h; sourceTree = "<group>"; };
    40194023                E42E060D1AA750E500B11699 /* NetworkCacheIOChannelCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = NetworkCacheIOChannelCocoa.mm; sourceTree = "<group>"; };
    … …  
    74717475                                E489D2881A0A2DB80078C06A /* NetworkCacheEncoder.cpp */,
    74727476                                E489D2891A0A2DB80078C06A /* NetworkCacheEncoder.h */,
     7477                                E413F59E1AC1AF9D00345360 /* NetworkCacheEntry.cpp */,
     7478                                E413F59B1AC1ADB600345360 /* NetworkCacheEntry.h */,
    74737479                                834B250E1A831A8D00CFB150 /* NetworkCacheFileSystemPosix.h */,
    74747480                                E42E060B1AA7440D00B11699 /* NetworkCacheIOChannel.h */,
    … …  
    78307836                                7CD622781739D863005BD7FF /* PluginSandboxProfile.h in Headers */,
    78317837                                1A6FB7AF11E64B6800DB1371 /* PluginView.h in Headers */,
     7838                                E413F59D1AC1ADC400345360 /* NetworkCacheEntry.h in Headers */,
    78327839                                E1CC1B9012D7EADF00625838 /* PrintInfo.h in Headers */,
    78337840                                86F9536518FF58F5001DB2EF /* ProcessAssertion.h in Headers */,
    … …  
    93849391                                BC82837B16B36A4F00A278FE /* ChildProcessEntryPoint.mm in Sources */,
    93859392                                A7E93CED1925331100A1DC48 /* ChildProcessIOS.mm in Sources */,
     9393                                E413F59F1AC1AF9D00345360 /* NetworkCacheEntry.cpp in Sources */,
    93869394                                9F54F88F16488E87007DF81A /* ChildProcessMac.mm in Sources */,
    93879395                                E1513C66166EABB200149FCB /* ChildProcessProxy.cpp in Sources */,
Note: See TracChangeset for help on using the changeset viewer.