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