#import "WebProgressTrackerClient.h"
#import "WebScriptDebugDelegate.h"
#import "WebScriptWorldInternal.h"
+#import "WebSelectionServiceController.h"
#import "WebStorageManagerInternal.h"
#import "WebSystemInterface.h"
#import "WebTextCompletionController.h"
#import <WebCore/ApplicationCacheStorage.h>
#import <WebCore/BackForwardController.h>
#import <WebCore/BackForwardList.h>
-#import <WebCore/MemoryCache.h>
+#import <WebCore/CFNetworkSPI.h>
#import <WebCore/Chrome.h>
#import <WebCore/ColorMac.h>
#import <WebCore/Cursor.h>
#import <WebCore/GCController.h>
#import <WebCore/GeolocationController.h>
#import <WebCore/GeolocationError.h>
-#import <WebCore/HTMLMediaElement.h>
#import <WebCore/HTMLNames.h>
+#import <WebCore/HTMLVideoElement.h>
#import <WebCore/HistoryController.h>
#import <WebCore/HistoryItem.h>
#import <WebCore/IconDatabase.h>
#import <WebCore/Logging.h>
#import <WebCore/MIMETypeRegistry.h>
#import <WebCore/MainFrame.h>
+#import <WebCore/MemoryCache.h>
#import <WebCore/MemoryPressureHandler.h>
+#import <WebCore/NSURLFileTypeMappingsSPI.h>
#import <WebCore/NodeList.h>
#import <WebCore/Notification.h>
#import <WebCore/NotificationController.h>
#import <runtime/ArrayPrototype.h>
#import <runtime/DateInstance.h>
#import <runtime/InitializeThreading.h>
-#import <runtime/JSLock.h>
#import <runtime/JSCJSValue.h>
+#import <runtime/JSLock.h>
#import <wtf/Assertions.h>
#import <wtf/HashTraits.h>
#import <wtf/MainThread.h>
#import <wtf/StdLibExtras.h>
#if !PLATFORM(IOS)
+#import "WebActionMenuController.h"
#import "WebContextMenuClient.h"
#import "WebFullScreenController.h"
#import "WebNSEventExtras.h"
#import "WebNSPasteboardExtras.h"
#import "WebNSPrintOperationExtras.h"
#import "WebPDFView.h"
+#import <WebCore/NSViewSPI.h>
#import <WebCore/WebVideoFullscreenController.h>
#else
#import "MemoryMeasure.h"
#import "WebStorageManagerPrivate.h"
#import "WebUIKitSupport.h"
#import "WebVisiblePosition.h"
-#import <CFNetwork/CFURLCachePriv.h>
-#import <MobileGestalt.h>
+#import <WebCore/DispatchSPI.h>
#import <WebCore/EventNames.h>
#import <WebCore/FontCache.h>
#import <WebCore/GraphicsLayer.h>
#import <WebCore/IconController.h>
#import <WebCore/LegacyTileCache.h>
+#import <WebCore/MobileGestaltSPI.h>
#import <WebCore/NetworkStateNotifier.h>
#import <WebCore/RuntimeApplicationChecksIOS.h>
#import <WebCore/SQLiteDatabaseTracker.h>
#import <WebCore/WebCoreThreadRun.h>
#import <WebCore/WebEvent.h>
#import <WebCore/WebVideoFullscreenControllerAVKit.h>
-#import <dispatch/private.h>
#import <wtf/FastMalloc.h>
#endif // !PLATFORM(IOS)
#import <WebKitLegacy/WebDashboardRegion.h>
#endif
-#if ENABLE(DISK_IMAGE_CACHE) && PLATFORM(IOS)
-#import "WebDiskImageCacheClientIOS.h"
-#import <WebCore/DiskImageCacheIOS.h>
-#endif
-
#if ENABLE(REMOTE_INSPECTOR)
#import <JavaScriptCore/RemoteInspector.h>
#if PLATFORM(IOS)
#include <WebCore/QuickLook.h>
#endif
-#if ENABLE(TOUCH_EVENTS)
+#if ENABLE(IOS_TOUCH_EVENTS)
#import <WebCore/WebEventRegion.h>
#endif
-#if ENABLE(DISK_IMAGE_CACHE)
-#import "WebDiskImageCacheClientIOS.h"
-#import <WebCore/DiskImageCacheIOS.h>
+#if ENABLE(GAMEPAD)
+#import <WebCore/HIDGamepadProvider.h>
#endif
#if !PLATFORM(IOS)
- (NSView *)_hitTest:(NSPoint *)aPoint dragTypes:(NSSet *)types;
- (void)_autoscrollForDraggingInfo:(id)dragInfo timeDelta:(NSTimeInterval)repeatDelta;
- (BOOL)_shouldAutoscrollForDraggingInfo:(id)dragInfo;
+- (void)_windowChangedKeyState;
@end
@interface NSWindow (WebNSWindowDetails)
@implementation WebView (WebPrivate)
-static String userVisibleWebKitVersionString()
+static String webKitBundleVersionString()
{
- // If the version is longer than 3 digits then the leading digits represent the version of the OS. Our user agent
- // string should not include the leading digits, so strip them off and report the rest as the version. <rdar://problem/4997547>
- NSString *fullVersion = [[NSBundle bundleForClass:[WebView class]] objectForInfoDictionaryKey:(NSString *)kCFBundleVersionKey];
- NSRange nonDigitRange = [fullVersion rangeOfCharacterFromSet:[[NSCharacterSet decimalDigitCharacterSet] invertedSet]];
- if (nonDigitRange.location == NSNotFound && fullVersion.length > 3)
- return [fullVersion substringFromIndex:fullVersion.length - 3];
- if (nonDigitRange.location != NSNotFound && nonDigitRange.location > 3)
- return [fullVersion substringFromIndex:nonDigitRange.location - 3];
- return fullVersion;
+ return [[NSBundle bundleForClass:[WebView class]] objectForInfoDictionaryKey:(NSString *)kCFBundleVersionKey];
}
+ (NSString *)_standardUserAgentWithApplicationName:(NSString *)applicationName
{
- return standardUserAgentWithApplicationName(applicationName, userVisibleWebKitVersionString());
+ return standardUserAgentWithApplicationName(applicationName, webKitBundleVersionString());
}
#if PLATFORM(IOS)
return shouldUseLegacyBackgroundSizeShorthandBehavior;
}
+#if ENABLE(GAMEPAD)
+static void WebKitInitializeGamepadProviderIfNecessary()
+{
+ static bool initialized = false;
+ if (initialized)
+ return;
+
+ GamepadProvider::shared().setSharedProvider(HIDGamepadProvider::shared());
+ initialized = true;
+}
+#endif
+
- (void)_commonInitializationWithFrameName:(NSString *)frameName groupName:(NSString *)groupName
{
WebCoreThreadViolationCheckRoundTwo();
[frameView release];
#if !PLATFORM(IOS)
+ if ([self respondsToSelector:@selector(setActionMenu:)]) {
+ RetainPtr<NSMenu> actionMenu = adoptNS([[NSMenu alloc] init]);
+ self.actionMenu = actionMenu.get();
+ _private->actionMenuController = [[WebActionMenuController alloc] initWithWebView:self];
+ }
+
static bool didOneTimeInitialization = false;
#endif
if (!didOneTimeInitialization) {
#endif
WebKitInitializeStorageIfNecessary();
WebKitInitializeApplicationCachePathIfNecessary();
-#if ENABLE(DISK_IMAGE_CACHE) && PLATFORM(IOS)
- WebKitInitializeWebDiskImageCache();
+#if ENABLE(GAMEPAD)
+ WebKitInitializeGamepadProviderIfNecessary();
#endif
Settings::setDefaultMinDOMTimerInterval(0.004);
#endif
}
-- (id)_initWithFrame:(NSRect)f frameName:(NSString *)frameName groupName:(NSString *)groupName usesDocumentViews:(BOOL)usesDocumentViews
+- (id)_initWithFrame:(NSRect)f frameName:(NSString *)frameName groupName:(NSString *)groupName
{
- // FIXME: Remove the usesDocumentViews parameter; it's only here for compatibility with WebKit nightly builds
- // running against Safari 5 on Leopard.
- ASSERT(usesDocumentViews);
-
self = [super initWithFrame:f];
if (!self)
return nil;
NSEnumerator *enumerator = [MIMETypes objectEnumerator];
NSString *MIMEType;
while ((MIMEType = [enumerator nextObject]) != nil) {
- NSArray *extensionsForType = WKGetExtensionsForMIMEType(MIMEType);
+ NSArray *extensionsForType = [[NSURLFileTypeMappings sharedMappings] extensionsForMIMEType:MIMEType];
if (extensionsForType) {
[extensions addObjectsFromArray:extensionsForType];
}
[self setGroupName:groupName];
#if ENABLE(REMOTE_INSPECTOR)
- // Production installs always disallow debugging simple HTML documents.
- // Internal installs allow debugging simple HTML documents (TextFields) if the Internal Setting is enabled.
- if (!isInternalInstall())
- _private->page->setRemoteInspectionAllowed(false);
- else {
- static BOOL textFieldInspectionEnabled = [[NSUserDefaults standardUserDefaults] boolForKey:WebKitTextFieldRemoteInspectionEnabledPreferenceKey];
- _private->page->setRemoteInspectionAllowed(textFieldInspectionEnabled);
- }
+ _private->page->setRemoteInspectionAllowed(isInternalInstall());
#endif
[self _updateScreenScaleFromWindow];
tileControllerMemoryHandler().trimUnparentedTilesToTarget(0);
-#if ENABLE(DISK_IMAGE_CACHE)
- {
- WebKit::MemoryMeasure measurer("Memory warning: flushing images to disk.");
- WebCore::memoryCache()->flushCachedImagesToDisk();
- }
-#endif
-
[WebStorageManager closeIdleLocalStorageDatabases];
[WebView _releaseMemoryNow];
return NO;
}
-#if !PLATFORM(IOS)
-+ (void)_setAlwaysUseATSU:(BOOL)f
-{
- [self _setAlwaysUsesComplexTextCodePath:f];
-}
-#endif
-
+ (void)_setAlwaysUsesComplexTextCodePath:(BOOL)f
{
Font::setCodePath(f ? Font::Complex : Font::Auto);
#if !PLATFORM(IOS)
+ (NSString *)suggestedFileExtensionForMIMEType:(NSString *)type
{
- return WKGetPreferredExtensionForMIMEType(type);
+ return [[NSURLFileTypeMappings sharedMappings] preferredExtensionForMIMEType:type];
}
#endif
_private->mainViewIsScrollingOrZooming = NO;
[self setDefersCallbacks:NO];
[[self mainFrame] setTimeoutsPaused:NO];
- FrameView* view = [self _mainCoreFrame]->view();
- if (view && view->renderView())
- view->renderView()->resumePausedImageAnimationsIfNeeded();
+ if (FrameView* view = [self _mainCoreFrame]->view())
+ view->resumeVisibleImageAnimationsIncludingSubframes();
}
- (void)_setResourceLoadSchedulerSuspended:(BOOL)suspend
resourceLoadScheduler()->resumePendingRequests();
}
-+ (void)_setAcceleratedImageDecoding:(BOOL)enabled
-{
- UNUSED_PARAM(enabled);
-}
-
+ (void)_setAllowCookies:(BOOL)allow
{
ResourceRequestBase::setDefaultAllowCookies(allow);
}
#if ENABLE(VIDEO) && !PLATFORM(IOS)
- [self _exitFullscreen];
+ [self _exitVideoFullscreen];
#endif
#if PLATFORM(IOS)
[self setUIDelegate:nil];
[_private->inspector webViewClosed];
+ [_private->actionMenuController webViewClosed];
#endif
#if !PLATFORM(IOS)
#if !PLATFORM(IOS)
// Get the MIME type from the extension.
if ([extension length] != 0) {
- MIMEType = WKGetMIMETypeForExtension(extension);
+ MIMEType = [[NSURLFileTypeMappings sharedMappings] MIMETypeForExtension:extension];
}
#endif
}
ASSERT(newItemToGoTo);
- _private->page->goToItem(newItemToGoTo, FrameLoadTypeIndexedBackForward);
+ _private->page->goToItem(newItemToGoTo, FrameLoadType::IndexedBackForward);
}
- (void)_setFormDelegate: (id<WebFormDelegate>)delegate
#endif
}
-- (BOOL)_needsUnrestrictedGetMatchedCSSRules
-{
-#if !PLATFORM(IOS)
- static bool needsUnrestrictedGetMatchedCSSRules = !WebKitLinkedOnOrAfter(WEBKIT_FIRST_VERSION_WITH_GET_MATCHED_CSS_RULES_RESTRICTIONS) && applicationIsSafari();
- return needsUnrestrictedGetMatchedCSSRules;
-#else
- // FIXME: <rdar://problem/8963684> Implement linked-on-or-after check for needsUnrestrictedGetMatchedCSSRules
- return NO;
-#endif
-}
-
- (void)_preferencesChangedNotification:(NSNotification *)notification
{
#if PLATFORM(IOS)
settings.setApplicationChromeMode([preferences applicationChromeModeEnabled]);
settings.setNeedsSiteSpecificQuirks(_private->useSiteSpecificSpoofing);
+ settings.setDOMTimersThrottlingEnabled([preferences domTimersThrottlingEnabled]);
settings.setWebArchiveDebugModeEnabled([preferences webArchiveDebugModeEnabled]);
settings.setLocalFileContentSniffingEnabled([preferences localFileContentSniffingEnabled]);
settings.setOfflineWebApplicationCacheEnabled([preferences offlineWebApplicationCacheEnabled]);
settings.setAsynchronousSpellCheckingEnabled([preferences asynchronousSpellCheckingEnabled]);
settings.setHyperlinkAuditingEnabled([preferences hyperlinkAuditingEnabled]);
settings.setUsePreHTML5ParserQuirks([self _needsPreHTML5ParserQuirks]);
- settings.setCrossOriginCheckInGetMatchedCSSRulesDisabled([self _needsUnrestrictedGetMatchedCSSRules]);
settings.setInteractiveFormValidationEnabled([self interactiveFormValidationEnabled]);
settings.setValidationMessageTimerMagnification([self validationMessageTimerMagnification]);
settings.setMediaPlaybackRequiresUserGesture([preferences mediaPlaybackRequiresUserGesture]);
settings.setMediaPlaybackAllowsInline([preferences mediaPlaybackAllowsInline]);
+ settings.setAllowsAlternateFullscreen([preferences allowsAlternateFullscreen]);
settings.setSuppressesIncrementalRendering([preferences suppressesIncrementalRendering]);
settings.setBackspaceKeyNavigationEnabled([preferences backspaceKeyNavigationEnabled]);
settings.setWantsBalancedSetDefersLoadingBehavior([preferences wantsBalancedSetDefersLoadingBehavior]);
settings.setPlugInSnapshottingEnabled([preferences plugInSnapshottingEnabled]);
settings.setFixedPositionCreatesStackingContext(true);
+#if PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101000
+ settings.setAcceleratedCompositingForFixedPositionEnabled(true);
+#endif
+
+#if ENABLE(RUBBER_BANDING)
+ // FIXME: https://bugs.webkit.org/show_bug.cgi?id=136131
+ settings.setRubberBandingForSubScrollableRegionsEnabled(false);
+#endif
#if PLATFORM(IOS)
settings.setStandalone([preferences _standalone]);
settings.setShowsURLsInToolTips([preferences showsURLsInToolTips]);
settings.setShowsToolTipOverTruncatedText([preferences showsToolTipOverTruncatedText]);
settings.setQTKitEnabled([preferences isQTKitEnabled]);
-
- // FIXME: Should we enable this following <rdar://problem/15290404>?
- settings.setMultithreadedWebGLEnabled([preferences multithreadedWebGLEnabled]);
#endif // PLATFORM(MAC)
#if ENABLE(SQL_DATABASE)
#if ENABLE(SERVICE_CONTROLS)
settings.setImageControlsEnabled([preferences imageControlsEnabled]);
+ settings.setServiceControlsEnabled([preferences serviceControlsEnabled]);
#endif
#if ENABLE(VIDEO_TRACK)
settings.setHiddenPageDOMTimerThrottlingEnabled([preferences hiddenPageDOMTimerThrottlingEnabled]);
#endif
-#if ENABLE(PAGE_VISIBILITY_API)
settings.setHiddenPageCSSAnimationSuspensionEnabled([preferences hiddenPageCSSAnimationSuspensionEnabled]);
+
+#if ENABLE(GAMEPAD)
+ RuntimeEnabledFeatures::sharedFeatures().setGamepadsEnabled([preferences gamepadsEnabled]);
#endif
NSTimeInterval timeout = [preferences incrementalRenderingSuppressionTimeoutInSeconds];
if (_private->zoomsTextOnly != zoomsTextOnly)
[self _setZoomMultiplier:_private->zoomMultiplier isTextOnly:zoomsTextOnly];
-#if ENABLE(DISK_IMAGE_CACHE) && PLATFORM(IOS)
- DiskImageCache& diskImageCache = WebCore::diskImageCache();
- diskImageCache.setEnabled([preferences diskImageCacheEnabled]);
- diskImageCache.setMinimumImageSize([preferences diskImageCacheMinimumImageSize]);
- diskImageCache.setMaximumCacheSize([preferences diskImageCacheMaximumCacheSize]);
-#endif
-
#if PLATFORM(IOS)
[[self window] setTileBordersVisible:[preferences showDebugBorders]];
[[self window] setTilePaintCountsVisible:[preferences showRepaintCounter]];
[[self window] setAcceleratedDrawingEnabled:[preferences acceleratedDrawingEnabled]];
[WAKView _setInterpolationQuality:[preferences _interpolationQuality]];
#endif
+
+#if ENABLE(ENCRYPTED_MEDIA_V2)
+ settings.setMediaKeysStorageDirectory([preferences mediaKeysStorageDirectory]);
+#endif
}
static inline IMP getMethod(id o, SEL s)
NSView *documentView = [[kit(&frameView->frame()) frameView] documentView];
for (const auto& widget: frameView->children()) {
- if (widget->isFrameView()) {
- [self _addScrollerDashboardRegionsForFrameView:toFrameView(widget.get()) dashboardRegions:regions];
+ if (is<FrameView>(*widget)) {
+ [self _addScrollerDashboardRegionsForFrameView:downcast<FrameView>(widget.get()) dashboardRegions:regions];
continue;
}
[regionValues release];
}
- WebDashboardRegion *webRegion = [[WebDashboardRegion alloc] initWithRect:pixelSnappedIntRect(region.bounds) clip:pixelSnappedIntRect(region.clip) type:type];
+ WebDashboardRegion *webRegion = [[WebDashboardRegion alloc] initWithRect:snappedIntRect(region.bounds) clip:snappedIntRect(region.clip) type:type];
[regionValues addObject:webRegion];
[webRegion release];
}
continue;
if (layerForWidget->contentsLayerForMedia() != layer) {
- layerForWidget->setContentsToMedia(layer);
+ layerForWidget->setContentsToPlatformLayer(layer, GraphicsLayer::ContentsLayerForMedia);
// We need to make sure the layer hierachy change is applied immediately.
if (mainCoreFrame->view())
mainCoreFrame->view()->flushCompositingStateIncludingSubframes();
if (rect.isEmpty())
continue;
+ // Note that these rectangles are in the coordinate system of the document (inside the WebHTMLView), which is not
+ // the same as the coordinate system of the WebView. If you want to do comparisons with locations in the WebView,
+ // you must convert between the two using WAKView's convertRect:toView: selector. This will take care of scaling
+ // and translations (which are relevant for right-to-left column layout).
+
// The event region wants this points in this order:
// p2------p3
// | |
NSMutableArray* rectsArray = [[NSMutableArray alloc] initWithCapacity:repaintRects.size()];
for (unsigned i = 0; i < repaintRects.size(); ++i)
- [rectsArray addObject:[NSValue valueWithRect:pixelSnappedIntRect(LayoutRect(repaintRects[i]))]];
+ [rectsArray addObject:[NSValue valueWithRect:snappedIntRect(LayoutRect(repaintRects[i]))]];
return [rectsArray autorelease];
}
- (WebPageVisibilityState)_visibilityState
{
-#if ENABLE(PAGE_VISIBILITY_API) || ENABLE(HIDDEN_PAGE_DOM_TIMER_THROTTLING)
if (_private->page)
return kit(_private->page->visibilityState());
-#endif
return WebPageVisibilityStateVisible;
}
#endif
WebCoreThreadViolationCheckRoundTwo();
- return [self _initWithFrame:f frameName:frameName groupName:groupName usesDocumentViews:YES];
+ return [self _initWithFrame:f frameName:frameName groupName:groupName];
}
#if !PLATFORM(IOS)
if (WebCoreObjCScheduleDeallocateOnMainThread([WebView class], self))
return;
+ // Because the machinations of the view's shutdown may cause self to be added to
+ // active autorelease pool, we capture any such releases here to ensure they are
+ // carried out before we are dealloc'd.
+ @autoreleasepool {
+
#if PLATFORM(IOS)
- if (_private)
- [_private->_geolocationProvider stopTrackingWebView:self];
+ if (_private)
+ [_private->_geolocationProvider stopTrackingWebView:self];
#endif
- // call close to ensure we tear-down completely
- // this maintains our old behavior for existing applications
- [self close];
+ // call close to ensure we tear-down completely
+ // this maintains our old behavior for existing applications
+ [self close];
- if ([[self class] shouldIncludeInWebKitStatistics])
- --WebViewCount;
+ if ([[self class] shouldIncludeInWebKitStatistics])
+ --WebViewCount;
#if !PLATFORM(IOS)
- if ([self _needsFrameLoadDelegateRetainQuirk])
- [_private->frameLoadDelegate release];
+ if ([self _needsFrameLoadDelegateRetainQuirk])
+ [_private->frameLoadDelegate release];
#endif
-
- [_private release];
- // [super dealloc] can end up dispatching against _private (3466082)
- _private = nil;
+
+ [_private release];
+ // [super dealloc] can end up dispatching against _private (3466082)
+ _private = nil;
+ }
[super dealloc];
}
_private->page->chrome().windowScreenDidChange((PlatformDisplayID)[[[[[self window] screen] deviceDescription] objectForKey:@"NSScreenNumber"] intValue]);
}
+- (void)_windowChangedKeyState
+{
+ [self _updateActiveState];
+ [super _windowChangedKeyState];
+}
+
- (void)windowKeyStateChanged:(NSNotification *)notification
{
[self _updateActiveState];
}
+- (void)viewDidHide
+{
+ [self _updateVisibilityState];
+}
+
+- (void)viewDidUnhide
+{
+ [self _updateVisibilityState];
+}
+
- (void)_windowWillOrderOnScreen:(NSNotification *)notification
{
if (![self shouldUpdateWhileOffscreen])
if (!_private->page)
return NO;
- _private->page->goToItem(core(item), FrameLoadTypeIndexedBackForward);
+ _private->page->goToItem(core(item), FrameLoadType::IndexedBackForward);
return YES;
}
if (Frame* coreFrame = core(webFrame)) {
// FIXME: We shouldn't have to make a copy here.
Ref<MutableStyleProperties> properties(core(style)->copyProperties());
- coreFrame->editor().applyStyle(&properties.get());
+ coreFrame->editor().applyStyle(properties.ptr());
}
}
break;
}
case WebCacheModelPrimaryWebBrowser: {
-#if PLATFORM(IOS)
- WebPreferences *preferences = [WebPreferences standardPreferences];
- int prefValue;
-#endif
// Page cache capacity (in pages)
// (Research indicates that value / page drops substantially after 3 pages.)
if (memSize >= 2048)
// Reducing the capacity by 1 reduces overall back-forward performance.
if (pageCacheCapacity > 0)
pageCacheCapacity -= 1;
- prefValue = [preferences _pageCacheSize];
- if (prefValue >= 0)
- pageCacheCapacity = prefValue;
#endif
// Object cache capacities (in bytes)
else if (memSize >= 512)
cacheTotalCapacity = 32 * 1024 * 1024;
-#if PLATFORM(IOS)
- prefValue = [preferences _objectCacheSize];
- if (prefValue >= 0)
- cacheTotalCapacity = prefValue;
-#endif
-
cacheMinDeadCapacity = cacheTotalCapacity / 4;
cacheMaxDeadCapacity = cacheTotalCapacity / 2;
nsurlCacheMemoryCapacity = 16 * 1024 * 1024;
else
nsurlCacheMemoryCapacity = 8 * 1024 * 1024;
-
- prefValue = [preferences _NSURLMemoryCacheSize];
- if (prefValue >= 0)
- nsurlCacheMemoryCapacity = prefValue;
#else
// Foundation memory cache capacity (in bytes)
// (These values are small because WebCore does most caching itself.)
nsurlCacheDiskCapacity = 50 * 1024 * 1024;
#if PLATFORM(IOS)
- prefValue = [preferences _NSURLDiskCacheSize];
- if (prefValue >= 0)
- nsurlCacheDiskCapacity = prefValue;
-
// TileCache layer pool capacity, in bytes.
if (memSize >= 1024)
tileLayerPoolCapacity = 48 * 1024 * 1024;
// Don't shrink a big disk cache, since that would cause churn.
nsurlCacheDiskCapacity = std::max(nsurlCacheDiskCapacity, [nsurlCache diskCapacity]);
- memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
- memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
+ memoryCache().setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
+ memoryCache().setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
pageCache()->setCapacity(pageCacheCapacity);
#if PLATFORM(IOS)
pageCache()->setShouldClearBackingStores(true);
#endif
#if ENABLE(VIDEO)
-- (void)_enterFullscreenForNode:(WebCore::Node*)node
+- (void)_enterVideoFullscreenForVideoElement:(WebCore::HTMLVideoElement*)videoElement mode:(WebCore::HTMLMediaElement::VideoFullscreenMode)mode
{
- ASSERT(isHTMLVideoElement(node));
- HTMLMediaElement* videoElement = toHTMLMediaElement(node);
-
if (_private->fullscreenController) {
- if ([_private->fullscreenController mediaElement] == videoElement) {
+ if ([_private->fullscreenController videoElement] == videoElement) {
// The backend may just warn us that the underlaying plaftormMovie()
// has changed. Just force an update.
- [_private->fullscreenController setMediaElement:videoElement];
+ [_private->fullscreenController setVideoElement:videoElement];
return; // No more to do.
}
- // First exit Fullscreen for the old mediaElement.
- [_private->fullscreenController mediaElement]->exitFullscreen();
+ // First exit Fullscreen for the old videoElement.
+ [_private->fullscreenController videoElement]->exitFullscreen();
// This previous call has to trigger _exitFullscreen,
// which has to clear _private->fullscreenController.
ASSERT(!_private->fullscreenController);
}
if (!_private->fullscreenController) {
_private->fullscreenController = [[WebVideoFullscreenController alloc] init];
- [_private->fullscreenController setMediaElement:videoElement];
+ [_private->fullscreenController setVideoElement:videoElement];
#if PLATFORM(IOS)
- [_private->fullscreenController enterFullscreen:nil];
+ [_private->fullscreenController enterFullscreen:(UIView *)[[[self window] hostLayer] delegate] mode:mode];
#else
[_private->fullscreenController enterFullscreen:[[self window] screen]];
#endif
}
else
- [_private->fullscreenController setMediaElement:videoElement];
+ [_private->fullscreenController setVideoElement:videoElement];
}
-- (void)_exitFullscreen
+- (void)_exitVideoFullscreen
{
if (!_private->fullscreenController)
return;
_private->fullscreenController = nil;
}
-#endif // ENABLE(VIDEO) && !PLATFORM(IOS)
+#endif // ENABLE(VIDEO)
#if ENABLE(FULLSCREEN_API) && !PLATFORM(IOS)
- (BOOL)_supportsFullScreenForElement:(const WebCore::Element*)element withKeyboard:(BOOL)withKeyboard
}
#endif
+#if ENABLE(SERVICE_CONTROLS)
+- (WebSelectionServiceController&)_selectionServiceController
+{
+ if (!_private->_selectionServiceController)
+ _private->_selectionServiceController = std::make_unique<WebSelectionServiceController>(self);
+ return *_private->_selectionServiceController;
+}
+#endif
+
- (NSPoint)_convertPointFromRootView:(NSPoint)point
{
return NSMakePoint(point.x, [self bounds].size.height - point.y);
return NSMakeRect(rect.origin.x, [self bounds].size.height - rect.origin.y - rect.size.height, rect.size.width, rect.size.height);
}
+#if !PLATFORM(IOS)
+- (void)prepareForMenu:(NSMenu *)menu withEvent:(NSEvent *)event
+{
+ if (menu != self.actionMenu)
+ return;
+
+ [_private->actionMenuController prepareForMenu:menu withEvent:event];
+}
+
+- (void)willOpenMenu:(NSMenu *)menu withEvent:(NSEvent *)event
+{
+ if (menu != self.actionMenu)
+ return;
+
+ [_private->actionMenuController willOpenMenu:menu withEvent:event];
+}
+
+- (void)didCloseMenu:(NSMenu *)menu withEvent:(NSEvent *)event
+{
+ if (menu != self.actionMenu)
+ return;
+
+ [_private->actionMenuController didCloseMenu:menu withEvent:event];
+}
+#endif
+
@end
@implementation WebView (WebViewDeviceOrientation)
{
#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
JSContextRef context = [[self mainFrame] globalContext];
- WebCore::Notification* notification = toNotification(toJS(toJS(context), jsNotification));
+ WebCore::Notification* notification = JSNotification::toWrapped(toJS(toJS(context), jsNotification));
return static_cast<WebNotificationClient*>(NotificationController::clientFrom(_private->page))->notificationIDForTesting(notification);
#else
return 0;
git://git.webkit.org / WebKit-https.git / blobdiff