439ebf0f79401e6139919cc0e7142be928fd34d7
[WebKit.git] / Source / WebKit / NetworkProcess / cache / NetworkCacheKey.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 NetworkCacheKey_h
27 #define NetworkCacheKey_h
28
29 #if ENABLE(NETWORK_CACHE)
30
31 #include "NetworkCacheData.h"
32 #include <wtf/SHA1.h>
33 #include <wtf/persistence/Coder.h>
34 #include <wtf/text/WTFString.h>
35
36 namespace WebKit {
37 namespace NetworkCache {
38
39 struct DataKey {
40     String partition;
41     String type;
42     SHA1::Digest identifier;
43
44     template <class Encoder> void encode(Encoder& encoder) const
45     {
46         encoder << partition << type << identifier;
47     }
48
49     template <class Decoder> static bool decode(Decoder& decoder, DataKey& dataKey)
50     {
51         return decoder.decode(dataKey.partition) && decoder.decode(dataKey.type) && decoder.decode(dataKey.identifier);
52     }
53 };
54
55 class Key {
56 public:
57     typedef SHA1::Digest HashType;
58
59     Key() { }
60     Key(const Key&);
61     Key(Key&&) = default;
62     Key(const String& partition, const String& type, const String& range, const String& identifier, const Salt&);
63     Key(const DataKey&, const Salt&);
64
65     Key& operator=(const Key&);
66     Key& operator=(Key&&) = default;
67
68     Key(WTF::HashTableDeletedValueType);
69     bool isHashTableDeletedValue() const { return m_identifier.isHashTableDeletedValue(); }
70
71     bool isNull() const { return m_identifier.isNull(); }
72
73     const String& partition() const { return m_partition; }
74     const String& identifier() const { return m_identifier; }
75     const String& type() const { return m_type; }
76     const String& range() const { return m_range; }
77
78     const HashType& hash() const { return m_hash; }
79     const HashType& partitionHash() const { return m_partitionHash; }
80
81     static bool stringToHash(const String&, HashType&);
82
83     static size_t hashStringLength() { return 2 * sizeof(m_hash); }
84     String hashAsString() const { return hashAsString(m_hash); }
85     String partitionHashAsString() const { return hashAsString(m_partitionHash); }
86
87     void encode(WTF::Persistence::Encoder&) const;
88     static bool decode(WTF::Persistence::Decoder&, Key&);
89
90     bool operator==(const Key&) const;
91     bool operator!=(const Key& other) const { return !(*this == other); }
92
93 private:
94     static String hashAsString(const HashType&);
95     HashType computeHash(const Salt&) const;
96     HashType computePartitionHash(const Salt&) const;
97
98     String m_partition;
99     String m_type;
100     String m_identifier;
101     String m_range;
102     HashType m_hash;
103     HashType m_partitionHash;
104 };
105
106 }
107 }
108
109 namespace WTF {
110
111 struct NetworkCacheKeyHash {
112     static unsigned hash(const WebKit::NetworkCache::Key& key)
113     {
114         static_assert(SHA1::hashSize >= sizeof(unsigned), "Hash size must be greater than sizeof(unsigned)");
115         return *reinterpret_cast<const unsigned*>(key.hash().data());
116     }
117
118     static bool equal(const WebKit::NetworkCache::Key& a, const WebKit::NetworkCache::Key& b)
119     {
120         return a == b;
121     }
122
123     static const bool safeToCompareToEmptyOrDeleted = false;
124 };
125
126 template<typename T> struct DefaultHash;
127 template<> struct DefaultHash<WebKit::NetworkCache::Key> {
128     typedef NetworkCacheKeyHash Hash;
129 };
130
131 template<> struct HashTraits<WebKit::NetworkCache::Key> : SimpleClassHashTraits<WebKit::NetworkCache::Key> {
132     static const bool emptyValueIsZero = false;
133
134     static const bool hasIsEmptyValueFunction = true;
135     static bool isEmptyValue(const WebKit::NetworkCache::Key& key) { return key.isNull(); }
136 };
137
138 } // namespace WTF
139
140 #endif
141 #endif