Remove std::chrono completely
[WebKit.git] / Source / WebKit / NetworkProcess / cache / NetworkCacheStorage.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 "NetworkCacheBlobStorage.h"
29 #include "NetworkCacheData.h"
30 #include "NetworkCacheKey.h"
31 #include <WebCore/Timer.h>
32 #include <wtf/BloomFilter.h>
33 #include <wtf/Deque.h>
34 #include <wtf/Function.h>
35 #include <wtf/HashSet.h>
36 #include <wtf/Optional.h>
37 #include <wtf/WallTime.h>
38 #include <wtf/WorkQueue.h>
39 #include <wtf/text/WTFString.h>
40
41 namespace WebKit {
42 namespace NetworkCache {
43
44 class IOChannel;
45
46 class Storage : public ThreadSafeRefCounted<Storage> {
47 public:
48     enum class Mode { Normal, Testing };
49     static RefPtr<Storage> open(const String& cachePath, Mode);
50
51     struct Record {
52         WTF_MAKE_FAST_ALLOCATED;
53     public:
54         Key key;
55         WallTime timeStamp;
56         Data header;
57         Data body;
58         std::optional<SHA1::Digest> bodyHash;
59     };
60     // This may call completion handler synchronously on failure.
61     typedef Function<bool (std::unique_ptr<Record>)> RetrieveCompletionHandler;
62     void retrieve(const Key&, unsigned priority, RetrieveCompletionHandler&&);
63
64     typedef Function<void (const Data& mappedBody)> MappedBodyHandler;
65     void store(const Record&, MappedBodyHandler&&);
66
67     void remove(const Key&);
68     void remove(const Vector<Key>&, Function<void ()>&&);
69     void clear(const String& type, WallTime modifiedSinceTime, Function<void ()>&& completionHandler);
70
71     struct RecordInfo {
72         size_t bodySize;
73         double worth; // 0-1 where 1 is the most valuable.
74         unsigned bodyShareCount;
75         String bodyHash;
76     };
77     enum TraverseFlag {
78         ComputeWorth = 1 << 0,
79         ShareCount = 1 << 1,
80     };
81     typedef unsigned TraverseFlags;
82     typedef Function<void (const Record*, const RecordInfo&)> TraverseHandler;
83     // Null record signals end.
84     void traverse(const String& type, TraverseFlags, TraverseHandler&&);
85
86     void setCapacity(size_t);
87     size_t capacity() const { return m_capacity; }
88     size_t approximateSize() const;
89
90     static const unsigned version = 12;
91 #if PLATFORM(MAC)
92     /// Allow the last stable version of the cache to co-exist with the latest development one.
93     static const unsigned lastStableVersion = 11;
94 #endif
95
96     String basePath() const;
97     String versionPath() const;
98     String recordsPath() const;
99
100     const Salt& salt() const { return m_salt; }
101
102     bool canUseSharedMemoryForBodyData() const { return m_canUseSharedMemoryForBodyData; }
103
104     ~Storage();
105
106     void writeWithoutWaiting() { m_initialWriteDelay = 0_s; };
107
108 private:
109     Storage(const String& directoryPath, Mode, Salt);
110
111     String recordDirectoryPathForKey(const Key&) const;
112     String recordPathForKey(const Key&) const;
113     String blobPathForKey(const Key&) const;
114
115     void synchronize();
116     void deleteOldVersions();
117     void shrinkIfNeeded();
118     void shrink();
119
120     struct ReadOperation;
121     void dispatchReadOperation(std::unique_ptr<ReadOperation>);
122     void dispatchPendingReadOperations();
123     void finishReadOperation(ReadOperation&);
124     void cancelAllReadOperations();
125
126     struct WriteOperation;
127     void dispatchWriteOperation(std::unique_ptr<WriteOperation>);
128     void dispatchPendingWriteOperations();
129     void finishWriteOperation(WriteOperation&);
130
131     std::optional<BlobStorage::Blob> storeBodyAsBlob(WriteOperation&);
132     Data encodeRecord(const Record&, std::optional<BlobStorage::Blob>);
133     void readRecord(ReadOperation&, const Data&);
134
135     void updateFileModificationTime(const String& path);
136     void removeFromPendingWriteOperations(const Key&);
137
138     WorkQueue& ioQueue() { return m_ioQueue.get(); }
139     WorkQueue& backgroundIOQueue() { return m_backgroundIOQueue.get(); }
140     WorkQueue& serialBackgroundIOQueue() { return m_serialBackgroundIOQueue.get(); }
141
142     bool mayContain(const Key&) const;
143     bool mayContainBlob(const Key&) const;
144
145     void addToRecordFilter(const Key&);
146     void deleteFiles(const Key&);
147
148     const String m_basePath;
149     const String m_recordsPath;
150     
151     const Mode m_mode;
152     const Salt m_salt;
153     const bool m_canUseSharedMemoryForBodyData;
154
155     size_t m_capacity { std::numeric_limits<size_t>::max() };
156     size_t m_approximateRecordsSize { 0 };
157
158     // 2^18 bit filter can support up to 26000 entries with false positive rate < 1%.
159     using ContentsFilter = BloomFilter<18>;
160     std::unique_ptr<ContentsFilter> m_recordFilter;
161     std::unique_ptr<ContentsFilter> m_blobFilter;
162
163     bool m_synchronizationInProgress { false };
164     bool m_shrinkInProgress { false };
165
166     Vector<Key::HashType> m_recordFilterHashesAddedDuringSynchronization;
167     Vector<Key::HashType> m_blobFilterHashesAddedDuringSynchronization;
168
169     static const int maximumRetrievePriority = 4;
170     Deque<std::unique_ptr<ReadOperation>> m_pendingReadOperationsByPriority[maximumRetrievePriority + 1];
171     HashSet<std::unique_ptr<ReadOperation>> m_activeReadOperations;
172     WebCore::Timer m_readOperationTimeoutTimer;
173
174     Deque<std::unique_ptr<WriteOperation>> m_pendingWriteOperations;
175     HashSet<std::unique_ptr<WriteOperation>> m_activeWriteOperations;
176     WebCore::Timer m_writeOperationDispatchTimer;
177
178     struct TraverseOperation;
179     HashSet<std::unique_ptr<TraverseOperation>> m_activeTraverseOperations;
180
181     Ref<WorkQueue> m_ioQueue;
182     Ref<WorkQueue> m_backgroundIOQueue;
183     Ref<WorkQueue> m_serialBackgroundIOQueue;
184
185     BlobStorage m_blobStorage;
186
187     // By default, delay the start of writes a bit to avoid affecting early page load.
188     // Completing writes will dispatch more writes without delay.
189     Seconds m_initialWriteDelay { 1_s };
190 };
191
192 // FIXME: Remove, used by NetworkCacheStatistics only.
193 using RecordFileTraverseFunction = Function<void (const String& fileName, const String& hashString, const String& type, bool isBlob, const String& recordDirectoryPath)>;
194 void traverseRecordsFiles(const String& recordsPath, const String& type, const RecordFileTraverseFunction&);
195
196 }
197 }