4cab39e775be5f8e755a30f576a6feef3a305931
[WebKit-https.git] / Source / WebKit2 / NetworkProcess / cache / NetworkCacheStorage.h
1 /*
2  * Copyright (C) 2014-2015 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 #ifndef NetworkCacheStorage_h
27 #define NetworkCacheStorage_h
28
29 #if ENABLE(NETWORK_CACHE)
30
31 #include "NetworkCacheData.h"
32 #include "NetworkCacheKey.h"
33 #include <wtf/BloomFilter.h>
34 #include <wtf/Deque.h>
35 #include <wtf/HashSet.h>
36 #include <wtf/Optional.h>
37 #include <wtf/WorkQueue.h>
38 #include <wtf/text/WTFString.h>
39
40 namespace WebKit {
41 namespace NetworkCache {
42
43 class IOChannel;
44
45 class Storage {
46     WTF_MAKE_NONCOPYABLE(Storage);
47 public:
48     static std::unique_ptr<Storage> open(const String& cachePath);
49
50     struct Record {
51         Key key;
52         std::chrono::system_clock::time_point timeStamp;
53         Data header;
54         Data body;
55     };
56     // This may call completion handler synchronously on failure.
57     typedef std::function<bool (std::unique_ptr<Record>)> RetrieveCompletionHandler;
58     void retrieve(const Key&, unsigned priority, RetrieveCompletionHandler&&);
59
60     typedef std::function<void (bool success, const Data& mappedBody)> StoreCompletionHandler;
61     void store(const Record&, StoreCompletionHandler&&);
62     void update(const Record& updateRecord, const Record& existingRecord, StoreCompletionHandler&&);
63
64     void remove(const Key&);
65
66     struct RecordInfo {
67         size_t bodySize { 0 };
68         double worth { -1 }; // 0-1 where 1 is the most valuable.
69     };
70     enum TraverseFlag {
71         ComputeWorth = 1 << 0,
72     };
73     typedef unsigned TraverseFlags;
74     // Null record signals end.
75     void traverse(TraverseFlags, std::function<void (const Record*, const RecordInfo&)>&&);
76
77     void setMaximumSize(size_t);
78     void clear();
79
80     static const unsigned version = 2;
81
82     const String& baseDirectoryPath() const { return m_baseDirectoryPath; }
83     const String& directoryPath() const { return m_directoryPath; }
84
85 private:
86     Storage(const String& directoryPath);
87
88     void initialize();
89     void deleteOldVersions();
90     void shrinkIfNeeded();
91
92     struct ReadOperation {
93         Key key;
94         RetrieveCompletionHandler completionHandler;
95     };
96     void dispatchReadOperation(const ReadOperation&);
97     void dispatchPendingReadOperations();
98
99     struct WriteOperation {
100         Record record;
101         Optional<Record> existingRecord;
102         StoreCompletionHandler completionHandler;
103     };
104     void dispatchFullWriteOperation(const WriteOperation&);
105     void dispatchHeaderWriteOperation(const WriteOperation&);
106     void dispatchPendingWriteOperations();
107
108     void updateFileModificationTime(IOChannel&);
109
110     WorkQueue& ioQueue() { return m_ioQueue.get(); }
111     WorkQueue& backgroundIOQueue() { return m_backgroundIOQueue.get(); }
112     WorkQueue& serialBackgroundIOQueue() { return m_serialBackgroundIOQueue.get(); }
113
114     bool cacheMayContain(unsigned shortHash) { return !m_hasPopulatedContentsFilter || m_contentsFilter.mayContain(shortHash); }
115
116     const String m_baseDirectoryPath;
117     const String m_directoryPath;
118
119     size_t m_maximumSize { std::numeric_limits<size_t>::max() };
120
121     CountingBloomFilter<20> m_contentsFilter;
122     std::atomic<bool> m_hasPopulatedContentsFilter { false };
123
124     std::atomic<size_t> m_approximateSize { 0 };
125     std::atomic<bool> m_shrinkInProgress { false };
126
127     static const int maximumRetrievePriority = 4;
128     Deque<std::unique_ptr<const ReadOperation>> m_pendingReadOperationsByPriority[maximumRetrievePriority + 1];
129     HashSet<std::unique_ptr<const ReadOperation>> m_activeReadOperations;
130
131     Deque<std::unique_ptr<const WriteOperation>> m_pendingWriteOperations;
132     HashSet<std::unique_ptr<const WriteOperation>> m_activeWriteOperations;
133
134     Ref<WorkQueue> m_ioQueue;
135     Ref<WorkQueue> m_backgroundIOQueue;
136     Ref<WorkQueue> m_serialBackgroundIOQueue;
137 };
138
139 }
140 }
141 #endif
142 #endif