Source/WebKit/NetworkProcess/cache/NetworkCache.h

   1 /*
   2  * Copyright (C) 2014-2017 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #pragma once
  27
  28 #include "NetworkCacheEntry.h"
  29 #include "NetworkCacheStorage.h"
  30 #include "ShareableResource.h"
  31 #include <WebCore/PageIdentifier.h>
  32 #include <WebCore/ResourceResponse.h>
  33 #include <wtf/CompletionHandler.h>
  34 #include <wtf/OptionSet.h>
  35 #include <wtf/Seconds.h>
  36 #include <wtf/text/WTFString.h>
  37
  38 namespace WebCore {
  39 class LowPowerModeNotifier;
  40 class ResourceRequest;
  41 class SharedBuffer;
  42 }
  43
  44 namespace WebKit {
  45
  46 class NetworkProcess;
  47
  48 namespace NetworkCache {
  49
  50 class Cache;
  51 class SpeculativeLoadManager;
  52
  53 struct MappedBody {
  54 #if ENABLE(SHAREABLE_RESOURCE)
  55     RefPtr<ShareableResource> shareableResource;
  56     ShareableResource::Handle shareableResourceHandle;
  57 #endif
  58 };
  59
  60 enum class RetrieveDecision {
  61     Yes,
  62     NoDueToHTTPMethod,
  63     NoDueToConditionalRequest,
  64     NoDueToReloadIgnoringCache,
  65     NoDueToStreamingMedia,
  66 };
  67
  68 enum class StoreDecision {
  69     Yes,
  70     NoDueToProtocol,
  71     NoDueToHTTPMethod,
  72     NoDueToNoStoreResponse,
  73     NoDueToHTTPStatusCode,
  74     NoDueToNoStoreRequest,
  75     NoDueToUnlikelyToReuse,
  76     NoDueToStreamingMedia,
  77 };
  78
  79 enum class UseDecision {
  80     Use,
  81     Validate,
  82     NoDueToVaryingHeaderMismatch,
  83     NoDueToMissingValidatorFields,
  84     NoDueToDecodeFailure,
  85     NoDueToExpiredRedirect
  86 };
  87
  88 using GlobalFrameID = std::pair<WebCore::PageIdentifier, uint64_t /*webFrameID*/>;
  89
  90 enum class CacheOption : uint8_t {
  91     // In testing mode we try to eliminate sources of randomness. Cache does not shrink and there are no read timeouts.
  92     TestingMode = 1 << 0,
  93     RegisterNotify = 1 << 1,
  94 #if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
  95     SpeculativeRevalidation = 1 << 2,
  96 #endif
  97 };
  98
  99 class Cache : public RefCounted<Cache> {
 100 public:
 101     static RefPtr<Cache> open(NetworkProcess&, const String& cachePath, OptionSet<CacheOption>);
 102
 103     void setCapacity(size_t);
 104
 105     // Completion handler may get called back synchronously on failure.
 106     struct RetrieveInfo {
 107         MonotonicTime startTime;
 108         MonotonicTime completionTime;
 109         unsigned priority;
 110         Storage::Timings storageTimings;
 111         bool wasSpeculativeLoad { false };
 112
 113         WTF_MAKE_FAST_ALLOCATED;
 114     };
 115     using RetrieveCompletionHandler = Function<void(std::unique_ptr<Entry>, const RetrieveInfo&)>;
 116     void retrieve(const WebCore::ResourceRequest&, const GlobalFrameID&, RetrieveCompletionHandler&&);
 117     std::unique_ptr<Entry> store(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&, Function<void(MappedBody&)>&&);
 118     std::unique_ptr<Entry> storeRedirect(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest, Optional<Seconds> maxAgeCap);
 119     std::unique_ptr<Entry> update(const WebCore::ResourceRequest&, const GlobalFrameID&, const Entry&, const WebCore::ResourceResponse& validatingResponse);
 120
 121     struct TraversalEntry {
 122         const Entry& entry;
 123         const Storage::RecordInfo& recordInfo;
 124     };
 125     void traverse(Function<void(const TraversalEntry*)>&&);
 126     void remove(const Key&);
 127     void remove(const WebCore::ResourceRequest&);
 128     void remove(const Vector<Key>&, Function<void()>&&);
 129
 130     void clear();
 131     void clear(WallTime modifiedSince, Function<void()>&&);
 132
 133     void retrieveData(const DataKey&, Function<void(const uint8_t*, size_t)>);
 134     void storeData(const DataKey&,  const uint8_t* data, size_t);
 135
 136     std::unique_ptr<Entry> makeEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&);
 137     std::unique_ptr<Entry> makeRedirectEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest);
 138
 139     void dumpContentsToFile();
 140
 141     String recordsPath() const;
 142
 143 #if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
 144     SpeculativeLoadManager* speculativeLoadManager() { return m_speculativeLoadManager.get(); }
 145 #endif
 146
 147     NetworkProcess& networkProcess() { return m_networkProcess.get(); }
 148
 149     ~Cache();
 150
 151 private:
 152     Cache(NetworkProcess&, Ref<Storage>&&, OptionSet<CacheOption>);
 153
 154     Key makeCacheKey(const WebCore::ResourceRequest&);
 155
 156     static void completeRetrieve(RetrieveCompletionHandler&&, std::unique_ptr<Entry>, RetrieveInfo&);
 157
 158     String dumpFilePath() const;
 159     void deleteDumpFile();
 160
 161     Optional<Seconds> maxAgeCap(Entry&, const WebCore::ResourceRequest&, PAL::SessionID);
 162
 163     Ref<Storage> m_storage;
 164     Ref<NetworkProcess> m_networkProcess;
 165
 166 #if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
 167     std::unique_ptr<WebCore::LowPowerModeNotifier> m_lowPowerModeNotifier;
 168     std::unique_ptr<SpeculativeLoadManager> m_speculativeLoadManager;
 169 #endif
 170
 171     unsigned m_traverseCount { 0 };
 172 };
 173
 174 } // namespace NetworkCache
 175 } // namespace WebKit