From 1bf1084f2b10c3b47fd1a588d85d21ed0eb41d0c Mon Sep 17 00:00:00 2001 From: Lorry Tar Creator Date: Tue, 27 Jun 2017 06:07:23 +0000 Subject: webkitgtk-2.16.5 --- Source/WebKit2/NetworkProcess/cache/NetworkCache.h | 160 +++++++++++++++++++++ 1 file changed, 160 insertions(+) create mode 100644 Source/WebKit2/NetworkProcess/cache/NetworkCache.h (limited to 'Source/WebKit2/NetworkProcess/cache/NetworkCache.h') diff --git a/Source/WebKit2/NetworkProcess/cache/NetworkCache.h b/Source/WebKit2/NetworkProcess/cache/NetworkCache.h new file mode 100644 index 000000000..ca2bbc2dc --- /dev/null +++ b/Source/WebKit2/NetworkProcess/cache/NetworkCache.h @@ -0,0 +1,160 @@ +/* + * Copyright (C) 2014-2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef NetworkCache_h +#define NetworkCache_h + +#if ENABLE(NETWORK_CACHE) + +#include "NetworkCacheEntry.h" +#include "NetworkCacheStorage.h" +#include "ShareableResource.h" +#include +#include +#include + +namespace WebCore { +class ResourceRequest; +class SharedBuffer; +class URL; +} + +namespace WebKit { +namespace NetworkCache { + +class Cache; +class SpeculativeLoadManager; +class Statistics; + +Cache& singleton(); + +struct MappedBody { +#if ENABLE(SHAREABLE_RESOURCE) + RefPtr shareableResource; + ShareableResource::Handle shareableResourceHandle; +#endif +}; + +enum class RetrieveDecision { + Yes, + NoDueToHTTPMethod, + NoDueToConditionalRequest, + NoDueToReloadIgnoringCache, + NoDueToStreamingMedia, +}; + +// FIXME: This enum is used in the Statistics code in a way that prevents removing or reordering anything. +enum class StoreDecision { + Yes, + NoDueToProtocol, + NoDueToHTTPMethod, + NoDueToAttachmentResponse, // Unused. + NoDueToNoStoreResponse, + NoDueToHTTPStatusCode, + NoDueToNoStoreRequest, + NoDueToUnlikelyToReuse, + NoDueToStreamingMedia, +}; + +enum class UseDecision { + Use, + Validate, + NoDueToVaryingHeaderMismatch, + NoDueToMissingValidatorFields, + NoDueToDecodeFailure, + NoDueToExpiredRedirect, +}; + +using GlobalFrameID = std::pair; + +class Cache { + WTF_MAKE_NONCOPYABLE(Cache); + friend class WTF::NeverDestroyed; +public: + struct Parameters { + bool enableEfficacyLogging; +#if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION) + bool enableNetworkCacheSpeculativeRevalidation; +#endif + }; + bool initialize(const String& cachePath, const Parameters&); + void setCapacity(size_t); + + bool isEnabled() const { return !!m_storage; } + + // Completion handler may get called back synchronously on failure. + void retrieve(const WebCore::ResourceRequest&, const GlobalFrameID&, Function)>&&); + std::unique_ptr store(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr&&, Function&&); + std::unique_ptr storeRedirect(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest); + std::unique_ptr update(const WebCore::ResourceRequest&, const GlobalFrameID&, const Entry&, const WebCore::ResourceResponse& validatingResponse); + + struct TraversalEntry { + const Entry& entry; + const Storage::RecordInfo& recordInfo; + }; + void traverse(Function&&); + void remove(const Key&); + void remove(const WebCore::ResourceRequest&); + + void clear(); + void clear(std::chrono::system_clock::time_point modifiedSince, Function&& completionHandler); + + void retrieveData(const DataKey&, Function); + void storeData(const DataKey&, const uint8_t* data, size_t); + + std::unique_ptr makeEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr&&); + std::unique_ptr makeRedirectEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest); + + void dumpContentsToFile(); + + String recordsPath() const; + bool canUseSharedMemoryForBodyData() const { return m_storage && m_storage->canUseSharedMemoryForBodyData(); } + +#if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION) + SpeculativeLoadManager* speculativeLoadManager() { return m_speculativeLoadManager.get(); } +#endif + +private: + Cache() = default; + ~Cache() = delete; + + Key makeCacheKey(const WebCore::ResourceRequest&); + + String dumpFilePath() const; + void deleteDumpFile(); + + std::unique_ptr m_storage; +#if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION) + std::unique_ptr m_speculativeLoadManager; +#endif + std::unique_ptr m_statistics; + + unsigned m_traverseCount { 0 }; +}; + +} +} +#endif +#endif -- cgit v1.2.1