2015-11-03 Geoffrey Garen <ggaren@apple.com>
[WebKit-https.git] / Source / WebCore / page / Settings.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 "Settings.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 "HTMLMediaElement.h"
41 #include "HistoryItem.h"
42 #include "InspectorInstrumentation.h"
43 #include "MainFrame.h"
44 #include "Page.h"
45 #include "PageCache.h"
46 #include "StorageMap.h"
47 #include "TextAutosizer.h"
48 #include <limits>
49 #include <wtf/NeverDestroyed.h>
50 #include <wtf/StdLibExtras.h>
51
52 namespace WebCore {
53
54 static void setImageLoadingSettings(Page* page)
55 {
56     if (!page)
57         return;
58
59     for (Frame* frame = &page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
60         frame->document()->cachedResourceLoader().setImagesEnabled(page->settings().areImagesEnabled());
61         frame->document()->cachedResourceLoader().setAutoLoadImages(page->settings().loadsImagesAutomatically());
62     }
63 }
64
65 static void invalidateAfterGenericFamilyChange(Page* page)
66 {
67     invalidateFontCascadeCache();
68     if (page)
69         page->setNeedsRecalcStyleInAllFrames();
70 }
71
72 #if USE(AVFOUNDATION)
73 bool Settings::gAVFoundationEnabled = true;
74 #endif
75
76 #if PLATFORM(COCOA)
77 bool Settings::gQTKitEnabled = false;
78 #endif
79
80 bool Settings::gMockScrollbarsEnabled = false;
81 bool Settings::gUsesOverlayScrollbars = false;
82
83 #if PLATFORM(WIN)
84 bool Settings::gShouldUseHighResolutionTimers = true;
85 #endif
86     
87 bool Settings::gShouldRewriteConstAsVar = false;
88 bool Settings::gShouldRespectPriorityInCSSAttributeSetters = false;
89 bool Settings::gLowPowerVideoAudioBufferSizeEnabled = false;
90
91 #if PLATFORM(IOS)
92 bool Settings::gNetworkDataUsageTrackingEnabled = false;
93 bool Settings::gAVKitEnabled = false;
94 bool Settings::gShouldOptOutOfNetworkStateObservation = false;
95 bool Settings::gManageAudioSession = false;
96 #endif
97
98 // NOTEs
99 //  1) EditingMacBehavior comprises Tiger, Leopard, SnowLeopard and iOS builds, as well as QtWebKit when built on Mac;
100 //  2) EditingWindowsBehavior comprises Win32 build;
101 //  3) EditingUnixBehavior comprises all unix-based systems, but Darwin/MacOS (and then abusing the terminology);
102 // 99) MacEditingBehavior is used as a fallback.
103 static EditingBehaviorType editingBehaviorTypeForPlatform()
104 {
105     return
106 #if PLATFORM(IOS)
107     EditingIOSBehavior
108 #elif OS(DARWIN)
109     EditingMacBehavior
110 #elif OS(WINDOWS)
111     EditingWindowsBehavior
112 #elif OS(UNIX)
113     EditingUnixBehavior
114 #else
115     // Fallback
116     EditingMacBehavior
117 #endif
118     ;
119 }
120
121 #if PLATFORM(IOS)
122 static const bool defaultFixedPositionCreatesStackingContext = true;
123 static const bool defaultFixedBackgroundsPaintRelativeToDocument = true;
124 static const bool defaultAcceleratedCompositingForFixedPositionEnabled = true;
125 static const bool defaultAllowsInlineMediaPlayback = false;
126 static const bool defaultInlineMediaPlaybackRequiresPlaysInlineAttribute = true;
127 static const bool defaultRequiresUserGestureForMediaPlayback = true;
128 static const bool defaultAudioPlaybackRequiresUserGesture = true;
129 static const bool defaultMediaDataLoadsAutomatically = false;
130 static const bool defaultShouldRespectImageOrientation = true;
131 static const bool defaultImageSubsamplingEnabled = true;
132 static const bool defaultScrollingTreeIncludesFrames = true;
133 static const bool defaultMediaControlsScaleWithPageZoom = true;
134 #else
135 static const bool defaultFixedPositionCreatesStackingContext = false;
136 static const bool defaultFixedBackgroundsPaintRelativeToDocument = false;
137 static const bool defaultAcceleratedCompositingForFixedPositionEnabled = false;
138 static const bool defaultAllowsInlineMediaPlayback = true;
139 static const bool defaultInlineMediaPlaybackRequiresPlaysInlineAttribute = false;
140 static const bool defaultRequiresUserGestureForMediaPlayback = false;
141 static const bool defaultAudioPlaybackRequiresUserGesture = false;
142 static const bool defaultMediaDataLoadsAutomatically = true;
143 static const bool defaultShouldRespectImageOrientation = false;
144 static const bool defaultImageSubsamplingEnabled = false;
145 static const bool defaultScrollingTreeIncludesFrames = false;
146 static const bool defaultMediaControlsScaleWithPageZoom = true;
147 #endif
148
149 static const bool defaultAllowsPictureInPictureMediaPlayback = true;
150
151 static const double defaultIncrementalRenderingSuppressionTimeoutInSeconds = 5;
152 #if USE(UNIFIED_TEXT_CHECKING)
153 static const bool defaultUnifiedTextCheckerEnabled = true;
154 #else
155 static const bool defaultUnifiedTextCheckerEnabled = false;
156 #endif
157 static const bool defaultSmartInsertDeleteEnabled = true;
158 static const bool defaultSelectTrailingWhitespaceEnabled = false;
159
160 // This amount of time must have elapsed before we will even consider scheduling a layout without a delay.
161 // FIXME: For faster machines this value can really be lowered to 200. 250 is adequate, but a little high
162 // for dual G5s. :)
163 static const auto layoutScheduleThreshold = std::chrono::milliseconds(250);
164
165 Settings::Settings(Page* page)
166     : m_page(nullptr)
167     , m_mediaTypeOverride("screen")
168     , m_fontGenericFamilies(std::make_unique<FontGenericFamilies>())
169     , m_storageBlockingPolicy(SecurityOrigin::AllowAllStorage)
170     , m_layoutInterval(layoutScheduleThreshold)
171     , m_minimumDOMTimerInterval(DOMTimer::defaultMinimumInterval())
172     , m_domTimerAlignmentInterval(DOMTimer::defaultAlignmentInterval())
173 #if ENABLE(TEXT_AUTOSIZING)
174     , m_textAutosizingFontScaleFactor(1)
175 #if HACK_FORCE_TEXT_AUTOSIZING_ON_DESKTOP
176     , m_textAutosizingWindowSizeOverride(320, 480)
177     , m_textAutosizingEnabled(true)
178 #else
179     , m_textAutosizingEnabled(false)
180 #endif
181 #endif
182     SETTINGS_INITIALIZER_LIST
183     , m_isJavaEnabled(false)
184     , m_isJavaEnabledForLocalFiles(true)
185     , m_loadsImagesAutomatically(false)
186     , m_areImagesEnabled(true)
187     , m_arePluginsEnabled(false)
188     , m_isScriptEnabled(false)
189     , m_needsAdobeFrameReloadingQuirk(false)
190     , m_usesPageCache(false)
191     , m_fontRenderingMode(0)
192     , m_antialiasedFontDilationEnabled(false)
193     , m_showTiledScrollingIndicator(false)
194     , m_backgroundShouldExtendBeyondPage(false)
195     , m_dnsPrefetchingEnabled(false)
196 #if ENABLE(TOUCH_EVENTS)
197     , m_touchEventEmulationEnabled(false)
198 #endif
199     , m_scrollingPerformanceLoggingEnabled(false)
200     , m_timeWithoutMouseMovementBeforeHidingControls(3)
201     , m_setImageLoadingSettingsTimer(*this, &Settings::imageLoadingSettingsTimerFired)
202 #if ENABLE(HIDDEN_PAGE_DOM_TIMER_THROTTLING)
203     , m_hiddenPageDOMTimerThrottlingEnabled(false)
204 #endif
205     , m_hiddenPageCSSAnimationSuspensionEnabled(false)
206     , m_fontFallbackPrefersPictographs(false)
207     , m_forcePendingWebGLPolicy(false)
208 {
209     // A Frame may not have been created yet, so we initialize the AtomicString
210     // hash before trying to use it.
211     AtomicString::init();
212     initializeDefaultFontFamilies();
213     m_page = page; // Page is not yet fully initialized when constructing Settings, so keeping m_page null over initializeDefaultFontFamilies() call.
214 }
215
216 Settings::~Settings()
217 {
218 }
219
220 Ref<Settings> Settings::create(Page* page)
221 {
222     return adoptRef(*new Settings(page));
223 }
224
225 SETTINGS_SETTER_BODIES
226
227 #if !PLATFORM(COCOA)
228 void Settings::initializeDefaultFontFamilies()
229 {
230     // Other platforms can set up fonts from a client, but on Mac, we want it in WebCore to share code between WebKit1 and WebKit2.
231 }
232 #endif
233
234 const AtomicString& Settings::standardFontFamily(UScriptCode script) const
235 {
236     return m_fontGenericFamilies->standardFontFamily(script);
237 }
238
239 void Settings::setStandardFontFamily(const AtomicString& family, UScriptCode script)
240 {
241     bool changes = m_fontGenericFamilies->setStandardFontFamily(family, script);
242     if (changes)
243         invalidateAfterGenericFamilyChange(m_page);
244 }
245
246 const AtomicString& Settings::fixedFontFamily(UScriptCode script) const
247 {
248     return m_fontGenericFamilies->fixedFontFamily(script);
249 }
250
251 void Settings::setFixedFontFamily(const AtomicString& family, UScriptCode script)
252 {
253     bool changes = m_fontGenericFamilies->setFixedFontFamily(family, script);
254     if (changes)
255         invalidateAfterGenericFamilyChange(m_page);
256 }
257
258 const AtomicString& Settings::serifFontFamily(UScriptCode script) const
259 {
260     return m_fontGenericFamilies->serifFontFamily(script);
261 }
262
263 void Settings::setSerifFontFamily(const AtomicString& family, UScriptCode script)
264 {
265     bool changes = m_fontGenericFamilies->setSerifFontFamily(family, script);
266     if (changes)
267         invalidateAfterGenericFamilyChange(m_page);
268 }
269
270 const AtomicString& Settings::sansSerifFontFamily(UScriptCode script) const
271 {
272     return m_fontGenericFamilies->sansSerifFontFamily(script);
273 }
274
275 void Settings::setSansSerifFontFamily(const AtomicString& family, UScriptCode script)
276 {
277     bool changes = m_fontGenericFamilies->setSansSerifFontFamily(family, script);
278     if (changes)
279         invalidateAfterGenericFamilyChange(m_page);
280 }
281
282 const AtomicString& Settings::cursiveFontFamily(UScriptCode script) const
283 {
284     return m_fontGenericFamilies->cursiveFontFamily(script);
285 }
286
287 void Settings::setCursiveFontFamily(const AtomicString& family, UScriptCode script)
288 {
289     bool changes = m_fontGenericFamilies->setCursiveFontFamily(family, script);
290     if (changes)
291         invalidateAfterGenericFamilyChange(m_page);
292 }
293
294 const AtomicString& Settings::fantasyFontFamily(UScriptCode script) const
295 {
296     return m_fontGenericFamilies->fantasyFontFamily(script);
297 }
298
299 void Settings::setFantasyFontFamily(const AtomicString& family, UScriptCode script)
300 {
301     bool changes = m_fontGenericFamilies->setFantasyFontFamily(family, script);
302     if (changes)
303         invalidateAfterGenericFamilyChange(m_page);
304 }
305
306 const AtomicString& Settings::pictographFontFamily(UScriptCode script) const
307 {
308     return m_fontGenericFamilies->pictographFontFamily(script);
309 }
310
311 void Settings::setPictographFontFamily(const AtomicString& family, UScriptCode script)
312 {
313     bool changes = m_fontGenericFamilies->setPictographFontFamily(family, script);
314     if (changes)
315         invalidateAfterGenericFamilyChange(m_page);
316 }
317
318 #if ENABLE(TEXT_AUTOSIZING)
319 void Settings::setTextAutosizingEnabled(bool textAutosizingEnabled)
320 {
321     if (m_textAutosizingEnabled == textAutosizingEnabled)
322         return;
323
324     m_textAutosizingEnabled = textAutosizingEnabled;
325     if (m_page)
326         m_page->setNeedsRecalcStyleInAllFrames();
327 }
328
329 void Settings::setTextAutosizingWindowSizeOverride(const IntSize& textAutosizingWindowSizeOverride)
330 {
331     if (m_textAutosizingWindowSizeOverride == textAutosizingWindowSizeOverride)
332         return;
333
334     m_textAutosizingWindowSizeOverride = textAutosizingWindowSizeOverride;
335     if (m_page)
336         m_page->setNeedsRecalcStyleInAllFrames();
337 }
338
339 void Settings::setTextAutosizingFontScaleFactor(float fontScaleFactor)
340 {
341     m_textAutosizingFontScaleFactor = fontScaleFactor;
342
343     if (!m_page)
344         return;
345
346     // FIXME: I wonder if this needs to traverse frames like in WebViewImpl::resize, or whether there is only one document per Settings instance?
347     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext())
348         frame->document()->textAutosizer()->recalculateMultipliers();
349
350     m_page->setNeedsRecalcStyleInAllFrames();
351 }
352
353 #endif
354
355 void Settings::setAntialiasedFontDilationEnabled(bool enabled)
356 {
357     // FIXME: It's wrong for a setting to toggle a global, but this code is temporary.
358     FontCascade::setAntialiasedFontDilationEnabled(enabled);
359 }
360
361 void Settings::setMediaTypeOverride(const String& mediaTypeOverride)
362 {
363     if (m_mediaTypeOverride == mediaTypeOverride)
364         return;
365
366     m_mediaTypeOverride = mediaTypeOverride;
367
368     if (!m_page)
369         return;
370
371     FrameView* view = m_page->mainFrame().view();
372     ASSERT(view);
373
374     view->setMediaType(mediaTypeOverride);
375     m_page->setNeedsRecalcStyleInAllFrames();
376 }
377
378 void Settings::setLoadsImagesAutomatically(bool loadsImagesAutomatically)
379 {
380     m_loadsImagesAutomatically = loadsImagesAutomatically;
381     
382     // Changing this setting to true might immediately start new loads for images that had previously had loading disabled.
383     // If this happens while a WebView is being dealloc'ed, and we don't know the WebView is being dealloc'ed, these new loads
384     // can cause crashes downstream when the WebView memory has actually been free'd.
385     // One example where this can happen is in Mac apps that subclass WebView then do work in their overridden dealloc methods.
386     // Starting these loads synchronously is not important.  By putting it on a 0-delay, properly closing the Page cancels them
387     // before they have a chance to really start.
388     // See http://webkit.org/b/60572 for more discussion.
389     m_setImageLoadingSettingsTimer.startOneShot(0);
390 }
391
392 void Settings::imageLoadingSettingsTimerFired()
393 {
394     setImageLoadingSettings(m_page);
395 }
396
397 void Settings::setScriptEnabled(bool isScriptEnabled)
398 {
399     if (m_isScriptEnabled == isScriptEnabled)
400         return;
401
402     m_isScriptEnabled = isScriptEnabled;
403
404     if (!m_page)
405         return;
406
407 #if PLATFORM(IOS)
408     m_page->setNeedsRecalcStyleInAllFrames();
409 #endif
410     InspectorInstrumentation::scriptsEnabled(*m_page, m_isScriptEnabled);
411 }
412
413 void Settings::setJavaEnabled(bool isJavaEnabled)
414 {
415     m_isJavaEnabled = isJavaEnabled;
416 }
417
418 void Settings::setJavaEnabledForLocalFiles(bool isJavaEnabledForLocalFiles)
419 {
420     m_isJavaEnabledForLocalFiles = isJavaEnabledForLocalFiles;
421 }
422
423 void Settings::setImagesEnabled(bool areImagesEnabled)
424 {
425     m_areImagesEnabled = areImagesEnabled;
426
427     // See comment in setLoadsImagesAutomatically.
428     m_setImageLoadingSettingsTimer.startOneShot(0);
429 }
430
431 void Settings::setForcePendingWebGLPolicy(bool forced)
432 {
433     m_forcePendingWebGLPolicy = forced;
434 }
435
436 void Settings::setPluginsEnabled(bool arePluginsEnabled)
437 {
438     if (m_arePluginsEnabled == arePluginsEnabled)
439         return;
440
441     m_arePluginsEnabled = arePluginsEnabled;
442     Page::refreshPlugins(false);
443 }
444
445 void Settings::setUserStyleSheetLocation(const URL& userStyleSheetLocation)
446 {
447     if (m_userStyleSheetLocation == userStyleSheetLocation)
448         return;
449
450     m_userStyleSheetLocation = userStyleSheetLocation;
451
452     if (m_page)
453         m_page->userStyleSheetLocationChanged();
454 }
455
456 // FIXME: This quirk is needed because of Radar 4674537 and 5211271. We need to phase it out once Adobe
457 // can fix the bug from their end.
458 void Settings::setNeedsAdobeFrameReloadingQuirk(bool shouldNotReloadIFramesForUnchangedSRC)
459 {
460     m_needsAdobeFrameReloadingQuirk = shouldNotReloadIFramesForUnchangedSRC;
461 }
462
463 void Settings::setMinimumDOMTimerInterval(double interval)
464 {
465     double oldTimerInterval = m_minimumDOMTimerInterval;
466     m_minimumDOMTimerInterval = interval;
467
468     if (!m_page)
469         return;
470
471     for (Frame* frame = &m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
472         if (frame->document())
473             frame->document()->adjustMinimumTimerInterval(oldTimerInterval);
474     }
475 }
476
477 void Settings::setDOMTimerAlignmentInterval(double alignmentInterval)
478 {
479     m_domTimerAlignmentInterval = alignmentInterval;
480 }
481
482 void Settings::setLayoutInterval(std::chrono::milliseconds layoutInterval)
483 {
484     // FIXME: It seems weird that this function may disregard the specified layout interval.
485     // We should either expose layoutScheduleThreshold or better communicate this invariant.
486     m_layoutInterval = std::max(layoutInterval, layoutScheduleThreshold);
487 }
488
489 void Settings::setUsesPageCache(bool usesPageCache)
490 {
491     if (m_usesPageCache == usesPageCache)
492         return;
493         
494     m_usesPageCache = usesPageCache;
495
496     if (!m_page)
497         return;
498
499     if (!m_usesPageCache)
500         PageCache::singleton().pruneToSizeNow(0, PruningReason::None);
501 }
502
503 void Settings::setFontRenderingMode(FontRenderingMode mode)
504 {
505     if (fontRenderingMode() == mode)
506         return;
507     m_fontRenderingMode = static_cast<int>(mode);
508     if (m_page)
509         m_page->setNeedsRecalcStyleInAllFrames();
510 }
511
512 FontRenderingMode Settings::fontRenderingMode() const
513 {
514     return static_cast<FontRenderingMode>(m_fontRenderingMode);
515 }
516
517 void Settings::setDNSPrefetchingEnabled(bool dnsPrefetchingEnabled)
518 {
519     if (m_dnsPrefetchingEnabled == dnsPrefetchingEnabled)
520         return;
521
522     m_dnsPrefetchingEnabled = dnsPrefetchingEnabled;
523     if (m_page)
524         m_page->dnsPrefetchingStateChanged();
525 }
526
527 void Settings::setShowTiledScrollingIndicator(bool enabled)
528 {
529     if (m_showTiledScrollingIndicator == enabled)
530         return;
531         
532     m_showTiledScrollingIndicator = enabled;
533 }
534
535 #if ENABLE(RESOURCE_USAGE_OVERLAY)
536 void Settings::setResourceUsageOverlayVisible(bool visible)
537 {
538     if (m_resourceUsageOverlayVisible == visible)
539         return;
540
541     m_resourceUsageOverlayVisible = visible;
542     if (m_page)
543         m_page->setResourceUsageOverlayVisible(visible);
544 }
545 #endif
546
547 #if PLATFORM(WIN)
548 void Settings::setShouldUseHighResolutionTimers(bool shouldUseHighResolutionTimers)
549 {
550     gShouldUseHighResolutionTimers = shouldUseHighResolutionTimers;
551 }
552 #endif
553
554 void Settings::setStorageBlockingPolicy(SecurityOrigin::StorageBlockingPolicy enabled)
555 {
556     if (m_storageBlockingPolicy == enabled)
557         return;
558
559     m_storageBlockingPolicy = enabled;
560     if (m_page)
561         m_page->storageBlockingStateChanged();
562 }
563
564 void Settings::setBackgroundShouldExtendBeyondPage(bool shouldExtend)
565 {
566     if (m_backgroundShouldExtendBeyondPage == shouldExtend)
567         return;
568
569     m_backgroundShouldExtendBeyondPage = shouldExtend;
570
571     if (m_page)
572         m_page->mainFrame().view()->updateExtendBackgroundIfNecessary();
573 }
574
575 #if USE(AVFOUNDATION)
576 void Settings::setAVFoundationEnabled(bool enabled)
577 {
578     if (gAVFoundationEnabled == enabled)
579         return;
580
581     gAVFoundationEnabled = enabled;
582     HTMLMediaElement::resetMediaEngines();
583 }
584 #endif
585
586 #if PLATFORM(COCOA)
587 void Settings::setQTKitEnabled(bool enabled)
588 {
589     if (gQTKitEnabled == enabled)
590         return;
591
592     gQTKitEnabled = enabled;
593     HTMLMediaElement::resetMediaEngines();
594 }
595 #endif
596
597 void Settings::setScrollingPerformanceLoggingEnabled(bool enabled)
598 {
599     m_scrollingPerformanceLoggingEnabled = enabled;
600
601     if (m_page && m_page->mainFrame().view())
602         m_page->mainFrame().view()->setScrollingPerformanceLoggingEnabled(enabled);
603 }
604
605 void Settings::setMockScrollbarsEnabled(bool flag)
606 {
607     gMockScrollbarsEnabled = flag;
608     // FIXME: This should update scroll bars in existing pages.
609 }
610
611 bool Settings::mockScrollbarsEnabled()
612 {
613     return gMockScrollbarsEnabled;
614 }
615
616 void Settings::setUsesOverlayScrollbars(bool flag)
617 {
618     gUsesOverlayScrollbars = flag;
619     // FIXME: This should update scroll bars in existing pages.
620 }
621
622 bool Settings::usesOverlayScrollbars()
623 {
624     return gUsesOverlayScrollbars;
625 }
626
627 void Settings::setShouldRespectPriorityInCSSAttributeSetters(bool flag)
628 {
629     gShouldRespectPriorityInCSSAttributeSetters = flag;
630 }
631
632 bool Settings::shouldRespectPriorityInCSSAttributeSetters()
633 {
634     return gShouldRespectPriorityInCSSAttributeSetters;
635 }
636
637 #if ENABLE(HIDDEN_PAGE_DOM_TIMER_THROTTLING)
638 void Settings::setHiddenPageDOMTimerThrottlingEnabled(bool flag)
639 {
640     if (m_hiddenPageDOMTimerThrottlingEnabled == flag)
641         return;
642     m_hiddenPageDOMTimerThrottlingEnabled = flag;
643     if (m_page)
644         m_page->hiddenPageDOMTimerThrottlingStateChanged();
645 }
646 #endif
647
648 void Settings::setHiddenPageCSSAnimationSuspensionEnabled(bool flag)
649 {
650     if (m_hiddenPageCSSAnimationSuspensionEnabled == flag)
651         return;
652     m_hiddenPageCSSAnimationSuspensionEnabled = flag;
653     if (m_page)
654         m_page->hiddenPageCSSAnimationSuspensionStateChanged();
655 }
656
657 void Settings::setFontFallbackPrefersPictographs(bool preferPictographs)
658 {
659     if (m_fontFallbackPrefersPictographs == preferPictographs)
660         return;
661
662     m_fontFallbackPrefersPictographs = preferPictographs;
663     if (m_page)
664         m_page->setNeedsRecalcStyleInAllFrames();
665 }
666
667 void Settings::setLowPowerVideoAudioBufferSizeEnabled(bool flag)
668 {
669     gLowPowerVideoAudioBufferSizeEnabled = flag;
670 }
671
672 #if PLATFORM(IOS)
673 void Settings::setAudioSessionCategoryOverride(unsigned sessionCategory)
674 {
675     AudioSession::sharedSession().setCategoryOverride(static_cast<AudioSession::CategoryType>(sessionCategory));
676 }
677
678 unsigned Settings::audioSessionCategoryOverride()
679 {
680     return AudioSession::sharedSession().categoryOverride();
681 }
682
683 void Settings::setNetworkDataUsageTrackingEnabled(bool trackingEnabled)
684 {
685     gNetworkDataUsageTrackingEnabled = trackingEnabled;
686 }
687
688 bool Settings::networkDataUsageTrackingEnabled()
689 {
690     return gNetworkDataUsageTrackingEnabled;
691 }
692
693 static String& sharedNetworkInterfaceNameGlobal()
694 {
695     static NeverDestroyed<String> networkInterfaceName;
696     return networkInterfaceName;
697 }
698
699 void Settings::setNetworkInterfaceName(const String& networkInterfaceName)
700 {
701     sharedNetworkInterfaceNameGlobal() = networkInterfaceName;
702 }
703
704 const String& Settings::networkInterfaceName()
705 {
706     return sharedNetworkInterfaceNameGlobal();
707 }
708 #endif
709
710 } // namespace WebCore