Use "= default" to denote default constructor or destructor
[WebKit-https.git] / Source / WebCore / page / SettingsBase.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009, 2011, 2012 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. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "SettingsBase.h"
28
29 #include "AudioSession.h"
30 #include "BackForwardController.h"
31 #include "CachedResourceLoader.h"
32 #include "CookieStorage.h"
33 #include "DOMTimer.h"
34 #include "Database.h"
35 #include "Document.h"
36 #include "FontCascade.h"
37 #include "FontGenericFamilies.h"
38 #include "FrameTree.h"
39 #include "FrameView.h"
40 #include "HistoryItem.h"
41 #include "MainFrame.h"
42 #include "Page.h"
43 #include "PageCache.h"
44 #include "RuntimeApplicationChecks.h"
45 #include "Settings.h"
46 #include "StorageMap.h"
47 #include <limits>
48 #include <wtf/StdLibExtras.h>
49
50 namespace WebCore {
51
52 static void invalidateAfterGenericFamilyChange(Page* page)
53 {
54     invalidateFontCascadeCache();
55     if (page)
56         page->setNeedsRecalcStyleInAllFrames();
57 }
58
59 // This amount of time must have elapsed before we will even consider scheduling a layout without a delay.
60 // FIXME: For faster machines this value can really be lowered to 200. 250 is adequate, but a little high
61 // for dual G5s. :)
62 static const Seconds layoutScheduleThreshold = 250_ms;
63
64 SettingsBase::SettingsBase(Page* page)
65     : m_page(nullptr)
66     , m_fontGenericFamilies(std::make_unique<FontGenericFamilies>())
67     , m_layoutInterval(layoutScheduleThreshold)
68     , m_minimumDOMTimerInterval(DOMTimer::defaultMinimumInterval())
69     , m_setImageLoadingSettingsTimer(*this, &SettingsBase::imageLoadingSettingsTimerFired)
70 {
71     // A Frame may not have been created yet, so we initialize the AtomicString
72     // hash before trying to use it.
73     AtomicString::init();
74     initializeDefaultFontFamilies();
75     m_page = page; // Page is not yet fully initialized when constructing Settings, so keeping m_page null over initializeDefaultFontFamilies() call.
76 }
77
78 SettingsBase::~SettingsBase() = default;
79
80 float SettingsBase::defaultMinimumZoomFontSize()
81 {
82     return 15;
83 }
84
85 #if !PLATFORM(IOS)
86 bool SettingsBase::defaultTextAutosizingEnabled()
87 {
88     return false;
89 }
90 #endif
91
92 #if !PLATFORM(COCOA)
93 const String& SettingsBase::defaultMediaContentTypesRequiringHardwareSupport()
94 {
95     return emptyString();
96 }
97 #endif
98
99 #if !PLATFORM(COCOA)
100 void SettingsBase::initializeDefaultFontFamilies()
101 {
102     // Other platforms can set up fonts from a client, but on Mac, we want it in WebCore to share code between WebKit1 and WebKit2.
103 }
104 #endif
105
106 const AtomicString& SettingsBase::standardFontFamily(UScriptCode script) const
107 {
108     return m_fontGenericFamilies->standardFontFamily(script);
109 }
110
111 void SettingsBase::setStandardFontFamily(const AtomicString& family, UScriptCode script)
112 {
113     bool changes = m_fontGenericFamilies->setStandardFontFamily(family, script);
114     if (changes)
115         invalidateAfterGenericFamilyChange(m_page);
116 }
117
118 const AtomicString& SettingsBase::fixedFontFamily(UScriptCode script) const
119 {
120     return m_fontGenericFamilies->fixedFontFamily(script);
121 }
122
123 void SettingsBase::setFixedFontFamily(const AtomicString& family, UScriptCode script)
124 {
125     bool changes = m_fontGenericFamilies->setFixedFontFamily(family, script);
126     if (changes)
127         invalidateAfterGenericFamilyChange(m_page);
128 }
129
130 const AtomicString& SettingsBase::serifFontFamily(UScriptCode script) const
131 {
132     return m_fontGenericFamilies->serifFontFamily(script);
133 }
134
135 void SettingsBase::setSerifFontFamily(const AtomicString& family, UScriptCode script)
136 {
137     bool changes = m_fontGenericFamilies->setSerifFontFamily(family, script);
138     if (changes)
139         invalidateAfterGenericFamilyChange(m_page);
140 }
141
142 const AtomicString& SettingsBase::sansSerifFontFamily(UScriptCode script) const
143 {
144     return m_fontGenericFamilies->sansSerifFontFamily(script);
145 }
146
147 void SettingsBase::setSansSerifFontFamily(const AtomicString& family, UScriptCode script)
148 {
149     bool changes = m_fontGenericFamilies->setSansSerifFontFamily(family, script);
150     if (changes)
151         invalidateAfterGenericFamilyChange(m_page);
152 }
153
154 const AtomicString& SettingsBase::cursiveFontFamily(UScriptCode script) const
155 {
156     return m_fontGenericFamilies->cursiveFontFamily(script);
157 }
158
159 void SettingsBase::setCursiveFontFamily(const AtomicString& family, UScriptCode script)
160 {
161     bool changes = m_fontGenericFamilies->setCursiveFontFamily(family, script);
162     if (changes)
163         invalidateAfterGenericFamilyChange(m_page);
164 }
165
166 const AtomicString& SettingsBase::fantasyFontFamily(UScriptCode script) const
167 {
168     return m_fontGenericFamilies->fantasyFontFamily(script);
169 }
170
171 void SettingsBase::setFantasyFontFamily(const AtomicString& family, UScriptCode script)
172 {
173     bool changes = m_fontGenericFamilies->setFantasyFontFamily(family, script);
174     if (changes)
175         invalidateAfterGenericFamilyChange(m_page);
176 }
177
178 const AtomicString& SettingsBase::pictographFontFamily(UScriptCode script) const
179 {
180     return m_fontGenericFamilies->pictographFontFamily(script);
181 }
182
183 void SettingsBase::setPictographFontFamily(const AtomicString& family, UScriptCode script)
184 {
185     bool changes = m_fontGenericFamilies->setPictographFontFamily(family, script);
186     if (changes)
187         invalidateAfterGenericFamilyChange(m_page);
188 }
189
190 void SettingsBase::setMinimumDOMTimerInterval(Seconds interval)
191 {
192     auto oldTimerInterval = std::exchange(m_minimumDOMTimerInterval, interval);
193
194     if (!m_page)
195         return;
196
197     for (Frame* frame = &m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
198         if (frame->document())
199             frame->document()->adjustMinimumDOMTimerInterval(oldTimerInterval);
200     }
201 }
202
203 void SettingsBase::setLayoutInterval(Seconds layoutInterval)
204 {
205     // FIXME: It seems weird that this function may disregard the specified layout interval.
206     // We should either expose layoutScheduleThreshold or better communicate this invariant.
207     m_layoutInterval = std::max(layoutInterval, layoutScheduleThreshold);
208 }
209
210 void SettingsBase::setMediaContentTypesRequiringHardwareSupport(const String& contentTypes)
211 {
212     m_mediaContentTypesRequiringHardwareSupport.shrink(0);
213     for (auto type : StringView(contentTypes).split(':'))
214         m_mediaContentTypesRequiringHardwareSupport.append(ContentType { type.toString() });
215 }
216
217 void SettingsBase::setMediaContentTypesRequiringHardwareSupport(const Vector<ContentType>& contentTypes)
218 {
219     m_mediaContentTypesRequiringHardwareSupport = contentTypes;
220 }
221
222
223
224 // MARK - onChange handlers
225
226 void SettingsBase::setNeedsRecalcStyleInAllFrames()
227 {
228     if (m_page)
229         m_page->setNeedsRecalcStyleInAllFrames();
230 }
231
232 void SettingsBase::mediaTypeOverrideChanged()
233 {
234     if (!m_page)
235         return;
236
237     FrameView* view = m_page->mainFrame().view();
238     if (view)
239         view->setMediaType(m_page->settings().mediaTypeOverride());
240
241     m_page->setNeedsRecalcStyleInAllFrames();
242 }
243
244 void SettingsBase::imagesEnabledChanged()
245 {
246     // Changing this setting to true might immediately start new loads for images that had previously had loading disabled.
247     // If this happens while a WebView is being dealloc'ed, and we don't know the WebView is being dealloc'ed, these new loads
248     // can cause crashes downstream when the WebView memory has actually been free'd.
249     // One example where this can happen is in Mac apps that subclass WebView then do work in their overridden dealloc methods.
250     // Starting these loads synchronously is not important. By putting it on a 0-delay, properly closing the Page cancels them
251     // before they have a chance to really start.
252     // See http://webkit.org/b/60572 for more discussion.
253     m_setImageLoadingSettingsTimer.startOneShot(0_s);
254 }
255
256 void SettingsBase::imageLoadingSettingsTimerFired()
257 {
258     if (!m_page)
259         return;
260
261     for (Frame* frame = &m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
262         if (!frame->document())
263             continue;
264         frame->document()->cachedResourceLoader().setImagesEnabled(m_page->settings().areImagesEnabled());
265         frame->document()->cachedResourceLoader().setAutoLoadImages(m_page->settings().loadsImagesAutomatically());
266     }
267 }
268
269 void SettingsBase::scriptEnabledChanged()
270 {
271 #if PLATFORM(IOS)
272     // FIXME: Why do we only do this on iOS?
273     if (m_page)
274         m_page->setNeedsRecalcStyleInAllFrames();
275 #endif
276 }
277
278 void SettingsBase::pluginsEnabledChanged()
279 {
280     Page::refreshPlugins(false);
281 }
282
283 void SettingsBase::userStyleSheetLocationChanged()
284 {
285     if (m_page)
286         m_page->userStyleSheetLocationChanged();
287 }
288
289 void SettingsBase::usesPageCacheChanged()
290 {
291     if (!m_page)
292         return;
293
294     if (!m_page->settings().usesPageCache())
295         PageCache::singleton().pruneToSizeNow(0, PruningReason::None);
296 }
297
298 void SettingsBase::dnsPrefetchingEnabledChanged()
299 {
300     if (m_page)
301         m_page->dnsPrefetchingStateChanged();
302 }
303
304 void SettingsBase::storageBlockingPolicyChanged()
305 {
306     if (m_page)
307         m_page->storageBlockingStateChanged();
308 }
309
310 void SettingsBase::backgroundShouldExtendBeyondPageChanged()
311 {
312     if (m_page)
313         m_page->mainFrame().view()->updateExtendBackgroundIfNecessary();
314 }
315
316 void SettingsBase::scrollingPerformanceLoggingEnabledChanged()
317 {
318     if (m_page && m_page->mainFrame().view())
319         m_page->mainFrame().view()->setScrollingPerformanceLoggingEnabled(m_page->settings().scrollingPerformanceLoggingEnabled());
320 }
321
322 void SettingsBase::hiddenPageDOMTimerThrottlingStateChanged()
323 {
324     if (m_page)
325         m_page->hiddenPageDOMTimerThrottlingStateChanged();
326 }
327
328 void SettingsBase::hiddenPageCSSAnimationSuspensionEnabledChanged()
329 {
330     if (m_page)
331         m_page->hiddenPageCSSAnimationSuspensionStateChanged();
332 }
333
334 void SettingsBase::resourceUsageOverlayVisibleChanged()
335 {
336 #if ENABLE(RESOURCE_USAGE)
337     if (m_page)
338         m_page->setResourceUsageOverlayVisible(m_page->settings().resourceUsageOverlayVisible());
339 #endif
340 }
341
342 } // namespace WebCore