Source/WebKitLegacy/mac/WebView/WebPreferences.mm

   1 /*
   2  * Copyright (C) 2005-2022 Apple Inc. All rights reserved.
   3  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #import "WebPreferencesInternal.h"
  31
  32 #import "NetworkStorageSessionMap.h"
  33 #import "TestingFunctions.h"
  34 #import "WebApplicationCache.h"
  35 #import "WebFeature.h"
  36 #import "WebFrameNetworkingContext.h"
  37 #import "WebKitLogging.h"
  38 #import "WebKitNSStringExtras.h"
  39 #import "WebKitVersionChecks.h"
  40 #import "WebNSDictionaryExtras.h"
  41 #import "WebNSURLExtras.h"
  42 #import "WebPreferenceKeysPrivate.h"
  43 #import "WebPreferencesDefinitions.h"
  44 #import <JavaScriptCore/InitializeThreading.h>
  45 #import <WebCore/ApplicationCacheStorage.h>
  46 #import <WebCore/AudioSession.h>
  47 #import <WebCore/DeprecatedGlobalSettings.h>
  48 #import <WebCore/MediaPlayerEnums.h>
  49 #import <WebCore/NetworkStorageSession.h>
  50 #import <WebCore/RuntimeApplicationChecks.h>
  51 #import <WebCore/Settings.h>
  52 #import <WebCore/WebCoreJITOperations.h>
  53 #import <pal/spi/cf/CFNetworkSPI.h>
  54 #import <pal/text/TextEncodingRegistry.h>
  55 #import <wtf/Compiler.h>
  56 #import <wtf/MainThread.h>
  57 #import <wtf/OptionSet.h>
  58 #import <wtf/RetainPtr.h>
  59 #import <wtf/RunLoop.h>
  60 #import <wtf/cocoa/RuntimeApplicationChecksCocoa.h>
  61
  62 using namespace WebCore;
  63
  64 #if PLATFORM(IOS_FAMILY)
  65 #import <WebCore/GraphicsContext.h>
  66 #import <WebCore/WebCoreThreadMessage.h>
  67 #endif
  68
  69 NSString *WebPreferencesChangedNotification = @"WebPreferencesChangedNotification";
  70 NSString *WebPreferencesRemovedNotification = @"WebPreferencesRemovedNotification";
  71 NSString *WebPreferencesChangedInternalNotification = @"WebPreferencesChangedInternalNotification";
  72 NSString *WebPreferencesCacheModelChangedInternalNotification = @"WebPreferencesCacheModelChangedInternalNotification";
  73
  74 #define KEY(x) (_private->identifier ? [_private->identifier.get() stringByAppendingString:(x)] : (x))
  75
  76 enum { WebPreferencesVersion = 1 };
  77
  78 static RetainPtr<WebPreferences>& standardPreferences()
  79 {
  80     static NeverDestroyed<RetainPtr<WebPreferences>> standardPreferences;
  81     return standardPreferences;
  82 }
  83
  84 static RetainPtr<NSMutableDictionary>& webPreferencesInstances()
  85 {
  86     static NeverDestroyed<RetainPtr<NSMutableDictionary>> webPreferencesInstances;
  87     return webPreferencesInstances;
  88 }
  89
  90 static unsigned webPreferencesInstanceCountWithPrivateBrowsingEnabled;
  91
  92 template<unsigned size> static bool contains(const char* const (&array)[size], const char* item)
  93 {
  94     if (!item)
  95         return false;
  96     for (auto* string : array) {
  97         if (equalIgnoringASCIICase(string, item))
  98             return true;
  99     }
 100     return false;
 101 }
 102
 103 static WebCacheModel cacheModelForMainBundle(NSString *bundleIdentifier)
 104 {
 105     @autoreleasepool {
 106         // Apps that probably need the small setting
 107         static const char* const documentViewerIDs[] = {
 108             "Microsoft/com.microsoft.Messenger",
 109             "com.adiumX.adiumX",
 110             "com.alientechnology.Proteus",
 111             "com.apple.Dashcode",
 112             "com.apple.iChat",
 113             "com.barebones.bbedit",
 114             "com.barebones.textwrangler",
 115             "com.barebones.yojimbo",
 116             "com.equinux.iSale4",
 117             "com.growl.growlframework",
 118             "com.intrarts.PandoraMan",
 119             "com.karelia.Sandvox",
 120             "com.macromates.textmate",
 121             "com.realmacsoftware.rapidweaverpro",
 122             "com.red-sweater.marsedit",
 123             "com.yahoo.messenger3",
 124             "de.codingmonkeys.SubEthaEdit",
 125             "fi.karppinen.Pyro",
 126             "info.colloquy",
 127             "kungfoo.tv.ecto",
 128         };
 129
 130         // Apps that probably need the medium setting
 131         static const char* const documentBrowserIDs[] = {
 132             "com.apple.Dictionary",
 133             "com.apple.Xcode",
 134             "com.apple.helpviewer",
 135             "com.culturedcode.xyle",
 136             "com.macrabbit.CSSEdit",
 137             "com.panic.Coda",
 138             "com.ranchero.NetNewsWire",
 139             "com.thinkmac.NewsLife",
 140             "org.xlife.NewsFire",
 141             "uk.co.opencommunity.vienna2",
 142         };
 143
 144         // Apps that probably need the large setting
 145         static const char* const primaryWebBrowserIDs[] = {
 146             "com.app4mac.KidsBrowser",
 147             "com.app4mac.wKiosk",
 148             "com.freeverse.bumpercar",
 149             "com.omnigroup.OmniWeb5",
 150             "com.sunrisebrowser.Sunrise",
 151             "net.hmdt-web.Shiira",
 152         };
 153
 154         const char* bundleID = [bundleIdentifier UTF8String];
 155         if (contains(documentViewerIDs, bundleID))
 156             return WebCacheModelDocumentViewer;
 157         if (contains(documentBrowserIDs, bundleID))
 158             return WebCacheModelDocumentBrowser;
 159         if (contains(primaryWebBrowserIDs, bundleID))
 160             return WebCacheModelPrimaryWebBrowser;
 161
 162         bool isLinkedAgainstWebKit = WebKitLinkedOnOrAfter(0);
 163         if (!isLinkedAgainstWebKit)
 164             return WebCacheModelDocumentViewer; // Apps that don't link against WebKit probably aren't meant to be browsers.
 165
 166 #if !PLATFORM(IOS_FAMILY)
 167         bool isLegacyApp = !WebKitLinkedOnOrAfter(WEBKIT_FIRST_VERSION_WITH_CACHE_MODEL_API);
 168 #else
 169         bool isLegacyApp = false;
 170 #endif
 171         if (isLegacyApp)
 172             return WebCacheModelDocumentBrowser; // To avoid regressions in apps that depended on old WebKit's large cache.
 173
 174         return WebCacheModelDocumentViewer; // To save memory.
 175     }
 176 }
 177
 178 #if ENABLE(BUILD_FOR_TESTING)
 179 WebCacheModel TestWebPreferencesCacheModelForMainBundle(NSString *bundleIdentifier)
 180 {
 181     return cacheModelForMainBundle(bundleIdentifier);
 182 }
 183 #endif // ENABLE(BUILD_FOR_TESTING)
 184
 185 @interface WebPreferences ()
 186 - (void)_postCacheModelChangedNotification;
 187 @end
 188
 189 @interface WebPreferences (WebInternal)
 190 + (NSString *)_concatenateKeyWithIBCreatorID:(NSString *)key;
 191 + (NSString *)_IBCreatorID;
 192 @end
 193
 194 enum class UpdateAfterBatchType : uint8_t {
 195     API         = 1 << 0,
 196     Internal    = 1 << 1
 197 };
 198
 199 struct WebPreferencesPrivate
 200 {
 201 public:
 202     WebPreferencesPrivate()
 203 #if PLATFORM(IOS_FAMILY)
 204         : readWriteQueue { adoptNS(dispatch_queue_create("com.apple.WebPreferences.ReadWriteQueue", DISPATCH_QUEUE_CONCURRENT)) }
 205 #endif
 206     {
 207     }
 208
 209 #if PLATFORM(IOS_FAMILY)
 210     RetainPtr<dispatch_queue_t> readWriteQueue;
 211 #endif
 212     RetainPtr<NSMutableDictionary> values;
 213     RetainPtr<NSString> identifier;
 214     BOOL inPrivateBrowsing { NO };
 215     BOOL autosaves { NO };
 216     BOOL automaticallyDetectsCacheModel { NO };
 217     unsigned numWebViews { 0 };
 218     unsigned updateBatchCount { 0 };
 219     OptionSet<UpdateAfterBatchType> updateAfterBatchType;
 220 };
 221
 222 #if PLATFORM(IOS_FAMILY)
 223 @interface WebPreferences ()
 224 - (id)initWithIdentifier:(NSString *)anIdentifier sendChangeNotification:(BOOL)sendChangeNotification;
 225 @end
 226 #endif
 227
 228 @implementation WebPreferences
 229
 230 - (instancetype)init
 231 {
 232     // Create fake identifier
 233     static int instanceCount = 1;
 234     NSString *fakeIdentifier;
 235
 236     // At least ensure that identifier hasn't been already used.
 237     fakeIdentifier = [NSString stringWithFormat:@"WebPreferences%d", instanceCount++];
 238     while ([[self class] _getInstanceForIdentifier:fakeIdentifier]){
 239         fakeIdentifier = [NSString stringWithFormat:@"WebPreferences%d", instanceCount++];
 240     }
 241
 242     return [self initWithIdentifier:fakeIdentifier];
 243 }
 244
 245 #if PLATFORM(IOS_FAMILY)
 246 - (id)initWithIdentifier:(NSString *)anIdentifier
 247 {
 248     return [self initWithIdentifier:anIdentifier sendChangeNotification:YES];
 249 }
 250 #endif
 251
 252 #if PLATFORM(IOS_FAMILY)
 253 - (instancetype)initWithIdentifier:(NSString *)anIdentifier sendChangeNotification:(BOOL)sendChangeNotification
 254 #else
 255 - (instancetype)initWithIdentifier:(NSString *)anIdentifier
 256 #endif
 257 {
 258     WebPreferences *instance = [[self class] _getInstanceForIdentifier:anIdentifier];
 259     if (instance) {
 260         [self release];
 261         return [instance retain];
 262     }
 263
 264     self = [super init];
 265     if (!self)
 266         return nil;
 267
 268     _private = new WebPreferencesPrivate;
 269     _private->values = adoptNS([[NSMutableDictionary alloc] init]);
 270     _private->identifier = adoptNS([anIdentifier copy]);
 271     _private->automaticallyDetectsCacheModel = YES;
 272
 273     [[self class] _setInstance:self forIdentifier:_private->identifier.get()];
 274
 275     [self _updatePrivateBrowsingStateTo:[self privateBrowsingEnabled]];
 276
 277 #if PLATFORM(IOS_FAMILY)
 278     if (sendChangeNotification) {
 279         [self _postPreferencesChangedNotification];
 280         [self _postCacheModelChangedNotification];
 281     }
 282 #else
 283     [self _postPreferencesChangedNotification];
 284     [self _postCacheModelChangedNotification];
 285 #endif
 286
 287     return self;
 288 }
 289
 290 - (instancetype)initWithCoder:(NSCoder *)decoder
 291 {
 292     self = [super init];
 293     if (!self)
 294         return nil;
 295
 296     _private = new WebPreferencesPrivate;
 297     _private->automaticallyDetectsCacheModel = YES;
 298
 299     @try {
 300         id identifier = nil;
 301         id values = nil;
 302         if ([decoder allowsKeyedCoding]) {
 303             identifier = [decoder decodeObjectForKey:@"Identifier"];
 304             values = [decoder decodeObjectForKey:@"Values"];
 305         } else {
 306             int version;
 307             [decoder decodeValueOfObjCType:@encode(int) at:&version size:sizeof(int)];
 308             if (version == 1) {
 309                 identifier = [decoder decodeObject];
 310                 values = [decoder decodeObject];
 311             }
 312         }
 313
 314         if ([identifier isKindOfClass:[NSString class]])
 315             _private->identifier = adoptNS([identifier copy]);
 316         if ([values isKindOfClass:[NSDictionary class]])
 317             _private->values = adoptNS([values mutableCopy]); // ensure dictionary is mutable
 318
 319         LOG(Encoding, "Identifier = %@, Values = %@\n", _private->identifier.get(), _private->values.get());
 320     } @catch(id) {
 321         [self release];
 322         return nil;
 323     }
 324
 325     // If we load a nib multiple times, or have instances in multiple
 326     // nibs with the same name, the first guy up wins.
 327     WebPreferences *instance = [[self class] _getInstanceForIdentifier:_private->identifier.get()];
 328     if (instance) {
 329         [self release];
 330         self = [instance retain];
 331     } else {
 332         [[self class] _setInstance:self forIdentifier:_private->identifier.get()];
 333         [self _updatePrivateBrowsingStateTo:[self privateBrowsingEnabled]];
 334     }
 335
 336     return self;
 337 }
 338
 339 - (void)encodeWithCoder:(NSCoder *)encoder
 340 {
 341     if ([encoder allowsKeyedCoding]){
 342         [encoder encodeObject:_private->identifier.get() forKey:@"Identifier"];
 343 #if PLATFORM(IOS_FAMILY)
 344         dispatch_sync(_private->readWriteQueue.get(), ^{
 345 #endif
 346         [encoder encodeObject:_private->values.get() forKey:@"Values"];
 347         LOG (Encoding, "Identifier = %@, Values = %@\n", _private->identifier.get(), _private->values.get());
 348 #if PLATFORM(IOS_FAMILY)
 349         });
 350 #endif
 351     }
 352     else {
 353         int version = WebPreferencesVersion;
 354         [encoder encodeValueOfObjCType:@encode(int) at:&version];
 355         [encoder encodeObject:_private->identifier.get()];
 356 #if PLATFORM(IOS_FAMILY)
 357         dispatch_sync(_private->readWriteQueue.get(), ^{
 358 #endif
 359         [encoder encodeObject:_private->values.get()];
 360 #if PLATFORM(IOS_FAMILY)
 361         });
 362 #endif
 363     }
 364 }
 365
 366 + (WebPreferences *)standardPreferences
 367 {
 368 #if !PLATFORM(IOS_FAMILY)
 369     if (!standardPreferences()) {
 370         standardPreferences() = adoptNS([[WebPreferences alloc] initWithIdentifier:nil]);
 371         [standardPreferences() setAutosaves:YES];
 372     }
 373 #else
 374     static dispatch_once_t pred;
 375     dispatch_once(&pred, ^{
 376         standardPreferences() = adoptNS([[WebPreferences alloc] initWithIdentifier:nil sendChangeNotification:NO]);
 377         [standardPreferences() _postPreferencesChangedNotification];
 378         [standardPreferences() setAutosaves:YES];
 379     });
 380 #endif
 381
 382     return standardPreferences().get();
 383 }
 384
 385 // if we ever have more than one WebPreferences object, this would move to init
 386 + (void)initialize
 387 {
 388 #if PLATFORM(MAC)
 389     JSC::initialize();
 390     WTF::initializeMainThread();
 391     WebCore::populateJITOperations();
 392 #endif
 393
 394     NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys:
 395         INITIALIZE_DEFAULT_PREFERENCES_DICTIONARY_FROM_GENERATED_PREFERENCES
 396
 397         @NO, WebKitUserStyleSheetEnabledPreferenceKey,
 398         @"", WebKitUserStyleSheetLocationPreferenceKey,
 399         @YES, WebKitAllowAnimatedImagesPreferenceKey,
 400         @YES, WebKitAllowAnimatedImageLoopingPreferenceKey,
 401         @"1800", WebKitBackForwardCacheExpirationIntervalKey,
 402         @NO, WebKitPrivateBrowsingEnabledPreferenceKey,
 403         @(cacheModelForMainBundle([[NSBundle mainBundle] bundleIdentifier])), WebKitCacheModelPreferenceKey,
 404         @YES, WebKitZoomsTextOnlyPreferenceKey,
 405         [NSNumber numberWithLongLong:ApplicationCacheStorage::noQuota()], WebKitApplicationCacheTotalQuota,
 406
 407         // FIXME: Are these relevent to WebKitLegacy? If not, we should remove them.
 408         @NO, WebKitResourceLoadStatisticsEnabledPreferenceKey,
 409         @NO, WebKitDebugInAppBrowserPrivacyEnabledPreferenceKey,
 410
 411 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
 412         @"~/Library/WebKit/MediaKeys", WebKitMediaKeysStorageDirectoryKey,
 413 #endif
 414
 415 #if PLATFORM(MAC)
 416         @NO, WebKitRespectStandardStyleKeyEquivalentsPreferenceKey,
 417         @"1", WebKitPDFDisplayModePreferenceKey,
 418         @"0", WebKitPDFScaleFactorPreferenceKey,
 419         @(WebTextDirectionSubmenuAutomaticallyIncluded), WebKitTextDirectionSubmenuInclusionBehaviorPreferenceKey,
 420         [NSNumber numberWithLongLong:ApplicationCacheStorage::noQuota()], WebKitApplicationCacheDefaultOriginQuota,
 421 #endif
 422
 423 #if PLATFORM(IOS_FAMILY)
 424         @NO, WebKitStorageTrackerEnabledPreferenceKey,
 425         @(static_cast<unsigned>(AudioSession::CategoryType::None)), WebKitAudioSessionCategoryOverride,
 426
 427         // Per-Origin Quota on iOS is 25MB. When the quota is reached for a particular origin
 428         // the quota for that origin can be increased. See also webView:exceededApplicationCacheOriginQuotaForSecurityOrigin:totalSpaceNeeded in WebUI/WebUIDelegate.m.
 429         [NSNumber numberWithLongLong:(25 * 1024 * 1024)], WebKitApplicationCacheDefaultOriginQuota,
 430
 431         @NO, WebKitAlwaysRequestGeolocationPermissionPreferenceKey,
 432         @(static_cast<int>(InterpolationQuality::Low)), WebKitInterpolationQualityPreferenceKey,
 433         @NO, WebKitNetworkDataUsageTrackingEnabledPreferenceKey,
 434         @"", WebKitNetworkInterfaceNamePreferenceKey,
 435 #endif
 436         nil];
 437
 438 #if !PLATFORM(IOS_FAMILY)
 439     // This value shouldn't ever change, which is assumed in the initialization of WebKitPDFDisplayModePreferenceKey above
 440     ASSERT(kPDFDisplaySinglePageContinuous == 1);
 441 #endif
 442     [[NSUserDefaults standardUserDefaults] registerDefaults:dict];
 443 }
 444
 445 - (void)dealloc
 446 {
 447     [self _updatePrivateBrowsingStateTo:NO];
 448
 449     delete _private;
 450     [super dealloc];
 451 }
 452
 453 - (NSString *)identifier
 454 {
 455     return _private->identifier.get();
 456 }
 457
 458 - (id)_valueForKey:(NSString *)key
 459 {
 460     NSString *_key = KEY(key);
 461 #if PLATFORM(IOS_FAMILY)
 462     __block id o = nil;
 463     dispatch_sync(_private->readWriteQueue.get(), ^{
 464         o = [_private->values.get() objectForKey:_key];
 465     });
 466 #else
 467     id o = [_private->values.get() objectForKey:_key];
 468 #endif
 469     if (o)
 470         return o;
 471     o = [[NSUserDefaults standardUserDefaults] objectForKey:_key];
 472     if (!o && key != _key)
 473         o = [[NSUserDefaults standardUserDefaults] objectForKey:key];
 474     return o;
 475 }
 476
 477 - (NSString *)_stringValueForKey:(NSString *)key
 478 {
 479     id s = [self _valueForKey:key];
 480     return [s isKindOfClass:[NSString class]] ? (NSString *)s : nil;
 481 }
 482
 483 - (void)_setStringValue:(NSString *)value forKey:(NSString *)key
 484 {
 485     if ([[self _stringValueForKey:key] isEqualToString:value])
 486         return;
 487     NSString *_key = KEY(key);
 488 #if PLATFORM(IOS_FAMILY)
 489     dispatch_barrier_sync(_private->readWriteQueue.get(), ^{
 490 #endif
 491     [_private->values.get() setObject:value forKey:_key];
 492 #if PLATFORM(IOS_FAMILY)
 493     });
 494 #endif
 495     if (_private->autosaves)
 496         [[NSUserDefaults standardUserDefaults] setObject:value forKey:_key];
 497     [self _postPreferencesChangedNotification];
 498 }
 499
 500 - (NSArray<NSString *> *)_stringArrayValueForKey:(NSString *)key
 501 {
 502     id value = [self _valueForKey:key];
 503     if (![value isKindOfClass:[NSArray class]])
 504         return nil;
 505
 506     NSArray *array = (NSArray *)value;
 507     for (id object in array) {
 508         if (![object isKindOfClass:[NSString class]])
 509             return nil;
 510     }
 511
 512     return (NSArray<NSString *> *)array;
 513 }
 514
 515 - (void)_setStringArrayValueForKey:(NSArray<NSString *> *)value forKey:(NSString *)key
 516 {
 517     NSString *_key = KEY(key);
 518 #if PLATFORM(IOS_FAMILY)
 519     dispatch_barrier_sync(_private->readWriteQueue.get(), ^{
 520 #endif
 521         [_private->values.get() setObject:value forKey:_key];
 522 #if PLATFORM(IOS_FAMILY)
 523     });
 524 #endif
 525     if (_private->autosaves)
 526         [[NSUserDefaults standardUserDefaults] setObject:value forKey:_key];
 527     [self _postPreferencesChangedNotification];
 528 }
 529
 530 - (int)_integerValueForKey:(NSString *)key
 531 {
 532     id o = [self _valueForKey:key];
 533     return [o respondsToSelector:@selector(intValue)] ? [o intValue] : 0;
 534 }
 535
 536 - (void)_setIntegerValue:(int)value forKey:(NSString *)key
 537 {
 538     if ([self _integerValueForKey:key] == value)
 539         return;
 540     NSString *_key = KEY(key);
 541 #if PLATFORM(IOS_FAMILY)
 542     dispatch_barrier_sync(_private->readWriteQueue.get(), ^{
 543 #endif
 544     [_private->values.get() setObject:@(value) forKey:_key];
 545 #if PLATFORM(IOS_FAMILY)
 546     });
 547 #endif
 548     if (_private->autosaves)
 549         [[NSUserDefaults standardUserDefaults] setInteger:value forKey:_key];
 550     [self _postPreferencesChangedNotification];
 551 }
 552
 553 - (unsigned int)_unsignedIntValueForKey:(NSString *)key
 554 {
 555     id o = [self _valueForKey:key];
 556     return [o respondsToSelector:@selector(unsignedIntValue)] ? [o unsignedIntValue] : 0;
 557 }
 558
 559 - (void)_setUnsignedIntValue:(unsigned int)value forKey:(NSString *)key
 560 {
 561     if ([self _unsignedIntValueForKey:key] == value)
 562         return;
 563     NSString *_key = KEY(key);
 564 #if PLATFORM(IOS_FAMILY)
 565     dispatch_barrier_sync(_private->readWriteQueue.get(), ^{
 566 #endif
 567     [_private->values.get() setObject:@(value) forKey:_key];
 568 #if PLATFORM(IOS_FAMILY)
 569     });
 570 #endif
 571     if (_private->autosaves)
 572         [[NSUserDefaults standardUserDefaults] setObject:@(value) forKey:_key];
 573     [self _postPreferencesChangedNotification];
 574 }
 575
 576 - (float)_floatValueForKey:(NSString *)key
 577 {
 578     id o = [self _valueForKey:key];
 579     return [o respondsToSelector:@selector(floatValue)] ? [o floatValue] : 0.0f;
 580 }
 581
 582 - (void)_setFloatValue:(float)value forKey:(NSString *)key
 583 {
 584     if ([self _floatValueForKey:key] == value)
 585         return;
 586     NSString *_key = KEY(key);
 587 #if PLATFORM(IOS_FAMILY)
 588     dispatch_barrier_sync(_private->readWriteQueue.get(), ^{
 589 #endif
 590     [_private->values.get() setObject:@(value) forKey:_key];
 591 #if PLATFORM(IOS_FAMILY)
 592     });
 593 #endif
 594     if (_private->autosaves)
 595         [[NSUserDefaults standardUserDefaults] setFloat:value forKey:_key];
 596     [self _postPreferencesChangedNotification];
 597 }
 598
 599 - (BOOL)_boolValueForKey:(NSString *)key
 600 {
 601     return [self _integerValueForKey:key] != 0;
 602 }
 603
 604 - (void)_setBoolValue:(BOOL)value forKey:(NSString *)key
 605 {
 606     if ([self _boolValueForKey:key] == value)
 607         return;
 608     NSString *_key = KEY(key);
 609 #if PLATFORM(IOS_FAMILY)
 610     dispatch_barrier_sync(_private->readWriteQueue.get(), ^{
 611 #endif
 612     [_private->values.get() setObject:@(value) forKey:_key];
 613 #if PLATFORM(IOS_FAMILY)
 614     });
 615 #endif
 616     if (_private->autosaves)
 617         [[NSUserDefaults standardUserDefaults] setBool:value forKey:_key];
 618     [self _postPreferencesChangedNotification];
 619 }
 620
 621 - (long long)_longLongValueForKey:(NSString *)key
 622 {
 623     id o = [self _valueForKey:key];
 624     return [o respondsToSelector:@selector(longLongValue)] ? [o longLongValue] : 0;
 625 }
 626
 627 - (void)_setLongLongValue:(long long)value forKey:(NSString *)key
 628 {
 629     if ([self _longLongValueForKey:key] == value)
 630         return;
 631     NSString *_key = KEY(key);
 632 #if PLATFORM(IOS_FAMILY)
 633     dispatch_barrier_sync(_private->readWriteQueue.get(), ^{
 634 #endif
 635     [_private->values.get() setObject:@(value) forKey:_key];
 636 #if PLATFORM(IOS_FAMILY)
 637     });
 638 #endif
 639     if (_private->autosaves)
 640         [[NSUserDefaults standardUserDefaults] setObject:[NSNumber numberWithLongLong:value] forKey:_key];
 641     [self _postPreferencesChangedNotification];
 642 }
 643
 644 - (unsigned long long)_unsignedLongLongValueForKey:(NSString *)key
 645 {
 646     id o = [self _valueForKey:key];
 647     return [o respondsToSelector:@selector(unsignedLongLongValue)] ? [o unsignedLongLongValue] : 0;
 648 }
 649
 650 - (void)_setUnsignedLongLongValue:(unsigned long long)value forKey:(NSString *)key
 651 {
 652     if ([self _unsignedLongLongValueForKey:key] == value)
 653         return;
 654     NSString *_key = KEY(key);
 655 #if PLATFORM(IOS_FAMILY)
 656     dispatch_barrier_sync(_private->readWriteQueue.get(), ^{
 657 #endif
 658     [_private->values.get() setObject:@(value) forKey:_key];
 659 #if PLATFORM(IOS_FAMILY)
 660     });
 661 #endif
 662     if (_private->autosaves)
 663         [[NSUserDefaults standardUserDefaults] setObject:[NSNumber numberWithUnsignedLongLong:value] forKey:_key];
 664     [self _postPreferencesChangedNotification];
 665 }
 666
 667 - (NSString *)standardFontFamily
 668 {
 669     return [self _stringValueForKey: WebKitStandardFontPreferenceKey];
 670 }
 671
 672 - (void)setStandardFontFamily:(NSString *)family
 673 {
 674     [self _setStringValue: family forKey: WebKitStandardFontPreferenceKey];
 675 }
 676
 677 - (NSString *)fixedFontFamily
 678 {
 679     return [self _stringValueForKey: WebKitFixedFontPreferenceKey];
 680 }
 681
 682 - (void)setFixedFontFamily:(NSString *)family
 683 {
 684     [self _setStringValue: family forKey: WebKitFixedFontPreferenceKey];
 685 }
 686
 687 - (NSString *)serifFontFamily
 688 {
 689     return [self _stringValueForKey: WebKitSerifFontPreferenceKey];
 690 }
 691
 692 - (void)setSerifFontFamily:(NSString *)family
 693 {
 694     [self _setStringValue: family forKey: WebKitSerifFontPreferenceKey];
 695 }
 696
 697 - (NSString *)sansSerifFontFamily
 698 {
 699     return [self _stringValueForKey: WebKitSansSerifFontPreferenceKey];
 700 }
 701
 702 - (void)setSansSerifFontFamily:(NSString *)family
 703 {
 704     [self _setStringValue: family forKey: WebKitSansSerifFontPreferenceKey];
 705 }
 706
 707 - (NSString *)cursiveFontFamily
 708 {
 709     return [self _stringValueForKey: WebKitCursiveFontPreferenceKey];
 710 }
 711
 712 - (void)setCursiveFontFamily:(NSString *)family
 713 {
 714     [self _setStringValue: family forKey: WebKitCursiveFontPreferenceKey];
 715 }
 716
 717 - (NSString *)fantasyFontFamily
 718 {
 719     return [self _stringValueForKey: WebKitFantasyFontPreferenceKey];
 720 }
 721
 722 - (void)setFantasyFontFamily:(NSString *)family
 723 {
 724     [self _setStringValue: family forKey: WebKitFantasyFontPreferenceKey];
 725 }
 726
 727 - (int)defaultFontSize
 728 {
 729     return [self _integerValueForKey: WebKitDefaultFontSizePreferenceKey];
 730 }
 731
 732 - (void)setDefaultFontSize:(int)size
 733 {
 734     [self _setIntegerValue: size forKey: WebKitDefaultFontSizePreferenceKey];
 735 }
 736
 737 - (int)defaultFixedFontSize
 738 {
 739     return [self _integerValueForKey: WebKitDefaultFixedFontSizePreferenceKey];
 740 }
 741
 742 - (void)setDefaultFixedFontSize:(int)size
 743 {
 744     [self _setIntegerValue: size forKey: WebKitDefaultFixedFontSizePreferenceKey];
 745 }
 746
 747 - (int)minimumFontSize
 748 {
 749     return [self _integerValueForKey: WebKitMinimumFontSizePreferenceKey];
 750 }
 751
 752 - (void)setMinimumFontSize:(int)size
 753 {
 754     [self _setIntegerValue: size forKey: WebKitMinimumFontSizePreferenceKey];
 755 }
 756
 757 - (int)minimumLogicalFontSize
 758 {
 759   return [self _integerValueForKey: WebKitMinimumLogicalFontSizePreferenceKey];
 760 }
 761
 762 - (void)setMinimumLogicalFontSize:(int)size
 763 {
 764   [self _setIntegerValue: size forKey: WebKitMinimumLogicalFontSizePreferenceKey];
 765 }
 766
 767 - (NSString *)defaultTextEncodingName
 768 {
 769     return [self _stringValueForKey: WebKitDefaultTextEncodingNamePreferenceKey];
 770 }
 771
 772 - (void)setDefaultTextEncodingName:(NSString *)encoding
 773 {
 774     [self _setStringValue: encoding forKey: WebKitDefaultTextEncodingNamePreferenceKey];
 775 }
 776
 777 #if !PLATFORM(IOS_FAMILY)
 778 - (BOOL)userStyleSheetEnabled
 779 {
 780     return [self _boolValueForKey: WebKitUserStyleSheetEnabledPreferenceKey];
 781 }
 782
 783 - (void)setUserStyleSheetEnabled:(BOOL)flag
 784 {
 785     [self _setBoolValue: flag forKey: WebKitUserStyleSheetEnabledPreferenceKey];
 786 }
 787
 788 - (NSURL *)userStyleSheetLocation
 789 {
 790     NSString *locationString = [self _stringValueForKey: WebKitUserStyleSheetLocationPreferenceKey];
 791
 792     if ([locationString _webkit_looksLikeAbsoluteURL]) {
 793         return [NSURL _web_URLWithDataAsString:locationString];
 794     } else {
 795         locationString = [locationString stringByExpandingTildeInPath];
 796         return [NSURL fileURLWithPath:locationString isDirectory:NO];
 797     }
 798 }
 799
 800 - (void)setUserStyleSheetLocation:(NSURL *)URL
 801 {
 802     NSString *locationString;
 803
 804     if ([URL isFileURL]) {
 805         locationString = [[URL path] _web_stringByAbbreviatingWithTildeInPath];
 806     } else {
 807         locationString = [URL _web_originalDataAsString];
 808     }
 809
 810     if (!locationString)
 811         locationString = @"";
 812
 813     [self _setStringValue:locationString forKey: WebKitUserStyleSheetLocationPreferenceKey];
 814 }
 815 #else
 816
 817 // These methods have had their implementations removed on iOS since it
 818 // is wrong to have such a setting stored in preferences that, when read,
 819 // is applied to all WebViews in a iOS process. Such a design might work
 820 // OK for an application like Safari on Mac OS X, where the only WebViews
 821 // in use display web content in a straightforward manner. However, it is
 822 // wrong for iOS, where WebViews are used for various purposes, like
 823 // text editing, text rendering, and displaying web content.
 824 //
 825 // I have changed the user style sheet mechanism to be a per-WebView
 826 // setting, rather than a per-process preference. This seems to give the
 827 // behavior we want for iOS.
 828
 829 - (BOOL)userStyleSheetEnabled
 830 {
 831     return NO;
 832 }
 833
 834 - (void)setUserStyleSheetEnabled:(BOOL)flag
 835 {
 836     // no-op
 837 }
 838
 839 - (NSURL *)userStyleSheetLocation
 840 {
 841     return nil;
 842 }
 843
 844 - (void)setUserStyleSheetLocation:(NSURL *)URL
 845 {
 846     // no-op
 847 }
 848 #endif // PLATFORM(IOS_FAMILY)
 849
 850 #if !PLATFORM(IOS_FAMILY)
 851 - (BOOL)shouldPrintBackgrounds
 852 {
 853     return [self _boolValueForKey: WebKitShouldPrintBackgroundsPreferenceKey];
 854 }
 855
 856 - (void)setShouldPrintBackgrounds:(BOOL)flag
 857 {
 858     [self _setBoolValue: flag forKey: WebKitShouldPrintBackgroundsPreferenceKey];
 859 }
 860 #endif
 861
 862 - (BOOL)isJavaScriptEnabled
 863 {
 864     return [self _boolValueForKey: WebKitJavaScriptEnabledPreferenceKey];
 865 }
 866
 867 - (void)setJavaScriptEnabled:(BOOL)flag
 868 {
 869     [self _setBoolValue: flag forKey: WebKitJavaScriptEnabledPreferenceKey];
 870 }
 871
 872 - (BOOL)javaScriptCanOpenWindowsAutomatically
 873 {
 874     return [self _boolValueForKey: WebKitJavaScriptCanOpenWindowsAutomaticallyPreferenceKey];
 875 }
 876
 877 - (void)setJavaScriptCanOpenWindowsAutomatically:(BOOL)flag
 878 {
 879     [self _setBoolValue: flag forKey: WebKitJavaScriptCanOpenWindowsAutomaticallyPreferenceKey];
 880 }
 881
 882 - (BOOL)arePlugInsEnabled
 883 {
 884     return [self _boolValueForKey: WebKitPluginsEnabledPreferenceKey];
 885 }
 886
 887 - (void)setPlugInsEnabled:(BOOL)flag
 888 {
 889     [self _setBoolValue: flag forKey: WebKitPluginsEnabledPreferenceKey];
 890 }
 891
 892 - (BOOL)allowsAnimatedImages
 893 {
 894     return [self _boolValueForKey: WebKitAllowAnimatedImagesPreferenceKey];
 895 }
 896
 897 - (void)setAllowsAnimatedImages:(BOOL)flag
 898 {
 899     [self _setBoolValue: flag forKey: WebKitAllowAnimatedImagesPreferenceKey];
 900 }
 901
 902 - (BOOL)allowsAnimatedImageLooping
 903 {
 904     return [self _boolValueForKey: WebKitAllowAnimatedImageLoopingPreferenceKey];
 905 }
 906
 907 - (void)setAllowsAnimatedImageLooping: (BOOL)flag
 908 {
 909     [self _setBoolValue: flag forKey: WebKitAllowAnimatedImageLoopingPreferenceKey];
 910 }
 911
 912 - (void)setLoadsImagesAutomatically: (BOOL)flag
 913 {
 914     [self _setBoolValue: flag forKey: WebKitDisplayImagesKey];
 915 }
 916
 917 - (BOOL)loadsImagesAutomatically
 918 {
 919     return [self _boolValueForKey: WebKitDisplayImagesKey];
 920 }
 921
 922 - (void)setAdditionalSupportedImageTypes:(NSArray<NSString*> *)imageTypes
 923 {
 924     [self _setStringArrayValueForKey:imageTypes forKey:WebKitAdditionalSupportedImageTypesKey];
 925 }
 926
 927 - (NSArray<NSString *> *)additionalSupportedImageTypes
 928 {
 929     return [self _stringArrayValueForKey:WebKitAdditionalSupportedImageTypesKey];
 930 }
 931
 932 - (void)setAutosaves:(BOOL)flag
 933 {
 934     _private->autosaves = flag;
 935 }
 936
 937 - (BOOL)autosaves
 938 {
 939     return _private->autosaves;
 940 }
 941
 942 #if !PLATFORM(IOS_FAMILY)
 943 - (void)setTabsToLinks:(BOOL)flag
 944 {
 945     [self _setBoolValue: flag forKey: WebKitTabToLinksPreferenceKey];
 946 }
 947
 948 - (BOOL)tabsToLinks
 949 {
 950     return [self _boolValueForKey:WebKitTabToLinksPreferenceKey];
 951 }
 952 #endif
 953
 954 - (void)setPrivateBrowsingEnabled:(BOOL)enabled
 955 {
 956     [self _updatePrivateBrowsingStateTo:enabled];
 957     [self _setBoolValue:enabled forKey:WebKitPrivateBrowsingEnabledPreferenceKey];
 958 }
 959
 960 - (BOOL)privateBrowsingEnabled
 961 {
 962     // Changes to private browsing defaults do not have effect on existing WebPreferences, and must be done through -setPrivateBrowsingEnabled.
 963     // This is needed to accurately track private browsing sessions in the process.
 964     return _private->inPrivateBrowsing;
 965 }
 966
 967 - (void)_updatePrivateBrowsingStateTo:(BOOL)enabled
 968 {
 969     if (!_private) {
 970         ASSERT(!enabled);
 971         return;
 972     }
 973
 974     if (enabled == _private->inPrivateBrowsing)
 975         return;
 976     if (enabled > _private->inPrivateBrowsing) {
 977         WebFrameNetworkingContext::ensurePrivateBrowsingSession();
 978         ++webPreferencesInstanceCountWithPrivateBrowsingEnabled;
 979     } else {
 980         ASSERT(webPreferencesInstanceCountWithPrivateBrowsingEnabled);
 981         --webPreferencesInstanceCountWithPrivateBrowsingEnabled;
 982         if (!webPreferencesInstanceCountWithPrivateBrowsingEnabled)
 983             WebFrameNetworkingContext::destroyPrivateBrowsingSession();
 984     }
 985     _private->inPrivateBrowsing = enabled;
 986 }
 987
 988 - (void)setUsesPageCache:(BOOL)usesPageCache
 989 {
 990     [self _setBoolValue:usesPageCache forKey:WebKitUsesPageCachePreferenceKey];
 991 }
 992
 993 - (BOOL)usesPageCache
 994 {
 995     return [self _boolValueForKey:WebKitUsesPageCachePreferenceKey];
 996 }
 997
 998 - (void)_postCacheModelChangedNotification
 999 {
1000 #if !PLATFORM(IOS_FAMILY)
1001     if (!pthread_main_np()) {
1002         [self performSelectorOnMainThread:_cmd withObject:nil waitUntilDone:NO];
1003         return;
1004     }
1005 #endif
1006
1007     [[NSNotificationCenter defaultCenter] postNotificationName:WebPreferencesCacheModelChangedInternalNotification object:self userInfo:nil];
1008 }
1009
1010 - (void)setCacheModel:(WebCacheModel)cacheModel
1011 {
1012     [self _setIntegerValue:cacheModel forKey:WebKitCacheModelPreferenceKey];
1013     [self setAutomaticallyDetectsCacheModel:NO];
1014     [self _postCacheModelChangedNotification];
1015 }
1016
1017 - (WebCacheModel)cacheModel
1018 {
1019     return (WebCacheModel)[self _integerValueForKey:WebKitCacheModelPreferenceKey];
1020 }
1021
1022
1023 - (void)setSuppressesIncrementalRendering:(BOOL)suppressesIncrementalRendering
1024 {
1025     [self _setBoolValue:suppressesIncrementalRendering forKey:WebKitSuppressesIncrementalRenderingKey];
1026 }
1027
1028 - (BOOL)suppressesIncrementalRendering
1029 {
1030     return [self _boolValueForKey:WebKitSuppressesIncrementalRenderingKey];
1031 }
1032
1033 - (BOOL)allowsAirPlayForMediaPlayback
1034 {
1035 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
1036     return [self _boolValueForKey:WebKitAllowsAirPlayForMediaPlaybackPreferenceKey];
1037 #else
1038     return false;
1039 #endif
1040 }
1041
1042 - (void)setAllowsAirPlayForMediaPlayback:(BOOL)flag
1043 {
1044 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
1045     [self _setBoolValue:flag forKey:WebKitAllowsAirPlayForMediaPlaybackPreferenceKey];
1046 #endif
1047 }
1048
1049 @end
1050
1051 @implementation WebPreferences (WebPrivate)
1052
1053 - (BOOL)isDNSPrefetchingEnabled
1054 {
1055     return [self _boolValueForKey:WebKitDNSPrefetchingEnabledPreferenceKey];
1056 }
1057
1058 - (void)setDNSPrefetchingEnabled:(BOOL)flag
1059 {
1060     [self _setBoolValue:flag forKey:WebKitDNSPrefetchingEnabledPreferenceKey];
1061 }
1062
1063 - (BOOL)developerExtrasEnabled
1064 {
1065     NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
1066     if ([defaults boolForKey:@"DisableWebKitDeveloperExtras"])
1067         return NO;
1068 #ifdef NDEBUG
1069     if ([defaults boolForKey:@"WebKitDeveloperExtras"] || [defaults boolForKey:@"IncludeDebugMenu"])
1070         return YES;
1071     return [self _boolValueForKey:WebKitDeveloperExtrasEnabledPreferenceKey];
1072 #else
1073     return YES; // always enable in debug builds
1074 #endif
1075 }
1076
1077 - (WebKitJavaScriptRuntimeFlags)javaScriptRuntimeFlags
1078 {
1079     return static_cast<WebKitJavaScriptRuntimeFlags>([self _unsignedIntValueForKey:WebKitJavaScriptRuntimeFlagsPreferenceKey]);
1080 }
1081
1082 - (void)setJavaScriptRuntimeFlags:(WebKitJavaScriptRuntimeFlags)flags
1083 {
1084     [self _setUnsignedIntValue:flags forKey:WebKitJavaScriptRuntimeFlagsPreferenceKey];
1085 }
1086
1087 - (void)setDeveloperExtrasEnabled:(BOOL)flag
1088 {
1089     [self _setBoolValue:flag forKey:WebKitDeveloperExtrasEnabledPreferenceKey];
1090 }
1091
1092 - (BOOL)authorAndUserStylesEnabled
1093 {
1094     return [self _boolValueForKey:WebKitAuthorAndUserStylesEnabledPreferenceKey];
1095 }
1096
1097 - (void)setAuthorAndUserStylesEnabled:(BOOL)flag
1098 {
1099     [self _setBoolValue:flag forKey:WebKitAuthorAndUserStylesEnabledPreferenceKey];
1100 }
1101
1102 // FIXME: applicationChromeMode is no longer needed by ToT, but is still used in Safari 8.
1103 - (BOOL)applicationChromeModeEnabled
1104 {
1105     return NO;
1106 }
1107
1108 - (void)setApplicationChromeModeEnabled:(BOOL)flag
1109 {
1110 }
1111
1112 - (BOOL)domTimersThrottlingEnabled
1113 {
1114     return [self _boolValueForKey:WebKitDOMTimersThrottlingEnabledPreferenceKey];
1115 }
1116
1117 - (void)setDOMTimersThrottlingEnabled:(BOOL)flag
1118 {
1119     [self _setBoolValue:flag forKey:WebKitDOMTimersThrottlingEnabledPreferenceKey];
1120 }
1121
1122 - (BOOL)webArchiveDebugModeEnabled
1123 {
1124     return [self _boolValueForKey:WebKitWebArchiveDebugModeEnabledPreferenceKey];
1125 }
1126
1127 - (void)setWebArchiveDebugModeEnabled:(BOOL)flag
1128 {
1129     [self _setBoolValue:flag forKey:WebKitWebArchiveDebugModeEnabledPreferenceKey];
1130 }
1131
1132 - (BOOL)localFileContentSniffingEnabled
1133 {
1134     return [self _boolValueForKey:WebKitLocalFileContentSniffingEnabledPreferenceKey];
1135 }
1136
1137 - (void)setLocalFileContentSniffingEnabled:(BOOL)flag
1138 {
1139     [self _setBoolValue:flag forKey:WebKitLocalFileContentSniffingEnabledPreferenceKey];
1140 }
1141
1142 - (BOOL)offlineWebApplicationCacheEnabled
1143 {
1144     return [self _boolValueForKey:WebKitOfflineWebApplicationCacheEnabledPreferenceKey];
1145 }
1146
1147 - (void)setOfflineWebApplicationCacheEnabled:(BOOL)flag
1148 {
1149     [self _setBoolValue:flag forKey:WebKitOfflineWebApplicationCacheEnabledPreferenceKey];
1150 }
1151
1152 - (BOOL)zoomsTextOnly
1153 {
1154     return [self _boolValueForKey:WebKitZoomsTextOnlyPreferenceKey];
1155 }
1156
1157 - (void)setZoomsTextOnly:(BOOL)flag
1158 {
1159     [self _setBoolValue:flag forKey:WebKitZoomsTextOnlyPreferenceKey];
1160 }
1161
1162 - (BOOL)javaScriptCanAccessClipboard
1163 {
1164     return [self _boolValueForKey:WebKitJavaScriptCanAccessClipboardPreferenceKey];
1165 }
1166
1167 - (void)setJavaScriptCanAccessClipboard:(BOOL)flag
1168 {
1169     [self _setBoolValue:flag forKey:WebKitJavaScriptCanAccessClipboardPreferenceKey];
1170 }
1171
1172 #if !PLATFORM(IOS_FAMILY)
1173 - (BOOL)respectStandardStyleKeyEquivalents
1174 {
1175     return [self _boolValueForKey:WebKitRespectStandardStyleKeyEquivalentsPreferenceKey];
1176 }
1177
1178 - (void)setRespectStandardStyleKeyEquivalents:(BOOL)flag
1179 {
1180     [self _setBoolValue:flag forKey:WebKitRespectStandardStyleKeyEquivalentsPreferenceKey];
1181 }
1182
1183 - (BOOL)showsURLsInToolTips
1184 {
1185     return [self _boolValueForKey:WebKitShowsURLsInToolTipsPreferenceKey];
1186 }
1187
1188 - (void)setShowsURLsInToolTips:(BOOL)flag
1189 {
1190     [self _setBoolValue:flag forKey:WebKitShowsURLsInToolTipsPreferenceKey];
1191 }
1192
1193 - (BOOL)showsToolTipOverTruncatedText
1194 {
1195     return [self _boolValueForKey:WebKitShowsToolTipOverTruncatedTextPreferenceKey];
1196 }
1197
1198 - (void)setShowsToolTipOverTruncatedText:(BOOL)flag
1199 {
1200     [self _setBoolValue:flag forKey:WebKitShowsToolTipOverTruncatedTextPreferenceKey];
1201 }
1202
1203 - (BOOL)textAreasAreResizable
1204 {
1205     return [self _boolValueForKey: WebKitTextAreasAreResizablePreferenceKey];
1206 }
1207
1208 - (void)setTextAreasAreResizable:(BOOL)flag
1209 {
1210     [self _setBoolValue: flag forKey: WebKitTextAreasAreResizablePreferenceKey];
1211 }
1212 #endif // !PLATFORM(IOS_FAMILY)
1213
1214 - (BOOL)shrinksStandaloneImagesToFit
1215 {
1216     return [self _boolValueForKey:WebKitShrinksStandaloneImagesToFitPreferenceKey];
1217 }
1218
1219 - (void)setShrinksStandaloneImagesToFit:(BOOL)flag
1220 {
1221     [self _setBoolValue:flag forKey:WebKitShrinksStandaloneImagesToFitPreferenceKey];
1222 }
1223
1224 - (BOOL)automaticallyDetectsCacheModel
1225 {
1226     return _private->automaticallyDetectsCacheModel;
1227 }
1228
1229 - (void)setAutomaticallyDetectsCacheModel:(BOOL)automaticallyDetectsCacheModel
1230 {
1231     _private->automaticallyDetectsCacheModel = automaticallyDetectsCacheModel;
1232 }
1233
1234 - (BOOL)usesEncodingDetector
1235 {
1236     return [self _boolValueForKey: WebKitUsesEncodingDetectorPreferenceKey];
1237 }
1238
1239 - (void)setUsesEncodingDetector:(BOOL)flag
1240 {
1241     [self _setBoolValue: flag forKey: WebKitUsesEncodingDetectorPreferenceKey];
1242 }
1243
1244 - (BOOL)isWebSecurityEnabled
1245 {
1246     return [self _boolValueForKey: WebKitWebSecurityEnabledPreferenceKey];
1247 }
1248
1249 - (void)setWebSecurityEnabled:(BOOL)flag
1250 {
1251     [self _setBoolValue: flag forKey: WebKitWebSecurityEnabledPreferenceKey];
1252 }
1253
1254 - (BOOL)allowUniversalAccessFromFileURLs
1255 {
1256     return [self _boolValueForKey: WebKitAllowUniversalAccessFromFileURLsPreferenceKey];
1257 }
1258
1259 - (void)setAllowUniversalAccessFromFileURLs:(BOOL)flag
1260 {
1261     [self _setBoolValue: flag forKey: WebKitAllowUniversalAccessFromFileURLsPreferenceKey];
1262 }
1263
1264 - (BOOL)allowFileAccessFromFileURLs
1265 {
1266     return [self _boolValueForKey: WebKitAllowFileAccessFromFileURLsPreferenceKey];
1267 }
1268
1269 - (void)setAllowFileAccessFromFileURLs:(BOOL)flag
1270 {
1271     [self _setBoolValue: flag forKey: WebKitAllowFileAccessFromFileURLsPreferenceKey];
1272 }
1273
1274 - (BOOL)allowTopNavigationToDataURLs
1275 {
1276     return [self _boolValueForKey: WebKitAllowTopNavigationToDataURLsPreferenceKey];
1277 }
1278
1279 - (void)setAllowTopNavigationToDataURLs:(BOOL)flag
1280 {
1281     [self _setBoolValue: flag forKey: WebKitAllowTopNavigationToDataURLsPreferenceKey];
1282 }
1283
1284 - (BOOL)allowCrossOriginSubresourcesToAskForCredentials
1285 {
1286     return [self _boolValueForKey:WebKitAllowCrossOriginSubresourcesToAskForCredentialsKey];
1287 }
1288
1289 - (void)setAllowCrossOriginSubresourcesToAskForCredentials:(BOOL)flag
1290 {
1291     [self _setBoolValue:flag forKey:WebKitAllowCrossOriginSubresourcesToAskForCredentialsKey];
1292 }
1293
1294 - (BOOL)needsStorageAccessFromFileURLsQuirk
1295 {
1296     return [self _boolValueForKey: WebKitNeedsStorageAccessFromFileURLsQuirkKey];
1297 }
1298
1299 -(void)setNeedsStorageAccessFromFileURLsQuirk:(BOOL)flag
1300 {
1301     [self _setBoolValue: flag forKey: WebKitNeedsStorageAccessFromFileURLsQuirkKey];
1302 }
1303
1304 - (NSTimeInterval)_backForwardCacheExpirationInterval
1305 {
1306     return (NSTimeInterval)[self _floatValueForKey:WebKitBackForwardCacheExpirationIntervalKey];
1307 }
1308
1309 #if PLATFORM(IOS_FAMILY)
1310 - (BOOL)_standalone
1311 {
1312     return [self _boolValueForKey:WebKitStandalonePreferenceKey];
1313 }
1314
1315 - (void)_setStandalone:(BOOL)flag
1316 {
1317     [self _setBoolValue:flag forKey:WebKitStandalonePreferenceKey];
1318 }
1319
1320 - (void)_setTelephoneNumberParsingEnabled:(BOOL)flag
1321 {
1322     [self _setBoolValue:flag forKey:WebKitTelephoneParsingEnabledPreferenceKey];
1323 }
1324
1325 - (BOOL)_telephoneNumberParsingEnabled
1326 {
1327     return [self _boolValueForKey:WebKitTelephoneParsingEnabledPreferenceKey];
1328 }
1329
1330 - (BOOL)contentChangeObserverEnabled
1331 {
1332     return [self _boolValueForKey:WebKitContentChangeObserverEnabledPreferenceKey];
1333 }
1334
1335 - (void)setContentChangeObserverEnabled:(BOOL)enabled
1336 {
1337     [self _setBoolValue:enabled forKey:WebKitContentChangeObserverEnabledPreferenceKey];
1338 }
1339 #endif
1340
1341 #if ENABLE(TEXT_AUTOSIZING)
1342 - (void)_setMinimumZoomFontSize:(float)size
1343 {
1344     [self _setFloatValue:size forKey:WebKitMinimumZoomFontSizePreferenceKey];
1345 }
1346
1347 - (float)_minimumZoomFontSize
1348 {
1349     return [self _floatValueForKey:WebKitMinimumZoomFontSizePreferenceKey];
1350 }
1351
1352 - (void)_setTextAutosizingEnabled:(BOOL)enabled
1353 {
1354     [self _setBoolValue:enabled forKey:WebKitTextAutosizingEnabledPreferenceKey];
1355 }
1356
1357 - (BOOL)_textAutosizingEnabled
1358 {
1359     return [self _boolValueForKey:WebKitTextAutosizingEnabledPreferenceKey];
1360 }
1361 #endif
1362
1363 #if PLATFORM(IOS_FAMILY)
1364 - (void)_setMaxParseDuration:(float)d
1365 {
1366     [self _setFloatValue:d forKey:WebKitMaxParseDurationPreferenceKey];
1367 }
1368
1369 - (float)_maxParseDuration
1370 {
1371     return [self _floatValueForKey:WebKitMaxParseDurationPreferenceKey];
1372 }
1373
1374 - (void)_setAllowMultiElementImplicitFormSubmission:(BOOL)flag
1375 {
1376     [self _setBoolValue:flag forKey:WebKitAllowMultiElementImplicitFormSubmissionPreferenceKey];
1377 }
1378
1379 - (BOOL)_allowMultiElementImplicitFormSubmission
1380 {
1381     return [self _boolValueForKey:WebKitAllowMultiElementImplicitFormSubmissionPreferenceKey];
1382 }
1383
1384 - (void)_setAlwaysRequestGeolocationPermission:(BOOL)flag
1385 {
1386     [self _setBoolValue:flag forKey:WebKitAlwaysRequestGeolocationPermissionPreferenceKey];
1387 }
1388
1389 - (BOOL)_alwaysRequestGeolocationPermission
1390 {
1391     return [self _boolValueForKey:WebKitAlwaysRequestGeolocationPermissionPreferenceKey];
1392 }
1393
1394 - (void)_setInterpolationQuality:(int)quality
1395 {
1396     [self _setIntegerValue:quality forKey:WebKitInterpolationQualityPreferenceKey];
1397 }
1398
1399 - (int)_interpolationQuality
1400 {
1401     return [self _integerValueForKey:WebKitInterpolationQualityPreferenceKey];
1402 }
1403
1404 - (BOOL)_allowPasswordEcho
1405 {
1406     return [self _boolValueForKey:WebKitPasswordEchoEnabledPreferenceKey];
1407 }
1408
1409 - (float)_passwordEchoDuration
1410 {
1411     return [self _floatValueForKey:WebKitPasswordEchoDurationPreferenceKey];
1412 }
1413
1414 #endif // PLATFORM(IOS_FAMILY)
1415
1416 #if !PLATFORM(IOS_FAMILY)
1417 - (float)PDFScaleFactor
1418 {
1419     return [self _floatValueForKey:WebKitPDFScaleFactorPreferenceKey];
1420 }
1421
1422 - (void)setPDFScaleFactor:(float)factor
1423 {
1424     [self _setFloatValue:factor forKey:WebKitPDFScaleFactorPreferenceKey];
1425 }
1426 #endif
1427
1428 - (int64_t)applicationCacheTotalQuota
1429 {
1430     return [self _longLongValueForKey:WebKitApplicationCacheTotalQuota];
1431 }
1432
1433 - (void)setApplicationCacheTotalQuota:(int64_t)quota
1434 {
1435     [self _setLongLongValue:quota forKey:WebKitApplicationCacheTotalQuota];
1436
1437     // Application Cache Preferences are stored on the global cache storage manager, not in Settings.
1438     [WebApplicationCache setMaximumSize:quota];
1439 }
1440
1441 - (int64_t)applicationCacheDefaultOriginQuota
1442 {
1443     return [self _longLongValueForKey:WebKitApplicationCacheDefaultOriginQuota];
1444 }
1445
1446 - (void)setApplicationCacheDefaultOriginQuota:(int64_t)quota
1447 {
1448     [self _setLongLongValue:quota forKey:WebKitApplicationCacheDefaultOriginQuota];
1449 }
1450
1451 #if !PLATFORM(IOS_FAMILY)
1452 - (PDFDisplayMode)PDFDisplayMode
1453 {
1454     PDFDisplayMode value = static_cast<PDFDisplayMode>([self _integerValueForKey:WebKitPDFDisplayModePreferenceKey]);
1455     if (value != kPDFDisplaySinglePage && value != kPDFDisplaySinglePageContinuous && value != kPDFDisplayTwoUp && value != kPDFDisplayTwoUpContinuous) {
1456         // protect against new modes from future versions of OS X stored in defaults
1457         value = kPDFDisplaySinglePageContinuous;
1458     }
1459     return value;
1460 }
1461
1462 - (void)setPDFDisplayMode:(PDFDisplayMode)mode
1463 {
1464     [self _setIntegerValue:mode forKey:WebKitPDFDisplayModePreferenceKey];
1465 }
1466 #endif
1467
1468 - (WebKitEditableLinkBehavior)editableLinkBehavior
1469 {
1470     WebKitEditableLinkBehavior value = static_cast<WebKitEditableLinkBehavior> ([self _integerValueForKey:WebKitEditableLinkBehaviorPreferenceKey]);
1471     if (value != WebKitEditableLinkDefaultBehavior &&
1472         value != WebKitEditableLinkAlwaysLive &&
1473         value != WebKitEditableLinkNeverLive &&
1474         value != WebKitEditableLinkOnlyLiveWithShiftKey &&
1475         value != WebKitEditableLinkLiveWhenNotFocused) {
1476         // ensure that a valid result is returned
1477         value = WebKitEditableLinkDefaultBehavior;
1478     }
1479
1480     return value;
1481 }
1482
1483 - (void)setEditableLinkBehavior:(WebKitEditableLinkBehavior)behavior
1484 {
1485     [self _setIntegerValue:behavior forKey:WebKitEditableLinkBehaviorPreferenceKey];
1486 }
1487
1488 - (WebTextDirectionSubmenuInclusionBehavior)textDirectionSubmenuInclusionBehavior
1489 {
1490     auto value = static_cast<WebTextDirectionSubmenuInclusionBehavior>([self _integerValueForKey:WebKitTextDirectionSubmenuInclusionBehaviorPreferenceKey]);
1491     if (value != WebTextDirectionSubmenuNeverIncluded &&
1492         value != WebTextDirectionSubmenuAutomaticallyIncluded &&
1493         value != WebTextDirectionSubmenuAlwaysIncluded) {
1494         // Ensure that a valid result is returned.
1495         value = WebTextDirectionSubmenuNeverIncluded;
1496     }
1497     return value;
1498 }
1499
1500 - (void)setTextDirectionSubmenuInclusionBehavior:(WebTextDirectionSubmenuInclusionBehavior)behavior
1501 {
1502     [self _setIntegerValue:behavior forKey:WebKitTextDirectionSubmenuInclusionBehaviorPreferenceKey];
1503 }
1504
1505 - (BOOL)_useSiteSpecificSpoofing
1506 {
1507     return [self _boolValueForKey:WebKitUseSiteSpecificSpoofingPreferenceKey];
1508 }
1509
1510 - (void)_setUseSiteSpecificSpoofing:(BOOL)newValue
1511 {
1512     [self _setBoolValue:newValue forKey:WebKitUseSiteSpecificSpoofingPreferenceKey];
1513 }
1514
1515 - (BOOL)databasesEnabled
1516 {
1517     return [self _boolValueForKey:WebKitDatabasesEnabledPreferenceKey];
1518 }
1519
1520 - (void)setDatabasesEnabled:(BOOL)databasesEnabled
1521 {
1522     [self _setBoolValue:databasesEnabled forKey:WebKitDatabasesEnabledPreferenceKey];
1523 }
1524
1525 #if PLATFORM(IOS_FAMILY)
1526 - (BOOL)storageTrackerEnabled
1527 {
1528     return [self _boolValueForKey:WebKitStorageTrackerEnabledPreferenceKey];
1529 }
1530
1531 - (void)setStorageTrackerEnabled:(BOOL)storageTrackerEnabled
1532 {
1533     [self _setBoolValue:storageTrackerEnabled forKey:WebKitStorageTrackerEnabledPreferenceKey];
1534 }
1535 #endif
1536
1537 - (BOOL)localStorageEnabled
1538 {
1539     return [self _boolValueForKey:WebKitLocalStorageEnabledPreferenceKey];
1540 }
1541
1542 - (void)setLocalStorageEnabled:(BOOL)localStorageEnabled
1543 {
1544     [self _setBoolValue:localStorageEnabled forKey:WebKitLocalStorageEnabledPreferenceKey];
1545 }
1546
1547 + (WebPreferences *)_getInstanceForIdentifier:(NSString *)ident
1548 {
1549     LOG(Encoding, "requesting for %@\n", ident);
1550
1551     if (!ident)
1552         return standardPreferences().get();
1553
1554     WebPreferences *instance = [webPreferencesInstances() objectForKey:[self _concatenateKeyWithIBCreatorID:ident]];
1555
1556     return instance;
1557 }
1558
1559 + (void)_setInstance:(WebPreferences *)instance forIdentifier:(NSString *)ident
1560 {
1561     if (!ident)
1562         return;
1563
1564     auto& instances = webPreferencesInstances();
1565     if (!instances)
1566         instances = adoptNS([[NSMutableDictionary alloc] init]);
1567     [instances setObject:instance forKey:[self _concatenateKeyWithIBCreatorID:ident]];
1568     LOG(Encoding, "recording %p for %@\n", instance, [self _concatenateKeyWithIBCreatorID:ident]);
1569 }
1570
1571 + (void)_checkLastReferenceForIdentifier:(id)identifier
1572 {
1573     // FIXME: This won't work at all under garbage collection because retainCount returns a constant.
1574     // We may need to change WebPreferences API so there's an explicit way to end the lifetime of one.
1575     WebPreferences *instance = [webPreferencesInstances() objectForKey:identifier];
1576     if ([instance retainCount] == 1)
1577         [webPreferencesInstances() removeObjectForKey:identifier];
1578 }
1579
1580 + (void)_removeReferenceForIdentifier:(NSString *)ident
1581 {
1582     if (ident)
1583         [self performSelector:@selector(_checkLastReferenceForIdentifier:) withObject:[self _concatenateKeyWithIBCreatorID:ident] afterDelay:0.1];
1584 }
1585
1586 - (void)_startBatchingUpdates
1587 {
1588     if (!_private->updateBatchCount)
1589         _private->updateAfterBatchType = { };
1590
1591     _private->updateBatchCount++;
1592 }
1593
1594 - (void)_stopBatchingUpdates
1595 {
1596     ASSERT(_private->updateBatchCount > 0);
1597     if (_private->updateBatchCount <= 0)
1598         NSLog(@"ERROR: Unbalanced _startBatchingUpdates/_stopBatchingUpdates.");
1599
1600     _private->updateBatchCount--;
1601     if (!_private->updateBatchCount) {
1602         if (_private->updateAfterBatchType.contains(UpdateAfterBatchType::Internal)) {
1603             if (_private->updateAfterBatchType.contains(UpdateAfterBatchType::API))
1604                 [self _postPreferencesChangedNotification];
1605             else
1606                 [self _postPreferencesChangedAPINotification];
1607         }
1608     }
1609 }
1610
1611 - (void)_batchUpdatePreferencesInBlock:(void (^)(WebPreferences *))block
1612 {
1613     [self _startBatchingUpdates];
1614     block(self);
1615     [self _stopBatchingUpdates];
1616 }
1617
1618 - (void)_resetForTesting
1619 {
1620     _private->values = adoptNS([[NSMutableDictionary alloc] init]);
1621     [self _postPreferencesChangedNotification];
1622 }
1623
1624 - (void)_postPreferencesChangedNotification
1625 {
1626 #if !PLATFORM(IOS_FAMILY)
1627     if (!pthread_main_np()) {
1628         [self performSelectorOnMainThread:_cmd withObject:nil waitUntilDone:NO];
1629         return;
1630     }
1631 #endif
1632
1633     if (_private->updateBatchCount) {
1634         _private->updateAfterBatchType.add({ UpdateAfterBatchType::API, UpdateAfterBatchType::Internal });
1635         return;
1636     }
1637
1638     [[NSNotificationCenter defaultCenter] postNotificationName:WebPreferencesChangedInternalNotification object:self userInfo:nil];
1639     [[NSNotificationCenter defaultCenter] postNotificationName:WebPreferencesChangedNotification object:self userInfo:nil];
1640 }
1641
1642 - (void)_postPreferencesChangedAPINotification
1643 {
1644     if (!pthread_main_np()) {
1645         [self performSelectorOnMainThread:_cmd withObject:nil waitUntilDone:NO];
1646         return;
1647     }
1648
1649     if (_private->updateBatchCount) {
1650         _private->updateAfterBatchType.add({ UpdateAfterBatchType::Internal });
1651         return;
1652     }
1653
1654     [[NSNotificationCenter defaultCenter] postNotificationName:WebPreferencesChangedNotification object:self userInfo:nil];
1655 }
1656
1657 + (CFStringEncoding)_systemCFStringEncoding
1658 {
1659     return PAL::webDefaultCFStringEncoding();
1660 }
1661
1662 + (void)_setInitialDefaultTextEncodingToSystemEncoding
1663 {
1664     [[NSUserDefaults standardUserDefaults] registerDefaults:
1665         @{ WebKitDefaultTextEncodingNamePreferenceKey: PAL::defaultTextEncodingNameForSystemLanguage() }];
1666 }
1667
1668 static RetainPtr<NSString>& classIBCreatorID()
1669 {
1670     static NeverDestroyed<RetainPtr<NSString>> classIBCreatorID;
1671     return classIBCreatorID;
1672 }
1673
1674 + (void)_setIBCreatorID:(NSString *)string
1675 {
1676     classIBCreatorID() = adoptNS([string copy]);
1677 }
1678
1679 - (BOOL)isDOMPasteAllowed
1680 {
1681     return [self _boolValueForKey:WebKitDOMPasteAllowedPreferenceKey];
1682 }
1683
1684 - (void)setDOMPasteAllowed:(BOOL)DOMPasteAllowed
1685 {
1686     [self _setBoolValue:DOMPasteAllowed forKey:WebKitDOMPasteAllowedPreferenceKey];
1687 }
1688
1689 - (NSString *)_localStorageDatabasePath
1690 {
1691     return [[self _stringValueForKey:WebKitLocalStorageDatabasePathPreferenceKey] stringByStandardizingPath];
1692 }
1693
1694 - (void)_setLocalStorageDatabasePath:(NSString *)path
1695 {
1696     [self _setStringValue:[path stringByStandardizingPath] forKey:WebKitLocalStorageDatabasePathPreferenceKey];
1697 }
1698
1699 - (NSString *)_ftpDirectoryTemplatePath
1700 {
1701     return [[self _stringValueForKey:WebKitFTPDirectoryTemplatePath] stringByStandardizingPath];
1702 }
1703
1704 - (void)_setFTPDirectoryTemplatePath:(NSString *)path
1705 {
1706     [self _setStringValue:[path stringByStandardizingPath] forKey:WebKitFTPDirectoryTemplatePath];
1707 }
1708
1709 - (BOOL)_forceFTPDirectoryListings
1710 {
1711     return [self _boolValueForKey:WebKitForceFTPDirectoryListings];
1712 }
1713
1714 - (void)_setForceFTPDirectoryListings:(BOOL)force
1715 {
1716     [self _setBoolValue:force forKey:WebKitForceFTPDirectoryListings];
1717 }
1718
1719 - (BOOL)acceleratedDrawingEnabled
1720 {
1721     return [self _boolValueForKey:WebKitAcceleratedDrawingEnabledPreferenceKey];
1722 }
1723
1724 - (void)setAcceleratedDrawingEnabled:(BOOL)enabled
1725 {
1726     [self _setBoolValue:enabled forKey:WebKitAcceleratedDrawingEnabledPreferenceKey];
1727 }
1728
1729 - (BOOL)displayListDrawingEnabled
1730 {
1731     return [self _boolValueForKey:WebKitDisplayListDrawingEnabledPreferenceKey];
1732 }
1733
1734 - (void)setDisplayListDrawingEnabled:(BOOL)enabled
1735 {
1736     [self _setBoolValue:enabled forKey:WebKitDisplayListDrawingEnabledPreferenceKey];
1737 }
1738
1739 - (BOOL)resourceLoadStatisticsEnabled
1740 {
1741     return [self _boolValueForKey:WebKitResourceLoadStatisticsEnabledPreferenceKey];
1742 }
1743
1744 - (void)setResourceLoadStatisticsEnabled:(BOOL)enabled
1745 {
1746     [self _setBoolValue:enabled forKey:WebKitResourceLoadStatisticsEnabledPreferenceKey];
1747 }
1748
1749 - (BOOL)largeImageAsyncDecodingEnabled
1750 {
1751     return [self _boolValueForKey:WebKitLargeImageAsyncDecodingEnabledPreferenceKey];
1752 }
1753
1754 - (void)setLargeImageAsyncDecodingEnabled:(BOOL)enabled
1755 {
1756     [self _setBoolValue:enabled forKey:WebKitLargeImageAsyncDecodingEnabledPreferenceKey];
1757 }
1758
1759 - (BOOL)animatedImageAsyncDecodingEnabled
1760 {
1761     return [self _boolValueForKey:WebKitAnimatedImageAsyncDecodingEnabledPreferenceKey];
1762 }
1763
1764 - (void)setAnimatedImageAsyncDecodingEnabled:(BOOL)enabled
1765 {
1766     [self _setBoolValue:enabled forKey:WebKitAnimatedImageAsyncDecodingEnabledPreferenceKey];
1767 }
1768
1769 - (BOOL)canvasUsesAcceleratedDrawing
1770 {
1771     return [self _boolValueForKey:WebKitCanvasUsesAcceleratedDrawingPreferenceKey];
1772 }
1773
1774 - (void)setCanvasUsesAcceleratedDrawing:(BOOL)enabled
1775 {
1776     [self _setBoolValue:enabled forKey:WebKitCanvasUsesAcceleratedDrawingPreferenceKey];
1777 }
1778
1779 - (BOOL)acceleratedCompositingEnabled
1780 {
1781     return [self _boolValueForKey:WebKitAcceleratedCompositingEnabledPreferenceKey];
1782 }
1783
1784 - (void)setAcceleratedCompositingEnabled:(BOOL)enabled
1785 {
1786     [self _setBoolValue:enabled forKey:WebKitAcceleratedCompositingEnabledPreferenceKey];
1787 }
1788
1789 - (BOOL)showDebugBorders
1790 {
1791     return [self _boolValueForKey:WebKitShowDebugBordersPreferenceKey];
1792 }
1793
1794 - (void)setShowDebugBorders:(BOOL)enabled
1795 {
1796     [self _setBoolValue:enabled forKey:WebKitShowDebugBordersPreferenceKey];
1797 }
1798
1799 - (BOOL)subpixelAntialiasedLayerTextEnabled
1800 {
1801     return [self _boolValueForKey:WebKitSubpixelAntialiasedLayerTextEnabledPreferenceKey];
1802 }
1803
1804 - (void)setSubpixelAntialiasedLayerTextEnabled:(BOOL)enabled
1805 {
1806     [self _setBoolValue:enabled forKey:WebKitSubpixelAntialiasedLayerTextEnabledPreferenceKey];
1807 }
1808
1809 - (BOOL)legacyLineLayoutVisualCoverageEnabled
1810 {
1811     return [self _boolValueForKey:WebKitLegacyLineLayoutVisualCoverageEnabledPreferenceKey];
1812 }
1813
1814 - (void)setLegacyLineLayoutVisualCoverageEnabled:(BOOL)enabled
1815 {
1816     [self _setBoolValue:enabled forKey:WebKitLegacyLineLayoutVisualCoverageEnabledPreferenceKey];
1817 }
1818
1819 - (BOOL)showRepaintCounter
1820 {
1821     return [self _boolValueForKey:WebKitShowRepaintCounterPreferenceKey];
1822 }
1823
1824 - (void)setShowRepaintCounter:(BOOL)enabled
1825 {
1826     [self _setBoolValue:enabled forKey:WebKitShowRepaintCounterPreferenceKey];
1827 }
1828
1829 - (BOOL)webAudioEnabled
1830 {
1831     return [self _boolValueForKey:WebKitWebAudioEnabledPreferenceKey];
1832 }
1833
1834 - (void)setWebAudioEnabled:(BOOL)enabled
1835 {
1836     [self _setBoolValue:enabled forKey:WebKitWebAudioEnabledPreferenceKey];
1837 }
1838
1839 - (BOOL)webGLEnabled
1840 {
1841     return [self _boolValueForKey:WebKitWebGLEnabledPreferenceKey];
1842 }
1843
1844 - (void)setWebGLEnabled:(BOOL)enabled
1845 {
1846     [self _setBoolValue:enabled forKey:WebKitWebGLEnabledPreferenceKey];
1847 }
1848
1849 - (BOOL)forceLowPowerGPUForWebGL
1850 {
1851     return [self _boolValueForKey:WebKitForceWebGLUsesLowPowerPreferenceKey];
1852 }
1853
1854 - (void)setForceWebGLUsesLowPower:(BOOL)forceLowPower
1855 {
1856     [self _setBoolValue:forceLowPower forKey:WebKitForceWebGLUsesLowPowerPreferenceKey];
1857 }
1858
1859 - (BOOL)isFrameFlatteningEnabled
1860 {
1861     return [self _unsignedIntValueForKey:WebKitFrameFlatteningPreferenceKey] != WebKitFrameFlatteningDisabled;
1862 }
1863
1864 - (void)setFrameFlatteningEnabled:(BOOL)flattening
1865 {
1866     WebKitFrameFlattening value = flattening ? WebKitFrameFlatteningFullyEnabled : WebKitFrameFlatteningDisabled;
1867     [self _setUnsignedIntValue:value forKey:WebKitFrameFlatteningPreferenceKey];
1868 }
1869
1870 - (WebKitFrameFlattening)frameFlattening
1871 {
1872     return static_cast<WebKitFrameFlattening>([self _unsignedIntValueForKey:WebKitFrameFlatteningPreferenceKey]);
1873 }
1874
1875 - (void)setFrameFlattening:(WebKitFrameFlattening)flattening
1876 {
1877     [self _setUnsignedIntValue:flattening forKey:WebKitFrameFlatteningPreferenceKey];
1878 }
1879
1880 - (BOOL)asyncFrameScrollingEnabled
1881 {
1882     return [self _boolValueForKey:WebKitAsyncFrameScrollingEnabledPreferenceKey];
1883 }
1884
1885 - (void)setAsyncFrameScrollingEnabled:(BOOL)enabled
1886 {
1887     [self _setBoolValue:enabled forKey:WebKitAsyncFrameScrollingEnabledPreferenceKey];
1888 }
1889
1890 - (BOOL)isSpatialNavigationEnabled
1891 {
1892     return [self _boolValueForKey:WebKitSpatialNavigationEnabledPreferenceKey];
1893 }
1894
1895 - (void)setSpatialNavigationEnabled:(BOOL)flag
1896 {
1897     [self _setBoolValue:flag forKey:WebKitSpatialNavigationEnabledPreferenceKey];
1898 }
1899
1900 - (BOOL)paginateDuringLayoutEnabled
1901 {
1902     return [self _boolValueForKey:WebKitPaginateDuringLayoutEnabledPreferenceKey];
1903 }
1904
1905 - (void)setPaginateDuringLayoutEnabled:(BOOL)flag
1906 {
1907     [self _setBoolValue:flag forKey:WebKitPaginateDuringLayoutEnabledPreferenceKey];
1908 }
1909
1910 - (BOOL)hyperlinkAuditingEnabled
1911 {
1912     return [self _boolValueForKey:WebKitHyperlinkAuditingEnabledPreferenceKey];
1913 }
1914
1915 - (void)setHyperlinkAuditingEnabled:(BOOL)flag
1916 {
1917     [self _setBoolValue:flag forKey:WebKitHyperlinkAuditingEnabledPreferenceKey];
1918 }
1919
1920 - (BOOL)usePreHTML5ParserQuirks
1921 {
1922     return [self _boolValueForKey:WebKitUsePreHTML5ParserQuirksKey];
1923 }
1924
1925 - (void)setUsePreHTML5ParserQuirks:(BOOL)flag
1926 {
1927     [self _setBoolValue:flag forKey:WebKitUsePreHTML5ParserQuirksKey];
1928 }
1929
1930 - (void)didRemoveFromWebView
1931 {
1932     ASSERT(_private->numWebViews);
1933     if (--_private->numWebViews == 0)
1934         [[NSNotificationCenter defaultCenter]
1935             postNotificationName:WebPreferencesRemovedNotification
1936                           object:self
1937                         userInfo:nil];
1938 }
1939
1940 - (void)willAddToWebView
1941 {
1942     ++_private->numWebViews;
1943 }
1944
1945 - (void)setFullScreenEnabled:(BOOL)flag
1946 {
1947     [self _setBoolValue:flag forKey:WebKitFullScreenEnabledPreferenceKey];
1948 }
1949
1950 - (BOOL)fullScreenEnabled
1951 {
1952     return [self _boolValueForKey:WebKitFullScreenEnabledPreferenceKey];
1953 }
1954
1955 - (void)setAsynchronousSpellCheckingEnabled:(BOOL)flag
1956 {
1957     [self _setBoolValue:flag forKey:WebKitAsynchronousSpellCheckingEnabledPreferenceKey];
1958 }
1959
1960 - (BOOL)asynchronousSpellCheckingEnabled
1961 {
1962     return [self _boolValueForKey:WebKitAsynchronousSpellCheckingEnabledPreferenceKey];
1963 }
1964
1965 + (void)setWebKitLinkTimeVersion:(int)version
1966 {
1967     setWebKitLinkTimeVersion(version);
1968 }
1969
1970 - (void)setLoadsSiteIconsIgnoringImageLoadingPreference: (BOOL)flag
1971 {
1972     [self _setBoolValue: flag forKey: WebKitLoadSiteIconsKey];
1973 }
1974
1975 - (BOOL)loadsSiteIconsIgnoringImageLoadingPreference
1976 {
1977     return [self _boolValueForKey: WebKitLoadSiteIconsKey];
1978 }
1979
1980 - (void)setAVFoundationEnabled:(BOOL)flag
1981 {
1982     [self _setBoolValue:flag forKey:WebKitAVFoundationEnabledKey];
1983 }
1984
1985 - (BOOL)isAVFoundationEnabled
1986 {
1987     return [self _boolValueForKey:WebKitAVFoundationEnabledKey];
1988 }
1989
1990 - (void)setAVFoundationNSURLSessionEnabled:(BOOL)flag
1991 {
1992 }
1993
1994 - (BOOL)isAVFoundationNSURLSessionEnabled
1995 {
1996     return YES;
1997 }
1998
1999 - (BOOL)isInheritURIQueryComponentEnabled
2000 {
2001     return [self _boolValueForKey: WebKitEnableInheritURIQueryComponentPreferenceKey];
2002 }
2003
2004 - (void)setEnableInheritURIQueryComponent:(BOOL)flag
2005 {
2006     [self _setBoolValue:flag forKey: WebKitEnableInheritURIQueryComponentPreferenceKey];
2007 }
2008
2009 #if PLATFORM(IOS_FAMILY)
2010 - (BOOL)mediaPlaybackAllowsAirPlay
2011 {
2012     return [self _boolValueForKey:WebKitAllowsAirPlayForMediaPlaybackPreferenceKey];
2013 }
2014
2015 - (void)setMediaPlaybackAllowsAirPlay:(BOOL)flag
2016 {
2017     [self _setBoolValue:flag forKey:WebKitAllowsAirPlayForMediaPlaybackPreferenceKey];
2018 }
2019
2020 - (unsigned)audioSessionCategoryOverride
2021 {
2022     return [self _unsignedIntValueForKey:WebKitAudioSessionCategoryOverride];
2023 }
2024
2025 - (void)setAudioSessionCategoryOverride:(unsigned)override
2026 {
2027     if (override > static_cast<unsigned>(AudioSession::CategoryType::AudioProcessing)) {
2028         // Clients are passing us OSTypes values from AudioToolbox/AudioSession.h,
2029         // which need to be translated into AudioSession::CategoryType:
2030         switch (override) {
2031         case WebKitAudioSessionCategoryAmbientSound:
2032             override = static_cast<unsigned>(AudioSession::CategoryType::AmbientSound);
2033             break;
2034         case WebKitAudioSessionCategorySoloAmbientSound:
2035             override = static_cast<unsigned>(AudioSession::CategoryType::SoloAmbientSound);
2036             break;
2037         case WebKitAudioSessionCategoryMediaPlayback:
2038             override = static_cast<unsigned>(AudioSession::CategoryType::MediaPlayback);
2039             break;
2040         case WebKitAudioSessionCategoryRecordAudio:
2041             override = static_cast<unsigned>(AudioSession::CategoryType::RecordAudio);
2042             break;
2043         case WebKitAudioSessionCategoryPlayAndRecord:
2044             override = static_cast<unsigned>(AudioSession::CategoryType::PlayAndRecord);
2045             break;
2046         case WebKitAudioSessionCategoryAudioProcessing:
2047             override = static_cast<unsigned>(AudioSession::CategoryType::AudioProcessing);
2048             break;
2049         default:
2050             override = static_cast<unsigned>(AudioSession::CategoryType::None);
2051             break;
2052         }
2053     }
2054
2055     [self _setUnsignedIntValue:override forKey:WebKitAudioSessionCategoryOverride];
2056 }
2057
2058 - (BOOL)networkDataUsageTrackingEnabled
2059 {
2060     return [self _boolValueForKey:WebKitNetworkDataUsageTrackingEnabledPreferenceKey];
2061 }
2062
2063 - (void)setNetworkDataUsageTrackingEnabled:(BOOL)trackingEnabled
2064 {
2065     [self _setBoolValue:trackingEnabled forKey:WebKitNetworkDataUsageTrackingEnabledPreferenceKey];
2066 }
2067
2068 - (NSString *)networkInterfaceName
2069 {
2070     return [self _stringValueForKey:WebKitNetworkInterfaceNamePreferenceKey];
2071 }
2072
2073 - (void)setNetworkInterfaceName:(NSString *)name
2074 {
2075     [self _setStringValue:name forKey:WebKitNetworkInterfaceNamePreferenceKey];
2076 }
2077 #endif // PLATFORM(IOS_FAMILY)
2078
2079 // Deprecated. Use -videoPlaybackRequiresUserGesture and -audioPlaybackRequiresUserGesture instead.
2080 - (BOOL)mediaPlaybackRequiresUserGesture
2081 {
2082     return [self _boolValueForKey:WebKitRequiresUserGestureForMediaPlaybackPreferenceKey];
2083 }
2084
2085 // Deprecated. Use -setVideoPlaybackRequiresUserGesture and -setAudioPlaybackRequiresUserGesture instead.
2086 - (void)setMediaPlaybackRequiresUserGesture:(BOOL)flag
2087 {
2088     [self _setBoolValue:flag forKey:WebKitRequiresUserGestureForMediaPlaybackPreferenceKey];
2089 }
2090
2091 - (BOOL)videoPlaybackRequiresUserGesture
2092 {
2093     return [self _boolValueForKey:WebKitRequiresUserGestureForVideoPlaybackPreferenceKey];
2094 }
2095
2096 - (void)setVideoPlaybackRequiresUserGesture:(BOOL)flag
2097 {
2098     [self _setBoolValue:flag forKey:WebKitRequiresUserGestureForVideoPlaybackPreferenceKey];
2099 }
2100
2101 - (BOOL)audioPlaybackRequiresUserGesture
2102 {
2103     return [self _boolValueForKey:WebKitRequiresUserGestureForAudioPlaybackPreferenceKey];
2104 }
2105
2106 - (void)setAudioPlaybackRequiresUserGesture:(BOOL)flag
2107 {
2108     [self _setBoolValue:flag forKey:WebKitRequiresUserGestureForAudioPlaybackPreferenceKey];
2109 }
2110
2111 - (BOOL)overrideUserGestureRequirementForMainContent
2112 {
2113     return [self _boolValueForKey:WebKitMainContentUserGestureOverrideEnabledPreferenceKey];
2114 }
2115
2116 - (void)setOverrideUserGestureRequirementForMainContent:(BOOL)flag
2117 {
2118     [self _setBoolValue:flag forKey:WebKitMainContentUserGestureOverrideEnabledPreferenceKey];
2119 }
2120
2121 - (BOOL)mediaPlaybackAllowsInline
2122 {
2123     return [self _boolValueForKey:WebKitAllowsInlineMediaPlaybackPreferenceKey];
2124 }
2125
2126 - (void)setMediaPlaybackAllowsInline:(BOOL)flag
2127 {
2128     [self _setBoolValue:flag forKey:WebKitAllowsInlineMediaPlaybackPreferenceKey];
2129 }
2130
2131 - (BOOL)inlineMediaPlaybackRequiresPlaysInlineAttribute
2132 {
2133     return [self _boolValueForKey:WebKitInlineMediaPlaybackRequiresPlaysInlineAttributeKey];
2134 }
2135
2136 - (void)setInlineMediaPlaybackRequiresPlaysInlineAttribute:(BOOL)flag
2137 {
2138     [self _setBoolValue:flag forKey:WebKitInlineMediaPlaybackRequiresPlaysInlineAttributeKey];
2139 }
2140
2141 - (BOOL)invisibleAutoplayNotPermitted
2142 {
2143     return [self _boolValueForKey:WebKitInvisibleAutoplayNotPermittedKey];
2144 }
2145
2146 - (void)setInvisibleAutoplayNotPermitted:(BOOL)flag
2147 {
2148     [self _setBoolValue:flag forKey:WebKitInvisibleAutoplayNotPermittedKey];
2149 }
2150
2151 - (BOOL)mediaControlsScaleWithPageZoom
2152 {
2153     return [self _boolValueForKey:WebKitMediaControlsScaleWithPageZoomPreferenceKey];
2154 }
2155
2156 - (void)setMediaControlsScaleWithPageZoom:(BOOL)flag
2157 {
2158     [self _setBoolValue:flag forKey:WebKitMediaControlsScaleWithPageZoomPreferenceKey];
2159 }
2160
2161 - (BOOL)allowsAlternateFullscreen
2162 {
2163     return [self allowsPictureInPictureMediaPlayback];
2164 }
2165
2166 - (void)setAllowsAlternateFullscreen:(BOOL)flag
2167 {
2168     [self setAllowsPictureInPictureMediaPlayback:flag];
2169 }
2170
2171 - (BOOL)allowsPictureInPictureMediaPlayback
2172 {
2173     return [self _boolValueForKey:WebKitAllowsPictureInPictureMediaPlaybackPreferenceKey];
2174 }
2175
2176 - (void)setAllowsPictureInPictureMediaPlayback:(BOOL)flag
2177 {
2178     [self _setBoolValue:flag forKey:WebKitAllowsPictureInPictureMediaPlaybackPreferenceKey];
2179 }
2180
2181 - (BOOL)mockScrollbarsEnabled
2182 {
2183     return [self _boolValueForKey:WebKitMockScrollbarsEnabledPreferenceKey];
2184 }
2185
2186 - (void)setMockScrollbarsEnabled:(BOOL)flag
2187 {
2188     [self _setBoolValue:flag forKey:WebKitMockScrollbarsEnabledPreferenceKey];
2189 }
2190
2191 - (NSString *)pictographFontFamily
2192 {
2193     return [self _stringValueForKey: WebKitPictographFontPreferenceKey];
2194 }
2195
2196 - (void)setPictographFontFamily:(NSString *)family
2197 {
2198     [self _setStringValue: family forKey: WebKitPictographFontPreferenceKey];
2199 }
2200
2201 - (BOOL)pageCacheSupportsPlugins
2202 {
2203     return [self _boolValueForKey:WebKitPageCacheSupportsPluginsPreferenceKey];
2204 }
2205
2206 - (void)setPageCacheSupportsPlugins:(BOOL)flag
2207 {
2208     [self _setBoolValue:flag forKey:WebKitPageCacheSupportsPluginsPreferenceKey];
2209
2210 }
2211
2212 #if PLATFORM(IOS_FAMILY)
2213 - (void)_invalidateCachedPreferences
2214 {
2215     dispatch_barrier_sync(_private->readWriteQueue.get(), ^{
2216         if (_private->values)
2217             _private->values = adoptNS([[NSMutableDictionary alloc] init]);
2218     });
2219
2220     [self _updatePrivateBrowsingStateTo:[self privateBrowsingEnabled]];
2221
2222     // Tell any live WebViews to refresh their preferences
2223     [self _postPreferencesChangedNotification];
2224 }
2225
2226 - (void)_synchronizeWebStoragePolicyWithCookiePolicy
2227 {
2228     // FIXME: This should be done in clients, WebKit shouldn't be making such policy decisions.
2229
2230     NSHTTPCookieAcceptPolicy cookieAcceptPolicy = [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookieAcceptPolicy];
2231     WebStorageBlockingPolicy storageBlockingPolicy;
2232     switch (static_cast<unsigned>(cookieAcceptPolicy)) {
2233     case NSHTTPCookieAcceptPolicyAlways:
2234         storageBlockingPolicy = WebAllowAllStorage;
2235         break;
2236     case NSHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain:
2237     case NSHTTPCookieAcceptPolicyExclusivelyFromMainDocumentDomain:
2238         storageBlockingPolicy = WebBlockThirdPartyStorage;
2239         break;
2240     case NSHTTPCookieAcceptPolicyNever:
2241         storageBlockingPolicy = WebBlockAllStorage;
2242         break;
2243     default:
2244         ASSERT_NOT_REACHED();
2245         storageBlockingPolicy = WebBlockAllStorage;
2246         break;
2247     }
2248
2249     [self setStorageBlockingPolicy:storageBlockingPolicy];
2250 }
2251 #endif
2252
2253 - (void)setBackspaceKeyNavigationEnabled:(BOOL)flag
2254 {
2255     [self _setBoolValue:flag forKey:WebKitBackspaceKeyNavigationEnabledKey];
2256 }
2257
2258 - (BOOL)backspaceKeyNavigationEnabled
2259 {
2260     return [self _boolValueForKey:WebKitBackspaceKeyNavigationEnabledKey];
2261 }
2262
2263 - (void)setWantsBalancedSetDefersLoadingBehavior:(BOOL)flag
2264 {
2265     [self _setBoolValue:flag forKey:WebKitWantsBalancedSetDefersLoadingBehaviorKey];
2266 }
2267
2268 - (BOOL)wantsBalancedSetDefersLoadingBehavior
2269 {
2270     return [self _boolValueForKey:WebKitWantsBalancedSetDefersLoadingBehaviorKey];
2271 }
2272
2273 - (void)setShouldDisplaySubtitles:(BOOL)flag
2274 {
2275     [self _setBoolValue:flag forKey:WebKitShouldDisplaySubtitlesPreferenceKey];
2276 }
2277
2278 - (BOOL)shouldDisplaySubtitles
2279 {
2280     return [self _boolValueForKey:WebKitShouldDisplaySubtitlesPreferenceKey];
2281 }
2282
2283 - (void)setShouldDisplayCaptions:(BOOL)flag
2284 {
2285     [self _setBoolValue:flag forKey:WebKitShouldDisplayCaptionsPreferenceKey];
2286 }
2287
2288 - (BOOL)shouldDisplayCaptions
2289 {
2290     return [self _boolValueForKey:WebKitShouldDisplayCaptionsPreferenceKey];
2291 }
2292
2293 - (void)setShouldDisplayTextDescriptions:(BOOL)flag
2294 {
2295     [self _setBoolValue:flag forKey:WebKitShouldDisplayTextDescriptionsPreferenceKey];
2296 }
2297
2298 - (BOOL)shouldDisplayTextDescriptions
2299 {
2300     return [self _boolValueForKey:WebKitShouldDisplayTextDescriptionsPreferenceKey];
2301 }
2302
2303 - (void)setNotificationsEnabled:(BOOL)flag
2304 {
2305     [self _setBoolValue:flag forKey:WebKitNotificationsEnabledKey];
2306 }
2307
2308 - (BOOL)notificationsEnabled
2309 {
2310     return [self _boolValueForKey:WebKitNotificationsEnabledKey];
2311 }
2312
2313 - (void)setShouldRespectImageOrientation:(BOOL)flag
2314 {
2315     [self _setBoolValue:flag forKey:WebKitShouldRespectImageOrientationKey];
2316 }
2317
2318 - (BOOL)shouldRespectImageOrientation
2319 {
2320     return [self _boolValueForKey:WebKitShouldRespectImageOrientationKey];
2321 }
2322
2323 - (void)setIncrementalRenderingSuppressionTimeoutInSeconds:(NSTimeInterval)timeout
2324 {
2325     [self _setFloatValue:timeout forKey:WebKitIncrementalRenderingSuppressionTimeoutInSecondsKey];
2326 }
2327
2328 - (NSTimeInterval)incrementalRenderingSuppressionTimeoutInSeconds
2329 {
2330     return [self _floatValueForKey:WebKitIncrementalRenderingSuppressionTimeoutInSecondsKey];
2331 }
2332
2333 - (BOOL)diagnosticLoggingEnabled
2334 {
2335     return [self _boolValueForKey:WebKitDiagnosticLoggingEnabledKey];
2336 }
2337
2338 - (void)setDiagnosticLoggingEnabled:(BOOL)enabled
2339 {
2340     [self _setBoolValue:enabled forKey:WebKitDiagnosticLoggingEnabledKey];
2341 }
2342
2343 - (void)setStorageBlockingPolicy:(WebStorageBlockingPolicy)storageBlockingPolicy
2344 {
2345 #if PLATFORM(IOS_FAMILY)
2346     // We don't want to write the setting out, so we just reset the default instead of storing the new setting.
2347     // FIXME: This code removes any defaults previously registered by client process, which is not appropriate for this method to do.
2348     [[NSUserDefaults standardUserDefaults] registerDefaults:@{ WebKitStorageBlockingPolicyKey: @(storageBlockingPolicy) }];
2349 #else
2350     [self _setIntegerValue:storageBlockingPolicy forKey:WebKitStorageBlockingPolicyKey];
2351 #endif
2352 }
2353
2354 - (WebStorageBlockingPolicy)storageBlockingPolicy
2355 {
2356     return static_cast<WebStorageBlockingPolicy>([self _integerValueForKey:WebKitStorageBlockingPolicyKey]);
2357 }
2358
2359 - (BOOL)plugInSnapshottingEnabled
2360 {
2361     return NO;
2362 }
2363
2364 - (void)setPlugInSnapshottingEnabled:(BOOL)enabled
2365 {
2366 }
2367
2368 - (BOOL)hiddenPageDOMTimerThrottlingEnabled
2369 {
2370     return [self _boolValueForKey:WebKitHiddenPageDOMTimerThrottlingEnabledPreferenceKey];
2371 }
2372
2373 - (void)setHiddenPageDOMTimerThrottlingEnabled:(BOOL)enabled
2374 {
2375     [self _setBoolValue:enabled forKey:WebKitHiddenPageDOMTimerThrottlingEnabledPreferenceKey];
2376 }
2377
2378 - (BOOL)hiddenPageCSSAnimationSuspensionEnabled
2379 {
2380     return [self _boolValueForKey:WebKitHiddenPageCSSAnimationSuspensionEnabledPreferenceKey];
2381 }
2382
2383 - (void)setHiddenPageCSSAnimationSuspensionEnabled:(BOOL)enabled
2384 {
2385     [self _setBoolValue:enabled forKey:WebKitHiddenPageCSSAnimationSuspensionEnabledPreferenceKey];
2386 }
2387
2388 - (BOOL)lowPowerVideoAudioBufferSizeEnabled
2389 {
2390     return [self _boolValueForKey:WebKitLowPowerVideoAudioBufferSizeEnabledPreferenceKey];
2391 }
2392
2393 - (void)setLowPowerVideoAudioBufferSizeEnabled:(BOOL)enabled
2394 {
2395     [self _setBoolValue:enabled forKey:WebKitLowPowerVideoAudioBufferSizeEnabledPreferenceKey];
2396 }
2397
2398 - (BOOL)useLegacyTextAlignPositionedElementBehavior
2399 {
2400     return [self _boolValueForKey:WebKitUseLegacyTextAlignPositionedElementBehaviorPreferenceKey];
2401 }
2402
2403 - (void)setUseLegacyTextAlignPositionedElementBehavior:(BOOL)enabled
2404 {
2405     [self _setBoolValue:enabled forKey:WebKitUseLegacyTextAlignPositionedElementBehaviorPreferenceKey];
2406 }
2407
2408 - (BOOL)mediaSourceEnabled
2409 {
2410     return [self _boolValueForKey:WebKitMediaSourceEnabledPreferenceKey];
2411 }
2412
2413 - (void)setMediaSourceEnabled:(BOOL)enabled
2414 {
2415     [self _setBoolValue:enabled forKey:WebKitMediaSourceEnabledPreferenceKey];
2416 }
2417
2418 - (BOOL)sourceBufferChangeTypeEnabled
2419 {
2420     return [self _boolValueForKey:WebKitSourceBufferChangeTypeEnabledPreferenceKey];
2421 }
2422
2423 - (void)setSourceBufferChangeTypeEnabled:(BOOL)enabled
2424 {
2425     [self _setBoolValue:enabled forKey:WebKitSourceBufferChangeTypeEnabledPreferenceKey];
2426 }
2427
2428 - (BOOL)imageControlsEnabled
2429 {
2430     // Image controls are no longer supported.
2431     return NO;
2432 }
2433
2434 - (void)setImageControlsEnabled:(BOOL)enabled
2435 {
2436     // Image controls are no longer supported.
2437     UNUSED_PARAM(enabled);
2438 }
2439
2440 - (BOOL)serviceControlsEnabled
2441 {
2442     return [self _boolValueForKey:WebKitServiceControlsEnabledPreferenceKey];
2443 }
2444
2445 - (void)setServiceControlsEnabled:(BOOL)enabled
2446 {
2447     [self _setBoolValue:enabled forKey:WebKitServiceControlsEnabledPreferenceKey];
2448 }
2449
2450 - (BOOL)gamepadsEnabled
2451 {
2452     return [self _boolValueForKey:WebKitGamepadsEnabledPreferenceKey];
2453 }
2454
2455 - (void)setGamepadsEnabled:(BOOL)flag
2456 {
2457     [self _setBoolValue:flag forKey:WebKitGamepadsEnabledPreferenceKey];
2458 }
2459
2460 - (BOOL)shouldConvertPositionStyleOnCopy
2461 {
2462     return [self _boolValueForKey:WebKitShouldConvertPositionStyleOnCopyPreferenceKey];
2463 }
2464
2465 - (void)setShouldConvertPositionStyleOnCopy:(BOOL)enabled
2466 {
2467     [self _setBoolValue:enabled forKey:WebKitShouldConvertPositionStyleOnCopyPreferenceKey];
2468 }
2469
2470 - (NSString *)mediaKeysStorageDirectory
2471 {
2472     return [[self _stringValueForKey:WebKitMediaKeysStorageDirectoryKey] stringByStandardizingPath];
2473 }
2474
2475 - (void)setMediaKeysStorageDirectory:(NSString *)directory
2476 {
2477     [self _setStringValue:directory forKey:WebKitMediaKeysStorageDirectoryKey];
2478 }
2479
2480 - (BOOL)mediaDevicesEnabled
2481 {
2482     return [self _boolValueForKey:WebKitMediaDevicesEnabledPreferenceKey];
2483 }
2484
2485 - (void)setMediaDevicesEnabled:(BOOL)flag
2486 {
2487     [self _setBoolValue:flag forKey:WebKitMediaDevicesEnabledPreferenceKey];
2488 }
2489
2490 - (BOOL)mediaStreamEnabled
2491 {
2492     return [self _boolValueForKey:WebKitMediaStreamEnabledPreferenceKey];
2493 }
2494
2495 - (void)setMediaStreamEnabled:(BOOL)flag
2496 {
2497     [self _setBoolValue:flag forKey:WebKitMediaStreamEnabledPreferenceKey];
2498 }
2499
2500 - (BOOL)peerConnectionEnabled
2501 {
2502     return [self _boolValueForKey:WebKitPeerConnectionEnabledPreferenceKey];
2503 }
2504
2505 - (void)setPeerConnectionEnabled:(BOOL)flag
2506 {
2507     [self _setBoolValue:flag forKey:WebKitPeerConnectionEnabledPreferenceKey];
2508 }
2509
2510 - (BOOL)linkPreloadEnabled
2511 {
2512     return [self _boolValueForKey:WebKitLinkPreloadEnabledPreferenceKey];
2513 }
2514
2515 - (void)setLinkPreloadEnabled:(BOOL)flag
2516 {
2517     [self _setBoolValue:flag forKey:WebKitLinkPreloadEnabledPreferenceKey];
2518 }
2519
2520 - (BOOL)mediaPreloadingEnabled
2521 {
2522     return [self _boolValueForKey:WebKitMediaPreloadingEnabledPreferenceKey];
2523 }
2524
2525 - (void)setMediaPreloadingEnabled:(BOOL)flag
2526 {
2527     [self _setBoolValue:flag forKey:WebKitMediaPreloadingEnabledPreferenceKey];
2528 }
2529
2530 - (void)setMetaRefreshEnabled:(BOOL)enabled
2531 {
2532     [self setHTTPEquivEnabled:enabled];
2533 }
2534
2535 - (BOOL)metaRefreshEnabled
2536 {
2537     return [self httpEquivEnabled];
2538 }
2539
2540 - (void)setHTTPEquivEnabled:(BOOL)enabled
2541 {
2542     [self _setBoolValue:enabled forKey:WebKitHTTPEquivEnabledPreferenceKey];
2543 }
2544
2545 - (BOOL)httpEquivEnabled
2546 {
2547     return [self _boolValueForKey:WebKitHTTPEquivEnabledPreferenceKey];
2548 }
2549
2550 - (BOOL)javaScriptMarkupEnabled
2551 {
2552     return [self _boolValueForKey:WebKitJavaScriptMarkupEnabledPreferenceKey];
2553 }
2554
2555 - (void)setJavaScriptMarkupEnabled:(BOOL)flag
2556 {
2557     [self _setBoolValue:flag forKey:WebKitJavaScriptMarkupEnabledPreferenceKey];
2558 }
2559
2560 - (BOOL)mediaDataLoadsAutomatically
2561 {
2562     return [self _boolValueForKey:WebKitMediaDataLoadsAutomaticallyPreferenceKey];
2563 }
2564
2565 - (void)setMediaDataLoadsAutomatically:(BOOL)flag
2566 {
2567     [self _setBoolValue:flag forKey:WebKitMediaDataLoadsAutomaticallyPreferenceKey];
2568 }
2569
2570 - (BOOL)attachmentElementEnabled
2571 {
2572     return [self _boolValueForKey:WebKitAttachmentElementEnabledPreferenceKey];
2573 }
2574
2575 - (void)setAttachmentElementEnabled:(BOOL)flag
2576 {
2577     [self _setBoolValue:flag forKey:WebKitAttachmentElementEnabledPreferenceKey];
2578 }
2579
2580 - (BOOL)allowsInlineMediaPlaybackAfterFullscreen
2581 {
2582     return [self _boolValueForKey:WebKitAllowsInlineMediaPlaybackAfterFullscreenPreferenceKey];
2583 }
2584
2585 - (void)setAllowsInlineMediaPlaybackAfterFullscreen:(BOOL)flag
2586 {
2587     [self _setBoolValue:flag forKey:WebKitAllowsInlineMediaPlaybackAfterFullscreenPreferenceKey];
2588 }
2589
2590 - (BOOL)mockCaptureDevicesEnabled
2591 {
2592     return [self _boolValueForKey:WebKitMockCaptureDevicesEnabledPreferenceKey];
2593 }
2594
2595 - (void)setMockCaptureDevicesEnabled:(BOOL)flag
2596 {
2597     [self _setBoolValue:flag forKey:WebKitMockCaptureDevicesEnabledPreferenceKey];
2598 }
2599
2600 - (BOOL)mockCaptureDevicesPromptEnabled
2601 {
2602     return [self _boolValueForKey:WebKitMockCaptureDevicesPromptEnabledPreferenceKey];
2603 }
2604
2605 - (void)setMockCaptureDevicesPromptEnabled:(BOOL)flag
2606 {
2607     [self _setBoolValue:flag forKey:WebKitMockCaptureDevicesPromptEnabledPreferenceKey];
2608 }
2609
2610 - (BOOL)enumeratingAllNetworkInterfacesEnabled
2611 {
2612     return [self _boolValueForKey:WebKitEnumeratingAllNetworkInterfacesEnabledPreferenceKey];
2613 }
2614
2615 - (void)setEnumeratingAllNetworkInterfacesEnabled:(BOOL)flag
2616 {
2617     [self _setBoolValue:flag forKey:WebKitEnumeratingAllNetworkInterfacesEnabledPreferenceKey];
2618 }
2619
2620 - (BOOL)iceCandidateFilteringEnabled
2621 {
2622     return [self _boolValueForKey:WebKitICECandidateFilteringEnabledPreferenceKey];
2623 }
2624
2625 - (void)setIceCandidateFilteringEnabled:(BOOL)flag
2626 {
2627     [self _setBoolValue:flag forKey:WebKitICECandidateFilteringEnabledPreferenceKey];
2628 }
2629
2630 - (BOOL)mediaCaptureRequiresSecureConnection
2631 {
2632     return [self _boolValueForKey:WebKitMediaCaptureRequiresSecureConnectionPreferenceKey];
2633 }
2634
2635 - (void)setMediaCaptureRequiresSecureConnection:(BOOL)flag
2636 {
2637     [self _setBoolValue:flag forKey:WebKitMediaCaptureRequiresSecureConnectionPreferenceKey];
2638 }
2639
2640 - (BOOL)dataTransferItemsEnabled
2641 {
2642     return [self _boolValueForKey:WebKitDataTransferItemsEnabledPreferenceKey];
2643 }
2644
2645 - (void)setDataTransferItemsEnabled:(BOOL)flag
2646 {
2647     [self _setBoolValue:flag forKey:WebKitDataTransferItemsEnabledPreferenceKey];
2648 }
2649
2650 - (BOOL)customPasteboardDataEnabled
2651 {
2652     return [self _boolValueForKey:WebKitCustomPasteboardDataEnabledPreferenceKey];
2653 }
2654
2655 - (void)setCustomPasteboardDataEnabled:(BOOL)flag
2656 {
2657     [self _setBoolValue:flag forKey:WebKitCustomPasteboardDataEnabledPreferenceKey];
2658 }
2659
2660 - (BOOL)cacheAPIEnabled
2661 {
2662     return [self _boolValueForKey:WebKitCacheAPIEnabledPreferenceKey];
2663 }
2664
2665 - (void)setCacheAPIEnabled:(BOOL)flag
2666 {
2667     [self _setBoolValue:flag forKey:WebKitCacheAPIEnabledPreferenceKey];
2668 }
2669
2670 - (BOOL)downloadAttributeEnabled
2671 {
2672     return [self _boolValueForKey:WebKitDownloadAttributeEnabledPreferenceKey];
2673 }
2674
2675 - (void)setDownloadAttributeEnabled:(BOOL)flag
2676 {
2677     [self _setBoolValue:flag forKey:WebKitDownloadAttributeEnabledPreferenceKey];
2678 }
2679
2680 - (void)setDirectoryUploadEnabled:(BOOL)flag
2681 {
2682     [self _setBoolValue:flag forKey:WebKitDirectoryUploadEnabledPreferenceKey];
2683 }
2684
2685 - (BOOL)directoryUploadEnabled
2686 {
2687     return [self _boolValueForKey:WebKitDirectoryUploadEnabledPreferenceKey];
2688 }
2689
2690 - (BOOL)CSSOMViewScrollingAPIEnabled
2691 {
2692     return [self _boolValueForKey:WebKitCSSOMViewScrollingAPIEnabledPreferenceKey];
2693 }
2694
2695 - (void)setCSSOMViewScrollingAPIEnabled:(BOOL)flag
2696 {
2697     [self _setBoolValue:flag forKey:WebKitCSSOMViewScrollingAPIEnabledPreferenceKey];
2698 }
2699
2700 - (BOOL)menuItemElementEnabled
2701 {
2702     return [self _boolValueForKey:WebKitMenuItemElementEnabledPreferenceKey];
2703 }
2704
2705 - (void)setMenuItemElementEnabled:(BOOL)flag
2706 {
2707     [self _setBoolValue:flag forKey:WebKitMenuItemElementEnabledPreferenceKey];
2708 }
2709
2710 - (BOOL)mediaUserGestureInheritsFromDocument
2711 {
2712     return [self _boolValueForKey:WebKitMediaUserGestureInheritsFromDocument];
2713 }
2714
2715 - (void)setMediaUserGestureInheritsFromDocument:(BOOL)flag
2716 {
2717     [self _setBoolValue:flag forKey:WebKitMediaUserGestureInheritsFromDocument];
2718 }
2719
2720 #if PLATFORM(IOS_FAMILY)
2721 - (BOOL)quickLookDocumentSavingEnabled
2722 {
2723     return [self _boolValueForKey:WebKitQuickLookDocumentSavingPreferenceKey];
2724 }
2725
2726 - (void)setQuickLookDocumentSavingEnabled:(BOOL)flag
2727 {
2728     [self _setBoolValue:flag forKey:WebKitQuickLookDocumentSavingPreferenceKey];
2729 }
2730 #endif
2731
2732 - (NSString *)mediaContentTypesRequiringHardwareSupport
2733 {
2734     return [self _stringValueForKey:WebKitMediaContentTypesRequiringHardwareSupportPreferenceKey];
2735 }
2736
2737 - (void)setMediaContentTypesRequiringHardwareSupport:(NSString *)value
2738 {
2739     [self _setStringValue:value forKey:WebKitMediaContentTypesRequiringHardwareSupportPreferenceKey];
2740 }
2741
2742 - (BOOL)legacyEncryptedMediaAPIEnabled
2743 {
2744     return [self _boolValueForKey:WebKitLegacyEncryptedMediaAPIEnabledKey];
2745 }
2746
2747 - (void)setLegacyEncryptedMediaAPIEnabled:(BOOL)flag
2748 {
2749     [self _setBoolValue:flag forKey:WebKitLegacyEncryptedMediaAPIEnabledKey];
2750 }
2751
2752 - (BOOL)encryptedMediaAPIEnabled
2753 {
2754     return [self _boolValueForKey:WebKitEncryptedMediaAPIEnabledKey];
2755 }
2756
2757 - (void)setEncryptedMediaAPIEnabled:(BOOL)flag
2758 {
2759     [self _setBoolValue:flag forKey:WebKitEncryptedMediaAPIEnabledKey];
2760 }
2761
2762 - (BOOL)pictureInPictureAPIEnabled
2763 {
2764     return [self _boolValueForKey:WebKitPictureInPictureAPIEnabledKey];
2765 }
2766
2767 - (void)setPictureInPictureAPIEnabled:(BOOL)flag
2768 {
2769     [self _setBoolValue:flag forKey:WebKitPictureInPictureAPIEnabledKey];
2770 }
2771
2772 - (BOOL)constantPropertiesEnabled
2773 {
2774     return [self _boolValueForKey:WebKitConstantPropertiesEnabledPreferenceKey];
2775 }
2776
2777 - (void)setConstantPropertiesEnabled:(BOOL)flag
2778 {
2779     [self _setBoolValue:flag forKey:WebKitConstantPropertiesEnabledPreferenceKey];
2780 }
2781
2782 - (BOOL)colorFilterEnabled
2783 {
2784     return [self _boolValueForKey:WebKitColorFilterEnabledPreferenceKey];
2785 }
2786
2787 - (void)setColorFilterEnabled:(BOOL)flag
2788 {
2789     [self _setBoolValue:flag forKey:WebKitColorFilterEnabledPreferenceKey];
2790 }
2791
2792 - (BOOL)punchOutWhiteBackgroundsInDarkMode
2793 {
2794     return [self _boolValueForKey:WebKitPunchOutWhiteBackgroundsInDarkModePreferenceKey];
2795 }
2796
2797 - (void)setPunchOutWhiteBackgroundsInDarkMode:(BOOL)flag
2798 {
2799     [self _setBoolValue:flag forKey:WebKitPunchOutWhiteBackgroundsInDarkModePreferenceKey];
2800 }
2801
2802 - (BOOL)allowMediaContentTypesRequiringHardwareSupportAsFallback
2803 {
2804     return [self _boolValueForKey:WebKitAllowMediaContentTypesRequiringHardwareSupportAsFallbackKey];
2805 }
2806
2807 - (void)setAllowMediaContentTypesRequiringHardwareSupportAsFallback:(BOOL)flag
2808 {
2809     [self _setBoolValue:flag forKey:WebKitAllowMediaContentTypesRequiringHardwareSupportAsFallbackKey];
2810 }
2811
2812 - (BOOL)inspectorAdditionsEnabled
2813 {
2814     return [self _boolValueForKey:WebKitInspectorAdditionsEnabledPreferenceKey];
2815 }
2816
2817 - (void)setInspectorAdditionsEnabled:(BOOL)flag
2818 {
2819     [self _setBoolValue:flag forKey:WebKitInspectorAdditionsEnabledPreferenceKey];
2820 }
2821
2822 - (BOOL)mediaCapabilitiesEnabled
2823 {
2824     return [self _boolValueForKey:WebKitMediaCapabilitiesEnabledPreferenceKey];
2825 }
2826
2827 - (void)setMediaCapabilitiesEnabled:(BOOL)flag
2828 {
2829     [self _setBoolValue:flag forKey:WebKitMediaCapabilitiesEnabledPreferenceKey];
2830 }
2831
2832 - (BOOL)cssLogicalEnabled
2833 {
2834     return [self _boolValueForKey:WebKitCSSLogicalEnabledPreferenceKey];
2835 }
2836
2837 - (void)setCSSLogicalEnabled:(BOOL)flag
2838 {
2839     [self _setBoolValue:flag forKey:WebKitCSSLogicalEnabledPreferenceKey];
2840 }
2841
2842 - (BOOL)lineHeightUnitsEnabled
2843 {
2844     return [self _boolValueForKey:WebKitLineHeightUnitsEnabledPreferenceKey];
2845 }
2846
2847 - (void)setLineHeightUnitsEnabled:(BOOL)flag
2848 {
2849     [self _setBoolValue:flag forKey:WebKitLineHeightUnitsEnabledPreferenceKey];
2850 }
2851
2852 - (BOOL)layoutFormattingContextIntegrationEnabled
2853 {
2854     return [self _boolValueForKey:WebKitLayoutFormattingContextIntegrationEnabledPreferenceKey];
2855 }
2856
2857 - (void)setLayoutFormattingContextIntegrationEnabled:(BOOL)flag
2858 {
2859     [self _setBoolValue:flag forKey:WebKitLayoutFormattingContextIntegrationEnabledPreferenceKey];
2860 }
2861
2862 - (BOOL)isInAppBrowserPrivacyEnabled
2863 {
2864     return [self _boolValueForKey:WebKitDebugInAppBrowserPrivacyEnabledPreferenceKey];
2865 }
2866
2867 - (void)setInAppBrowserPrivacyEnabled:(BOOL)flag
2868 {
2869     [self _setBoolValue:flag forKey:WebKitDebugInAppBrowserPrivacyEnabledPreferenceKey];
2870 }
2871
2872 - (BOOL)webSQLEnabled
2873 {
2874     return [self _boolValueForKey:WebKitWebSQLEnabledPreferenceKey];
2875 }
2876
2877 - (void)setWebSQLEnabled:(BOOL)webSQLEnabled
2878 {
2879     [self _setBoolValue:webSQLEnabled forKey:WebKitWebSQLEnabledPreferenceKey];
2880 }
2881
2882 @end
2883
2884 @implementation WebPreferences (WebInternal)
2885
2886 + (NSString *)_IBCreatorID
2887 {
2888     return classIBCreatorID().get();
2889 }
2890
2891 + (NSString *)_concatenateKeyWithIBCreatorID:(NSString *)key
2892 {
2893     NSString *IBCreatorID = [WebPreferences _IBCreatorID];
2894     if (!IBCreatorID)
2895         return key;
2896     return [IBCreatorID stringByAppendingString:key];
2897 }
2898
2899 @end
2900
2901 @implementation WebPreferences (WebPrivateFeatures)
2902
2903 - (BOOL)_isEnabledForFeature:(WebFeature *)feature
2904 {
2905     return [self _boolValueForKey:feature.preferenceKey];
2906 }
2907
2908 - (void)_setEnabled:(BOOL)value forFeature:(WebFeature *)feature
2909 {
2910     [self _setBoolValue:value forKey:feature.preferenceKey];
2911 }
2912
2913 @end
2914
2915 @implementation WebPreferences (WebPrivateTesting)
2916
2917 + (void)_switchNetworkLoaderToNewTestingSession
2918 {
2919 #if PLATFORM(IOS_FAMILY)
2920     WebThreadLock();
2921 #endif
2922     NetworkStorageSessionMap::switchToNewTestingSession();
2923 }
2924
2925 + (void)_setCurrentNetworkLoaderSessionCookieAcceptPolicy:(NSHTTPCookieAcceptPolicy)policy
2926 {
2927     auto cookieStorage = NetworkStorageSessionMap::defaultStorageSession().cookieStorage();
2928     RELEASE_ASSERT(cookieStorage); // Will fail when NetworkStorageSessionMap::switchToNewTestingSession() was not called beforehand.
2929     CFHTTPCookieStorageSetCookieAcceptPolicy(cookieStorage.get(), policy);
2930 }
2931
2932 + (void)_clearNetworkLoaderSession
2933 {
2934     NetworkStorageSessionMap::defaultStorageSession().deleteAllCookies();
2935 }
2936
2937 - (void)_setBoolPreferenceForTestingWithValue:(BOOL)value forKey:(NSString *)key
2938 {
2939     [self _setBoolValue:value forKey:key];
2940 }
2941
2942 - (void)_setUInt32PreferenceForTestingWithValue:(uint32_t)value forKey:(NSString *)key
2943 {
2944     [self _setIntegerValue:value forKey:key];
2945 }
2946
2947 - (void)_setDoublePreferenceForTestingWithValue:(double)value forKey:(NSString *)key
2948 {
2949     [self _setFloatValue:value forKey:key];
2950 }
2951
2952 - (void)_setStringPreferenceForTestingWithValue:(NSString *)value forKey:(NSString *)key
2953 {
2954     [self _setStringValue:value forKey:key];
2955 }
2956
2957 @end
2958
2959 @implementation WebPreferences (WebPrivatePreferencesConvertedToWebFeature)
2960
2961 - (BOOL)userGesturePromisePropagationEnabled
2962 {
2963     return [self _boolValueForKey:WebKitUserGesturePromisePropagationEnabledPreferenceKey];
2964 }
2965
2966 - (void)setUserGesturePromisePropagationEnabled:(BOOL)flag
2967 {
2968     [self _setBoolValue:flag forKey:WebKitUserGesturePromisePropagationEnabledPreferenceKey];
2969 }
2970
2971 - (BOOL)requestIdleCallbackEnabled
2972 {
2973     return [self _boolValueForKey:WebKitRequestIdleCallbackEnabledPreferenceKey];
2974 }
2975
2976 - (void)setRequestIdleCallbackEnabled:(BOOL)flag
2977 {
2978     [self _setBoolValue:flag forKey:WebKitRequestIdleCallbackEnabledPreferenceKey];
2979 }
2980
2981 - (BOOL)highlightAPIEnabled
2982 {
2983     return [self _boolValueForKey:WebKitHighlightAPIEnabledPreferenceKey];
2984 }
2985
2986 - (void)setHighlightAPIEnabled:(BOOL)flag
2987 {
2988     [self _setBoolValue:flag forKey:WebKitHighlightAPIEnabledPreferenceKey];
2989 }
2990
2991 - (BOOL)asyncClipboardAPIEnabled
2992 {
2993     return [self _boolValueForKey:WebKitAsyncClipboardAPIEnabledPreferenceKey];
2994 }
2995
2996 - (void)setAsyncClipboardAPIEnabled:(BOOL)flag
2997 {
2998     [self _setBoolValue:flag forKey:WebKitAsyncClipboardAPIEnabledPreferenceKey];
2999 }
3000
3001 - (BOOL)contactPickerAPIEnabled
3002 {
3003     return [self _boolValueForKey:WebKitContactPickerAPIEnabledPreferenceKey];
3004 }
3005
3006 - (void)setContactPickerAPIEnabled:(BOOL)flag
3007 {
3008     [self _setBoolValue:flag forKey:WebKitContactPickerAPIEnabledPreferenceKey];
3009 }
3010
3011 - (BOOL)intersectionObserverEnabled
3012 {
3013     return [self _boolValueForKey:WebKitIntersectionObserverEnabledPreferenceKey];
3014 }
3015
3016 - (void)setIntersectionObserverEnabled:(BOOL)flag
3017 {
3018     [self _setBoolValue:flag forKey:WebKitIntersectionObserverEnabledPreferenceKey];
3019 }
3020
3021 - (BOOL)visualViewportAPIEnabled
3022 {
3023     return [self _boolValueForKey:WebKitVisualViewportAPIEnabledPreferenceKey];
3024 }
3025
3026 - (void)setVisualViewportAPIEnabled:(BOOL)flag
3027 {
3028     [self _setBoolValue:flag forKey:WebKitVisualViewportAPIEnabledPreferenceKey];
3029 }
3030
3031 - (BOOL)syntheticEditingCommandsEnabled
3032 {
3033     return [self _boolValueForKey:WebKitSyntheticEditingCommandsEnabledPreferenceKey];
3034 }
3035
3036 - (void)setSyntheticEditingCommandsEnabled:(BOOL)flag
3037 {
3038     [self _setBoolValue:flag forKey:WebKitSyntheticEditingCommandsEnabledPreferenceKey];
3039 }
3040
3041 - (BOOL)CSSOMViewSmoothScrollingEnabled
3042 {
3043     return [self _boolValueForKey:WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey];
3044 }
3045
3046 - (void)setCSSOMViewSmoothScrollingEnabled:(BOOL)flag
3047 {
3048     [self _setBoolValue:flag forKey:WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey];
3049 }
3050
3051 - (BOOL)webAnimationsCompositeOperationsEnabled
3052 {
3053     return [self _boolValueForKey:WebKitWebAnimationsCompositeOperationsEnabledPreferenceKey];
3054 }
3055
3056 - (void)setWebAnimationsCompositeOperationsEnabled:(BOOL)flag
3057 {
3058     [self _setBoolValue:flag forKey:WebKitWebAnimationsCompositeOperationsEnabledPreferenceKey];
3059 }
3060
3061 - (BOOL)webAnimationsMutableTimelinesEnabled
3062 {
3063     return [self _boolValueForKey:WebKitWebAnimationsMutableTimelinesEnabledPreferenceKey];
3064 }
3065
3066 - (void)setWebAnimationsMutableTimelinesEnabled:(BOOL)flag
3067 {
3068     [self _setBoolValue:flag forKey:WebKitWebAnimationsMutableTimelinesEnabledPreferenceKey];
3069 }
3070
3071 - (BOOL)webGL2Enabled
3072 {
3073     return [self _boolValueForKey:WebKitWebGL2EnabledPreferenceKey];
3074 }
3075
3076 - (void)setWebGL2Enabled:(BOOL)enabled
3077 {
3078     [self _setBoolValue:enabled forKey:WebKitWebGL2EnabledPreferenceKey];
3079 }
3080
3081 - (BOOL)maskWebGLStringsEnabled
3082 {
3083     return [self _boolValueForKey:WebKitMaskWebGLStringsEnabledPreferenceKey];
3084 }
3085
3086 - (void)setMaskWebGLStringsEnabled:(BOOL)enabled
3087 {
3088     [self _setBoolValue:enabled forKey:WebKitMaskWebGLStringsEnabledPreferenceKey];
3089 }
3090
3091 - (BOOL)accessibilityObjectModelEnabled
3092 {
3093     return [self _boolValueForKey:WebKitAccessibilityObjectModelEnabledPreferenceKey];
3094 }
3095
3096 - (void)setAccessibilityObjectModelEnabled:(BOOL)flag
3097 {
3098     [self _setBoolValue:flag forKey:WebKitAccessibilityObjectModelEnabledPreferenceKey];
3099 }
3100
3101 - (BOOL)serverTimingEnabled
3102 {
3103     return [self _boolValueForKey:WebKitServerTimingEnabledPreferenceKey];
3104 }
3105
3106 - (void)setServerTimingEnabled:(BOOL)flag
3107 {
3108     [self _setBoolValue:flag forKey:WebKitServerTimingEnabledPreferenceKey];
3109 }
3110
3111 - (BOOL)CSSCustomPropertiesAndValuesEnabled
3112 {
3113     return [self _boolValueForKey:WebKitCSSCustomPropertiesAndValuesEnabledPreferenceKey];
3114 }
3115
3116 - (void)setCSSCustomPropertiesAndValuesEnabled:(BOOL)flag
3117 {
3118     [self _setBoolValue:flag forKey:WebKitCSSCustomPropertiesAndValuesEnabledPreferenceKey];
3119 }
3120
3121 - (BOOL)resizeObserverEnabled
3122 {
3123     return [self _boolValueForKey:WebKitResizeObserverEnabledPreferenceKey];
3124 }
3125
3126 - (void)setResizeObserverEnabled:(BOOL)flag
3127 {
3128     [self _setBoolValue:flag forKey:WebKitResizeObserverEnabledPreferenceKey];
3129 }
3130
3131 - (BOOL)privateClickMeasurementEnabled
3132 {
3133     return [self _boolValueForKey:WebKitPrivateClickMeasurementEnabledPreferenceKey];
3134 }
3135
3136 - (void)setPrivateClickMeasurementEnabled:(BOOL)flag
3137 {
3138     [self _setBoolValue:flag forKey:WebKitPrivateClickMeasurementEnabledPreferenceKey];
3139 }
3140
3141 - (BOOL)fetchAPIKeepAliveEnabled
3142 {
3143     return [self _boolValueForKey:WebKitFetchAPIEnabledPreferenceKey];
3144 }
3145
3146 - (void)setFetchAPIKeepAliveEnabled:(BOOL)flag
3147 {
3148     [self _setBoolValue:flag forKey:WebKitFetchAPIEnabledPreferenceKey];
3149 }
3150
3151 - (BOOL)genericCueAPIEnabled
3152 {
3153     return [self _boolValueForKey:WebKitGenericCueAPIEnabledKey];
3154 }
3155
3156 - (void)setGenericCueAPIEnabled:(BOOL)flag
3157 {
3158     [self _setBoolValue:flag forKey:WebKitGenericCueAPIEnabledKey];
3159 }
3160
3161 - (BOOL)aspectRatioOfImgFromWidthAndHeightEnabled
3162 {
3163     return [self _boolValueForKey:WebKitAspectRatioOfImgFromWidthAndHeightEnabledPreferenceKey];
3164 }
3165
3166 - (void)setAspectRatioOfImgFromWidthAndHeightEnabled:(BOOL)flag
3167 {
3168     [self _setBoolValue:flag forKey:WebKitAspectRatioOfImgFromWidthAndHeightEnabledPreferenceKey];
3169 }
3170
3171 - (BOOL)referrerPolicyAttributeEnabled
3172 {
3173     return [self _boolValueForKey:WebKitReferrerPolicyAttributeEnabledPreferenceKey];
3174 }
3175
3176 - (void)setReferrerPolicyAttributeEnabled:(BOOL)flag
3177 {
3178     [self _setBoolValue:flag forKey:WebKitReferrerPolicyAttributeEnabledPreferenceKey];
3179 }
3180
3181 - (BOOL)coreMathMLEnabled
3182 {
3183     return [self _boolValueForKey:WebKitCoreMathMLEnabledPreferenceKey];
3184 }
3185
3186 - (void)setCoreMathMLEnabled:(BOOL)flag
3187 {
3188     [self _setBoolValue:flag forKey:WebKitCoreMathMLEnabledPreferenceKey];
3189 }
3190
3191 - (BOOL)linkPreloadResponsiveImagesEnabled
3192 {
3193     return [self _boolValueForKey:WebKitLinkPreloadResponsiveImagesEnabledPreferenceKey];
3194 }
3195
3196 - (void)setLinkPreloadResponsiveImagesEnabled:(BOOL)flag
3197 {
3198     [self _setBoolValue:flag forKey:WebKitLinkPreloadResponsiveImagesEnabledPreferenceKey];
3199 }
3200
3201 - (BOOL)remotePlaybackEnabled
3202 {
3203     return [self _boolValueForKey:WebKitRemotePlaybackEnabledPreferenceKey];
3204 }
3205
3206 - (void)setRemotePlaybackEnabled:(BOOL)remotePlaybackEnabled
3207 {
3208     [self _setBoolValue:remotePlaybackEnabled forKey:WebKitRemotePlaybackEnabledPreferenceKey];
3209 }
3210
3211 - (BOOL)readableByteStreamAPIEnabled
3212 {
3213     return [self _boolValueForKey:WebKitReadableByteStreamAPIEnabledPreferenceKey];
3214 }
3215
3216 - (void)setReadableByteStreamAPIEnabled:(BOOL)flag
3217 {
3218     [self _setBoolValue:flag forKey:WebKitReadableByteStreamAPIEnabledPreferenceKey];
3219 }
3220
3221 - (BOOL)transformStreamAPIEnabled
3222 {
3223     return [self _boolValueForKey:WebKitTransformStreamAPIEnabledPreferenceKey];
3224 }
3225
3226 - (void)setTransformStreamAPIEnabled:(BOOL)flag
3227 {
3228     [self _setBoolValue:flag forKey:WebKitTransformStreamAPIEnabledPreferenceKey];
3229 }
3230
3231 - (BOOL)_mediaRecorderEnabled
3232 {
3233     return [self _boolValueForKey:WebKitMediaRecorderEnabledPreferenceKey];
3234 }
3235
3236 - (void)_setMediaRecorderEnabled:(BOOL)flag
3237 {
3238     [self _setBoolValue:flag forKey:WebKitMediaRecorderEnabledPreferenceKey];
3239 }
3240
3241 - (BOOL)mediaRecorderEnabled
3242 {
3243     return [self _boolValueForKey:WebKitMediaRecorderEnabledPreferenceKey];
3244 }
3245
3246 - (void)setMediaRecorderEnabled:(BOOL)flag
3247 {
3248     [self _setBoolValue:flag forKey:WebKitMediaRecorderEnabledPreferenceKey];
3249 }
3250
3251 - (BOOL)CSSIndividualTransformPropertiesEnabled
3252 {
3253     return [self _boolValueForKey:WebKitCSSIndividualTransformPropertiesEnabledPreferenceKey];
3254 }
3255
3256 - (void)setCSSIndividualTransformPropertiesEnabled:(BOOL)flag
3257 {
3258     [self _setBoolValue:flag forKey:WebKitCSSIndividualTransformPropertiesEnabledPreferenceKey];
3259 }
3260
3261 - (BOOL)_speechRecognitionEnabled
3262 {
3263     return [self _boolValueForKey:WebKitSpeechRecognitionEnabledPreferenceKey];
3264 }
3265
3266 - (void)_setSpeechRecognitionEnabled:(BOOL)flag
3267 {
3268     [self _setBoolValue:flag forKey:WebKitSpeechRecognitionEnabledPreferenceKey];
3269 }
3270
3271 - (WebKitPitchCorrectionAlgorithm)_pitchCorrectionAlgorithm
3272 {
3273     return static_cast<WebKitPitchCorrectionAlgorithm>([self _unsignedIntValueForKey:WebKitPitchCorrectionAlgorithmPreferenceKey]);
3274 }
3275
3276 - (void)_setPitchCorrectionAlgorithm:(WebKitPitchCorrectionAlgorithm)pitchCorrectionAlgorithm
3277 {
3278     [self _setUnsignedIntValue:pitchCorrectionAlgorithm forKey:WebKitPitchCorrectionAlgorithmPreferenceKey];
3279 }
3280
3281 @end
3282
3283 @implementation WebPreferences (WebPrivateObsolete)
3284
3285 // The preferences in this category are deprecated and have no effect. They should
3286 // be removed when it is considered safe to do so.
3287
3288 - (void)setSubpixelCSSOMElementMetricsEnabled:(BOOL)enabled
3289 {
3290     [self _setBoolValue:enabled forKey:WebKitSubpixelCSSOMElementMetricsEnabledPreferenceKey];
3291 }
3292
3293 - (BOOL)subpixelCSSOMElementMetricsEnabled
3294 {
3295     return [self _boolValueForKey:WebKitSubpixelCSSOMElementMetricsEnabledPreferenceKey];
3296 }
3297
3298 - (void)setUserTimingEnabled:(BOOL)flag
3299 {
3300 }
3301
3302 - (BOOL)userTimingEnabled
3303 {
3304     return YES;
3305 }
3306
3307 - (BOOL)requestAnimationFrameEnabled
3308 {
3309     return YES;
3310 }
3311
3312 - (void)setRequestAnimationFrameEnabled:(BOOL)enabled
3313 {
3314 }
3315
3316 - (void)setResourceTimingEnabled:(BOOL)flag
3317 {
3318 }
3319
3320 - (BOOL)resourceTimingEnabled
3321 {
3322     return YES;
3323 }
3324
3325 - (void)setCSSShadowPartsEnabled:(BOOL)flag
3326 {
3327 }
3328
3329 - (BOOL)cssShadowPartsEnabled
3330 {
3331     return YES;
3332 }
3333
3334 - (void)setIsSecureContextAttributeEnabled:(BOOL)flag
3335 {
3336 }
3337
3338 - (BOOL)isSecureContextAttributeEnabled
3339 {
3340     return YES;
3341 }
3342
3343 - (void)setFetchAPIEnabled:(BOOL)flag
3344 {
3345 }
3346
3347 - (BOOL)fetchAPIEnabled
3348 {
3349     return YES;
3350 }
3351
3352 - (void)setShadowDOMEnabled:(BOOL)flag
3353 {
3354 }
3355
3356 - (BOOL)shadowDOMEnabled
3357 {
3358     return YES;
3359 }
3360
3361 - (void)setCustomElementsEnabled:(BOOL)flag
3362 {
3363 }
3364
3365 - (BOOL)customElementsEnabled
3366 {
3367     return YES;
3368 }
3369
3370 - (BOOL)keygenElementEnabled
3371 {
3372     return NO;
3373 }
3374
3375 - (void)setKeygenElementEnabled:(BOOL)flag
3376 {
3377 }
3378
3379 - (void)setVideoPluginProxyEnabled:(BOOL)flag
3380 {
3381 }
3382
3383 - (BOOL)isVideoPluginProxyEnabled
3384 {
3385     return NO;
3386 }
3387
3388 - (void)setHixie76WebSocketProtocolEnabled:(BOOL)flag
3389 {
3390 }
3391
3392 - (BOOL)isHixie76WebSocketProtocolEnabled
3393 {
3394     return NO;
3395 }
3396
3397 - (void)setDiskImageCacheEnabled:(BOOL)enabled
3398 {
3399 }
3400
3401 - (void)setAccelerated2dCanvasEnabled:(BOOL)enabled
3402 {
3403 }
3404
3405 - (BOOL)accelerated2dCanvasEnabled
3406 {
3407     return NO;
3408 }
3409
3410 - (void)setExperimentalNotificationsEnabled:(BOOL)enabled
3411 {
3412 }
3413
3414 - (BOOL)experimentalNotificationsEnabled
3415 {
3416     return NO;
3417 }
3418
3419 - (BOOL)selectionAcrossShadowBoundariesEnabled
3420 {
3421     return YES;
3422 }
3423
3424 - (void)setSelectionAcrossShadowBoundariesEnabled:(BOOL)flag
3425 {
3426 }
3427
3428 - (BOOL)isXSSAuditorEnabled
3429 {
3430     return NO;
3431 }
3432
3433 - (void)setXSSAuditorEnabled:(BOOL)flag
3434 {
3435 }
3436
3437 - (BOOL)isJavaEnabled
3438 {
3439     return NO;
3440 }
3441
3442 - (void)setJavaEnabled:(BOOL)flag
3443 {
3444 }
3445
3446 @end