Changeset 258868 in webkit


Ignore:
Timestamp:
Mar 23, 2020 12:33:55 PM (4 years ago)
Author:
youenn@apple.com
Message:

Remove DOMCache::m_records
​https://bugs.webkit.org/show_bug.cgi?id=209425

Reviewed by Alex Christensen.

We do not need to keep references of FetchRequest and FetchResponse since we clone them before exposing them.
For that reason, remove m_records and directly use records given from the CacheStorageConnection.
Minor refactoring to modernize/improve code readability.

This is a first step towards a future refactoring that will reduce the sending of records from network process to web process
based on the request parameters: record filtering will be done in network process instead of web process.

No change of behavior.

  • Modules/cache/DOMCache.cpp:

(WebCore::createResponse):
(WebCore::DOMCache::doMatch):
(WebCore::DOMCache::cloneResponses):
(WebCore::DOMCache::matchAll):
(WebCore::createRequest):
(WebCore::DOMCache::keys):
(WebCore::DOMCache::retrieveRecords):
(WebCore::DOMCache::queryCache):
(WebCore::DOMCache::queryCacheWithTargetStorage):
(WebCore::DOMCache::batchDeleteOperation):
(WebCore::DOMCache::batchPutOperation):
(WebCore::copyRequestRef): Deleted.
(WebCore::queryCacheMatch): Deleted.
(WebCore::DOMCache::updateRecords): Deleted.

  • Modules/cache/DOMCache.h:
Location:
trunk/Source/WebCore
Files:
1 deleted
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r258866 r258868  
     12020-03-23  youenn fablet  <youenn@apple.com>
     2
     3        Remove DOMCache::m_records
     4        https://bugs.webkit.org/show_bug.cgi?id=209425
     5
     6        Reviewed by Alex Christensen.
     7
     8        We do not need to keep references of FetchRequest and FetchResponse since we clone them before exposing them.
     9        For that reason, remove m_records and directly use records given from the CacheStorageConnection.
     10        Minor refactoring to modernize/improve code readability.
     11
     12        This is a first step towards a future refactoring that will reduce the sending of records from network process to web process
     13        based on the request parameters: record filtering will be done in network process instead of web process.
     14
     15        No change of behavior.
     16
     17        * Modules/cache/DOMCache.cpp:
     18        (WebCore::createResponse):
     19        (WebCore::DOMCache::doMatch):
     20        (WebCore::DOMCache::cloneResponses):
     21        (WebCore::DOMCache::matchAll):
     22        (WebCore::createRequest):
     23        (WebCore::DOMCache::keys):
     24        (WebCore::DOMCache::retrieveRecords):
     25        (WebCore::DOMCache::queryCache):
     26        (WebCore::DOMCache::queryCacheWithTargetStorage):
     27        (WebCore::DOMCache::batchDeleteOperation):
     28        (WebCore::DOMCache::batchPutOperation):
     29        (WebCore::copyRequestRef): Deleted.
     30        (WebCore::queryCacheMatch): Deleted.
     31        (WebCore::DOMCache::updateRecords): Deleted.
     32        * Modules/cache/DOMCache.h:
     33
    1342020-03-23  Rob Buis  <rbuis@igalia.com>
    235

  • trunk/Source/WebCore/Modules/cache/DOMCache.cpp

    r254919 r258868  
    7474}
    7575
     76static Ref<FetchResponse> createResponse(ScriptExecutionContext& context, const DOMCacheEngine::Record& record)
     77{
     78    auto resourceResponse = record.response;
     79    resourceResponse.setSource(ResourceResponse::Source::DOMCache);
     80    auto response = FetchResponse::create(context, WTF::nullopt, record.responseHeadersGuard, WTFMove(resourceResponse));
     81    response->setBodyData(copyResponseBody(record.responseBody), record.responseBodySize);
     82    return response;
     83}
     84
    7685void DOMCache::doMatch(RequestInfo&& info, CacheQueryOptions&& options, MatchCallback&& callback)
    7786{
    … …  
    8695    auto request = requestOrException.releaseReturnValue();
    8796
    88     queryCache(request.get(), WTFMove(options), [this, callback = WTFMove(callback)](ExceptionOr<Vector<CacheStorageRecord>>&& result) mutable {
     97    queryCache(request.get(), WTFMove(options), [this, callback = WTFMove(callback)](auto&& result) mutable {
    8998        if (result.hasException()) {
    9099            callback(result.releaseException());
    91100            return;
    92101        }
    93         if (result.returnValue().isEmpty()) {
    94             callback(nullptr);
    95             return;
    96         }
    97         callback(RefPtr<FetchResponse>(result.returnValue()[0].response->clone(*scriptExecutionContext()).releaseReturnValue()));
    98     });
    99 }
    100 
    101 Vector<Ref<FetchResponse>> DOMCache::cloneResponses(const Vector<CacheStorageRecord>& records)
    102 {
    103     auto& context = *scriptExecutionContext();
    104     return WTF::map(records, [&context] (const auto& record) {
    105         return record.response->clone(context).releaseReturnValue();
     102
     103        RefPtr<FetchResponse> response;
     104        if (!result.returnValue().isEmpty())
     105            response = createResponse(*scriptExecutionContext(), result.returnValue()[0]);
     106
     107        callback(WTFMove(response));
     108    });
     109}
     110
     111Vector<Ref<FetchResponse>> DOMCache::cloneResponses(const Vector<DOMCacheEngine::Record>& records)
     112{
     113    return WTF::map(records, [this] (const auto& record) {
     114        return createResponse(*scriptExecutionContext(), record);
    106115    });
    107116}
    … …  
    122131    }
    123132
    124     if (!request) {
    125         retrieveRecords(URL { }, [this, promise = WTFMove(promise)](Optional<Exception>&& exception) mutable {
    126             queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [this, promise = WTFMove(promise), exception = WTFMove(exception)]() mutable {
    127                 if (exception) {
    128                     promise.reject(WTFMove(exception.value()));
    129                     return;
    130                 }
    131                 promise.resolve(cloneResponses(m_records));
    132             });
    133         });
    134         return;
    135     }
    136     queryCache(request.releaseNonNull(), WTFMove(options), [this, promise = WTFMove(promise)](ExceptionOr<Vector<CacheStorageRecord>>&& result) mutable {
     133    RecordsCallback callback = [this, promise = WTFMove(promise)](auto&& result) mutable {
    137134        queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [this, promise = WTFMove(promise), result = WTFMove(result)]() mutable {
    138135            if (result.hasException()) {
    … …  
    142139            promise.resolve(cloneResponses(result.releaseReturnValue()));
    143140        });
    144     });
     141    };
     142
     143    if (!request)
     144        return retrieveRecords(URL { }, WTFMove(callback));
     145    queryCache(request.releaseNonNull(), WTFMove(options), WTFMove(callback));
    145146}
    146147
    … …  
    414415}
    415416
    416 static inline Ref<FetchRequest> copyRequestRef(const CacheStorageRecord& record)
    417 {
    418     return record.request.copyRef();
     417static Ref<FetchRequest> createRequest(ScriptExecutionContext& context, const DOMCacheEngine::Record& record)
     418{
     419    auto requestHeaders = FetchHeaders::create(record.requestHeadersGuard, HTTPHeaderMap { record.request.httpHeaderFields() });
     420    return FetchRequest::create(context, WTF::nullopt, WTFMove(requestHeaders),  ResourceRequest { record.request }, FetchOptions { record.options }, String { record.referrer });
    419421}
    420422
    … …  
    434436    }
    435437
    436     if (!request) {
    437         retrieveRecords(URL { }, [this, promise = WTFMove(promise)](Optional<Exception>&& exception) mutable {
    438             queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [this, promise = WTFMove(promise), exception = WTFMove(exception)]() mutable {
    439                 if (exception) {
    440                     promise.reject(WTFMove(exception.value()));
    441                     return;
    442                 }
    443                 promise.resolve(WTF::map(m_records, copyRequestRef));
    444             });
    445         });
    446         return;
    447     }
    448 
    449     queryCache(request.releaseNonNull(), WTFMove(options), [this, protectedThis = makeRef(*this), promise = WTFMove(promise)](auto&& result) mutable {
    450         queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
     438    RecordsCallback callback = [this, promise = WTFMove(promise)](auto&& result) mutable {
     439        queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [this, promise = WTFMove(promise), result = WTFMove(result)]() mutable {
    451440            if (result.hasException()) {
    452441                promise.reject(result.releaseException());
    … …  
    454443            }
    455444
    456             promise.resolve(WTF::map(result.releaseReturnValue(), copyRequestRef));
    457         });
    458     });
    459 }
    460 
    461 void DOMCache::retrieveRecords(const URL& url, WTF::Function<void(Optional<Exception>&&)>&& callback)
     445            auto records = result.releaseReturnValue();
     446            promise.resolve(WTF::map(records, [this](auto& record) {
     447                return createRequest(*scriptExecutionContext(), record);
     448            }));
     449        });
     450    };
     451
     452    if (!request)
     453        return retrieveRecords(URL { }, WTFMove(callback));
     454    queryCache(request.releaseNonNull(), WTFMove(options), WTFMove(callback));
     455}
     456
     457void DOMCache::retrieveRecords(const URL& url, RecordsCallback&& callback)
    462458{
    463459    URL retrieveURL = url;
    464460    retrieveURL.removeQueryAndFragmentIdentifier();
    465461
    466     m_connection->retrieveRecords(m_identifier, retrieveURL, [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](RecordsOrError&& result) {
    467         if (m_isStopped)
    468             return;
     462    m_connection->retrieveRecords(m_identifier, retrieveURL, [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](auto&& result) mutable {
     463        if (m_isStopped) {
     464            callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), DOMCacheEngine::Error::Stopped));
     465            return;
     466        }
    469467
    470468        if (!result.has_value()) {
    … …  
    473471        }
    474472
    475         updateRecords(WTFMove(result.value()));
    476         callback(WTF::nullopt);
    477     });
    478 }
    479 
    480 void DOMCache::queryCache(Ref<FetchRequest>&& request, CacheQueryOptions&& options, WTF::Function<void(ExceptionOr<Vector<CacheStorageRecord>>&&)>&& callback)
     473        callback(WTFMove(result.value()));
     474    });
     475}
     476
     477void DOMCache::queryCache(Ref<FetchRequest>&& request, CacheQueryOptions&& options, RecordsCallback&& callback)
    481478{
    482479    auto url = request->url();
    483     retrieveRecords(url, [this, request = WTFMove(request), options = WTFMove(options), callback = WTFMove(callback)](Optional<Exception>&& exception) mutable {
    484         if (exception) {
    485             callback(WTFMove(exception.value()));
    486             return;
    487         }
    488         callback(queryCacheWithTargetStorage(request.get(), options, m_records));
    489     });
    490 }
    491 
    492 static inline bool queryCacheMatch(const FetchRequest& request, const FetchRequest& cachedRequest, const ResourceResponse& cachedResponse, const CacheQueryOptions& options)
    493 {
    494     // We need to pass the resource request with all correct headers hence why we call resourceRequest().
    495     return DOMCacheEngine::queryCacheMatch(request.resourceRequest(), cachedRequest.resourceRequest(), cachedResponse, options);
    496 }
    497 
    498 Vector<CacheStorageRecord> DOMCache::queryCacheWithTargetStorage(const FetchRequest& request, const CacheQueryOptions& options, const Vector<CacheStorageRecord>& targetStorage)
     480    retrieveRecords(url, [this, request = WTFMove(request), options = WTFMove(options), callback = WTFMove(callback)](auto&& result) mutable {
     481        if (result.hasException()) {
     482            callback(result.releaseException());
     483            return;
     484        }
     485        callback(queryCacheWithTargetStorage(request.get(), options, result.releaseReturnValue()));
     486    });
     487}
     488
     489Vector<DOMCacheEngine::Record> DOMCache::queryCacheWithTargetStorage(const FetchRequest& request, const CacheQueryOptions& options, const Vector<DOMCacheEngine::Record>& targetStorage)
    499490{
    500491    if (!options.ignoreMethod && request.method() != "GET")
    501492        return { };
    502493
    503     Vector<CacheStorageRecord> records;
     494    Vector<DOMCacheEngine::Record> records;
    504495    for (auto& record : targetStorage) {
    505         if (queryCacheMatch(request, record.request.get(), record.response->resourceResponse(), options))
    506             records.append({ record.identifier, record.updateResponseCounter, record.request.copyRef(), record.response.copyRef() });
     496        // We need to pass the resource request with all correct headers hence why we call resourceRequest().
     497        if (DOMCacheEngine::queryCacheMatch(request.resourceRequest(), record.request, record.response, options))
     498            records.append(record.copy());
    507499    }
    508500    return records;
    509501}
    510502
    511 void DOMCache::batchDeleteOperation(const FetchRequest& request, CacheQueryOptions&& options, WTF::Function<void(ExceptionOr<bool>&&)>&& callback)
    512 {
    513     m_connection->batchDeleteOperation(m_identifier, request.internalRequest(), WTFMove(options), [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](RecordIdentifiersOrError&& result) {
    514         if (m_isStopped)
    515             return;
     503void DOMCache::batchDeleteOperation(const FetchRequest& request, CacheQueryOptions&& options, CompletionHandler<void(ExceptionOr<bool>&&)>&& callback)
     504{
     505    m_connection->batchDeleteOperation(m_identifier, request.internalRequest(), WTFMove(options), [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](RecordIdentifiersOrError&& result) mutable {
     506        if (m_isStopped) {
     507            callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), DOMCacheEngine::Error::Stopped));
     508            return;
     509        }
    516510
    517511        if (!result.has_value()) {
    … …  
    544538}
    545539
    546 void DOMCache::batchPutOperation(const FetchRequest& request, FetchResponse& response, DOMCacheEngine::ResponseBody&& responseBody, WTF::Function<void(ExceptionOr<void>&&)>&& callback)
     540void DOMCache::batchPutOperation(const FetchRequest& request, FetchResponse& response, DOMCacheEngine::ResponseBody&& responseBody, CompletionHandler<void(ExceptionOr<void>&&)>&& callback)
    547541{
    548542    Vector<Record> records;
    … …  
    552546}
    553547
    554 void DOMCache::batchPutOperation(Vector<Record>&& records, WTF::Function<void(ExceptionOr<void>&&)>&& callback)
    555 {
    556     m_connection->batchPutOperation(m_identifier, WTFMove(records), [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](RecordIdentifiersOrError&& result) {
    557         if (m_isStopped)
    558             return;
     548void DOMCache::batchPutOperation(Vector<Record>&& records, CompletionHandler<void(ExceptionOr<void>&&)>&& callback)
     549{
     550    m_connection->batchPutOperation(m_identifier, WTFMove(records), [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](auto&& result) mutable {
     551        if (m_isStopped) {
     552            callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), DOMCacheEngine::Error::Stopped));
     553            return;
     554        }
     555
    559556        if (!result.has_value()) {
    560557            callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), result.error()));
    … …  
    565562}
    566563
    567 void DOMCache::updateRecords(Vector<Record>&& records)
    568 {
    569     ASSERT(scriptExecutionContext());
    570     Vector<CacheStorageRecord> newRecords;
    571 
    572     for (auto& record : records) {
    573         size_t index = m_records.findMatching([&](const auto& item) { return item.identifier == record.identifier; });
    574         if (index != notFound) {
    575             auto& current = m_records[index];
    576             if (current.updateResponseCounter != record.updateResponseCounter) {
    577                 record.response.setSource(ResourceResponse::Source::DOMCache);
    578                 auto response = FetchResponse::create(*scriptExecutionContext(), WTF::nullopt, record.responseHeadersGuard, WTFMove(record.response));
    579                 response->setBodyData(WTFMove(record.responseBody), record.responseBodySize);
    580 
    581                 current.response = WTFMove(response);
    582                 current.updateResponseCounter = record.updateResponseCounter;
    583             }
    584             newRecords.append(WTFMove(current));
    585         } else {
    586             auto requestHeaders = FetchHeaders::create(record.requestHeadersGuard, HTTPHeaderMap { record.request.httpHeaderFields() });
    587             auto request = FetchRequest::create(*scriptExecutionContext(), WTF::nullopt, WTFMove(requestHeaders),  WTFMove(record.request), WTFMove(record.options), WTFMove(record.referrer));
    588 
    589             record.response.setSource(ResourceResponse::Source::DOMCache);
    590             auto response = FetchResponse::create(*scriptExecutionContext(), WTF::nullopt, record.responseHeadersGuard, WTFMove(record.response));
    591             response->setBodyData(WTFMove(record.responseBody), record.responseBodySize);
    592 
    593             newRecords.append(CacheStorageRecord { record.identifier, record.updateResponseCounter, WTFMove(request), WTFMove(response) });
    594         }
    595     }
    596     m_records = WTFMove(newRecords);
    597 }
    598 
    599564void DOMCache::stop()
    600565{

  • trunk/Source/WebCore/Modules/cache/DOMCache.h

    r252227 r258868  
    2828#include "ActiveDOMObject.h"
    2929#include "CacheStorageConnection.h"
    30 #include "CacheStorageRecord.h"
     30#include "FetchRequest.h"
     31#include "FetchResponse.h"
    3132#include <wtf/UniqueRef.h>
    3233
    … …  
    5859    uint64_t identifier() const { return m_identifier; }
    5960
    60     using MatchCallback = Function<void(ExceptionOr<RefPtr<FetchResponse>>)>;
     61    using MatchCallback = CompletionHandler<void(ExceptionOr<RefPtr<FetchResponse>>)>;
    6162    void doMatch(RequestInfo&&, CacheQueryOptions&&, MatchCallback&&);
    6263
    … …  
    7475    void putWithResponseData(DOMPromiseDeferred<void>&&, Ref<FetchRequest>&&, Ref<FetchResponse>&&, ExceptionOr<RefPtr<SharedBuffer>>&&);
    7576
    76     void retrieveRecords(const URL&, WTF::Function<void(Optional<Exception>&&)>&&);
    77     Vector<CacheStorageRecord> queryCacheWithTargetStorage(const FetchRequest&, const CacheQueryOptions&, const Vector<CacheStorageRecord>&);
    78     void queryCache(Ref<FetchRequest>&&, CacheQueryOptions&&, WTF::Function<void(ExceptionOr<Vector<CacheStorageRecord>>&&)>&&);
    79     void batchDeleteOperation(const FetchRequest&, CacheQueryOptions&&, WTF::Function<void(ExceptionOr<bool>&&)>&&);
    80     void batchPutOperation(const FetchRequest&, FetchResponse&, DOMCacheEngine::ResponseBody&&, WTF::Function<void(ExceptionOr<void>&&)>&&);
    81     void batchPutOperation(Vector<DOMCacheEngine::Record>&&, WTF::Function<void(ExceptionOr<void>&&)>&&);
     77    using RecordsCallback = CompletionHandler<void(ExceptionOr<Vector<DOMCacheEngine::Record>>&&)>;
     78    void retrieveRecords(const URL&, RecordsCallback&&);
     79    Vector<DOMCacheEngine::Record> queryCacheWithTargetStorage(const FetchRequest&, const CacheQueryOptions&, const Vector<DOMCacheEngine::Record>&);
     80    void queryCache(Ref<FetchRequest>&&, CacheQueryOptions&&, RecordsCallback&&);
     81    void batchDeleteOperation(const FetchRequest&, CacheQueryOptions&&, CompletionHandler<void(ExceptionOr<bool>&&)>&&);
     82    void batchPutOperation(const FetchRequest&, FetchResponse&, DOMCacheEngine::ResponseBody&&, CompletionHandler<void(ExceptionOr<void>&&)>&&);
     83    void batchPutOperation(Vector<DOMCacheEngine::Record>&&, CompletionHandler<void(ExceptionOr<void>&&)>&&);
    8284
    83     void updateRecords(Vector<DOMCacheEngine::Record>&&);
    84     Vector<Ref<FetchResponse>> cloneResponses(const Vector<CacheStorageRecord>&);
     85    Vector<Ref<FetchResponse>> cloneResponses(const Vector<DOMCacheEngine::Record>&);
    8586    DOMCacheEngine::Record toConnectionRecord(const FetchRequest&, FetchResponse&, DOMCacheEngine::ResponseBody&&);
    8687
    … …  
    8990    Ref<CacheStorageConnection> m_connection;
    9091
    91     Vector<CacheStorageRecord> m_records;
    9292    bool m_isStopped { false };
    9393};

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

    r258843 r258868  
    11331133                41D129D01F3D0F0500D15E47 /* CacheQueryOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 41FB279B1F34CEF000795487 /* CacheQueryOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
    11341134                41D129D11F3D0F0E00D15E47 /* DOMWindowCaches.h in Headers */ = {isa = PBXBuildFile; fileRef = 41FB278C1F34C28200795487 /* DOMWindowCaches.h */; };
    1135                 41D129D21F3D0F1200D15E47 /* CacheStorageRecord.h in Headers */ = {isa = PBXBuildFile; fileRef = 41D129CA1F3D0EE300D15E47 /* CacheStorageRecord.h */; };
    11361135                41D129D31F3D0F1600D15E47 /* CacheStorageConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 41D129CC1F3D0EE300D15E47 /* CacheStorageConnection.h */; settings = {ATTRIBUTES = (Private, ); }; };
    11371136                41D129D51F3D0F6900D15E47 /* CacheStorageProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 41D129D41F3D0F6600D15E47 /* CacheStorageProvider.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    75597558                41D015C90F4B5C71004A662F /* ContentType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ContentType.cpp; sourceTree = "<group>"; };
    75607559                41D129C91F3D0EE300D15E47 /* CacheStorageConnection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CacheStorageConnection.cpp; sourceTree = "<group>"; };
    7561                 41D129CA1F3D0EE300D15E47 /* CacheStorageRecord.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CacheStorageRecord.h; sourceTree = "<group>"; };
    75627560                41D129CC1F3D0EE300D15E47 /* CacheStorageConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CacheStorageConnection.h; sourceTree = "<group>"; };
    75637561                41D129D41F3D0F6600D15E47 /* CacheStorageProvider.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CacheStorageProvider.h; sourceTree = "<group>"; };
    … …  
    1820318201                                41D129C91F3D0EE300D15E47 /* CacheStorageConnection.cpp */,
    1820418202                                41D129CC1F3D0EE300D15E47 /* CacheStorageConnection.h */,
    18205                                 41D129CA1F3D0EE300D15E47 /* CacheStorageRecord.h */,
    1820618203                                41380C201F34368A00155FDA /* DOMCache.cpp */,
    1820718204                                41380C251F34369A00155FDA /* DOMCache.h */,
    … …  
    2958229579                                41D129D31F3D0F1600D15E47 /* CacheStorageConnection.h in Headers */,
    2958329580                                41D129D51F3D0F6900D15E47 /* CacheStorageProvider.h in Headers */,
    29584                                 41D129D21F3D0F1200D15E47 /* CacheStorageRecord.h in Headers */,
    2958529581                                E43AF8E71AC5B7EC00CA717E /* CacheValidation.h in Headers */,
    2958629582                                49AE2D97134EE5F90072920A /* CalculationValue.h in Headers */,
Note: See TracChangeset for help on using the changeset viewer.