Add CatchScope and force all exception checks to be via ThrowScope or CatchScope.
[WebKit-https.git] / Source / WebCore / contentextensions / ContentExtensionRule.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 ContentExtensionRule_h
27 #define ContentExtensionRule_h
28
29 #if ENABLE(CONTENT_EXTENSIONS)
30
31 #include "ContentExtensionActions.h"
32 #include "ResourceLoadInfo.h"
33 #include <wtf/text/WTFString.h>
34
35 namespace WebCore {
36
37 namespace ContentExtensions {
38
39 // A ContentExtensionRule is the smallest unit in a ContentExtension.
40 //
41 // It is composed of a trigger and an action. The trigger defines on what kind of content this extension should apply.
42 // The action defines what to perform on that content.
43
44 struct Trigger {
45     String urlFilter;
46     bool urlFilterIsCaseSensitive { false };
47     ResourceFlags flags { 0 };
48     Vector<String> domains;
49     enum class DomainCondition {
50         None,
51         IfDomain,
52         UnlessDomain,
53     } domainCondition { DomainCondition::None };
54
55     ~Trigger()
56     {
57         ASSERT(domains.isEmpty() == (domainCondition == DomainCondition::None));
58     }
59
60     bool isEmpty() const
61     {
62         return urlFilter.isEmpty()
63             && !urlFilterIsCaseSensitive
64             && !flags
65             && domains.isEmpty()
66             && domainCondition == DomainCondition::None;
67     }
68
69     bool operator==(const Trigger& other) const
70     {
71         return urlFilter == other.urlFilter
72             && urlFilterIsCaseSensitive == other.urlFilterIsCaseSensitive
73             && flags == other.flags
74             && domains == other.domains
75             && domainCondition == other.domainCondition;
76     }
77 };
78
79 struct TriggerHash {
80     static unsigned hash(const Trigger& trigger)
81     {
82         unsigned hash = trigger.urlFilterIsCaseSensitive ? 10619863 : 40960001;
83         if (!trigger.urlFilter.isNull())
84             hash ^= StringHash::hash(trigger.urlFilter);
85         hash = WTF::pairIntHash(hash, DefaultHash<ResourceFlags>::Hash::hash(trigger.flags));
86
87         for (const String& domain : trigger.domains)
88             hash ^= StringHash::hash(domain);
89
90         if (trigger.domainCondition == Trigger::DomainCondition::IfDomain)
91             hash |= 1 << 16;
92         else if (trigger.domainCondition == Trigger::DomainCondition::IfDomain)
93             hash |= 1 << 31;
94         return hash;
95     }
96
97     static bool equal(const Trigger& a, const Trigger& b)
98     {
99         return a == b;
100     }
101
102     static const bool safeToCompareToEmptyOrDeleted = false;
103 };
104
105 struct TriggerHashTraits : public WTF::CustomHashTraits<Trigger> {
106     static const bool emptyValueIsZero = false;
107     static const bool hasIsEmptyValueFunction = true;
108
109     static void constructDeletedValue(Trigger& trigger)
110     {
111         new (NotNull, std::addressof(trigger.urlFilter)) String(WTF::HashTableDeletedValue);
112     }
113
114     static bool isDeletedValue(const Trigger& trigger)
115     {
116         return trigger.urlFilter.isHashTableDeletedValue();
117     }
118
119     static Trigger emptyValue()
120     {
121         return Trigger();
122     }
123
124     static bool isEmptyValue(const Trigger& trigger)
125     {
126         return trigger.isEmpty();
127     }
128 };
129
130 struct Action {
131     Action()
132         : m_type(ActionType::InvalidAction)
133         , m_actionID(std::numeric_limits<uint32_t>::max())
134     {
135     }
136
137     Action(ActionType type, const String& stringArgument, uint32_t actionID = std::numeric_limits<uint32_t>::max())
138         : m_type(type)
139         , m_actionID(actionID)
140         , m_stringArgument(stringArgument)
141     {
142         ASSERT(type == ActionType::CSSDisplayNoneSelector || type == ActionType::CSSDisplayNoneStyleSheet);
143     }
144
145     Action(ActionType type, uint32_t actionID = std::numeric_limits<uint32_t>::max())
146         : m_type(type)
147         , m_actionID(actionID)
148     {
149         ASSERT(type != ActionType::CSSDisplayNoneSelector && type != ActionType::CSSDisplayNoneStyleSheet);
150     }
151
152     bool operator==(const Action& other) const
153     {
154         return m_type == other.m_type
155             && m_extensionIdentifier == other.m_extensionIdentifier
156             && m_actionID == other.m_actionID
157             && m_stringArgument == other.m_stringArgument;
158     }
159
160     static Action deserialize(const SerializedActionByte* actions, const uint32_t actionsLength, uint32_t location);
161     static ActionType deserializeType(const SerializedActionByte* actions, const uint32_t actionsLength, uint32_t location);
162     static uint32_t serializedLength(const SerializedActionByte* actions, const uint32_t actionsLength, uint32_t location);
163
164     void setExtensionIdentifier(const String& extensionIdentifier) { m_extensionIdentifier = extensionIdentifier; }
165     const String& extensionIdentifier() const { return m_extensionIdentifier; }
166     ActionType type() const { return m_type; }
167     uint32_t actionID() const { return m_actionID; }
168     const String& stringArgument() const { return m_stringArgument; }
169
170 private:
171     String m_extensionIdentifier;
172     ActionType m_type;
173     uint32_t m_actionID;
174     String m_stringArgument;
175 };
176     
177 class ContentExtensionRule {
178 public:
179     ContentExtensionRule(const Trigger&, const Action&);
180
181     const Trigger& trigger() const { return m_trigger; }
182     const Action& action() const { return m_action; }
183
184 private:
185     Trigger m_trigger;
186     Action m_action;
187 };
188
189 } // namespace ContentExtensions
190
191 } // namespace WebCore
192
193 #endif // ENABLE(CONTENT_EXTENSIONS)
194
195 #endif // ContentExtensionRule_h