Changeset 191315 in webkit


Ignore:
Timestamp:
Oct 19, 2015 1:39:47 PM (9 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r191307.
​https://bugs.webkit.org/show_bug.cgi?id=150338

broke lots of API tests, need time to figure out whats up
(Requested by thorton on #webkit).

Reverted changeset:

"WKView being inside WKWebView leads to weird API issues"
​https://bugs.webkit.org/show_bug.cgi?id=150174
​http://trac.webkit.org/changeset/191307

Location:
trunk/Source
Files:
3 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r191314 r191315  
     12015-10-19  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r191307.
     4        https://bugs.webkit.org/show_bug.cgi?id=150338
     5
     6        broke lots of API tests, need time to figure out whats up
     7        (Requested by thorton on #webkit).
     8
     9        Reverted changeset:
     10
     11        "WKView being inside WKWebView leads to weird API issues"
     12        https://bugs.webkit.org/show_bug.cgi?id=150174
     13        http://trac.webkit.org/changeset/191307
     14
    1152015-10-19  Commit Queue  <commit-queue@webkit.org>
    216

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r191312 r191315  
    11221122                2D0B4AAB18DA1CCD00434DE1 /* IOSurface.h in Headers */ = {isa = PBXBuildFile; fileRef = 2D0B4AA918DA1CCD00434DE1 /* IOSurface.h */; settings = {ATTRIBUTES = (Private, ); }; };
    11231123                2D0B4AAC18DA1CCD00434DE1 /* IOSurface.mm in Sources */ = {isa = PBXBuildFile; fileRef = 2D0B4AAA18DA1CCD00434DE1 /* IOSurface.mm */; };
    1124                 2D0CF8171BCF5DE1007A4937 /* NSWindowSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 2D0CF8161BCF5DE1007A4937 /* NSWindowSPI.h */; settings = {ATTRIBUTES = (Private, ); }; };
    11251124                2D232C001A326F02006BF2DB /* TUCallSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 2D232BFF1A326EF9006BF2DB /* TUCallSPI.h */; settings = {ATTRIBUTES = (Private, ); }; };
    11261125                2D25396218CE7F6200270222 /* ImageControlsButtonElementMac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2D25396018CE7F6200270222 /* ImageControlsButtonElementMac.cpp */; };
    … …  
    84418440                2D0B4AA918DA1CCD00434DE1 /* IOSurface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IOSurface.h; sourceTree = "<group>"; };
    84428441                2D0B4AAA18DA1CCD00434DE1 /* IOSurface.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = IOSurface.mm; sourceTree = "<group>"; };
    8443                 2D0CF8161BCF5DE1007A4937 /* NSWindowSPI.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NSWindowSPI.h; sourceTree = "<group>"; };
    84448442                2D232BFF1A326EF9006BF2DB /* TUCallSPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = TUCallSPI.h; sourceTree = "<group>"; };
    84458443                2D25396018CE7F6200270222 /* ImageControlsButtonElementMac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageControlsButtonElementMac.cpp; sourceTree = "<group>"; };
    … …  
    1854318541                                2DCB837719F99BBA00A7FBE4 /* NSSharingServicePickerSPI.h */,
    1854418542                                2DCB837819F99BBA00A7FBE4 /* NSSharingServiceSPI.h */,
    18545                                 2D0CF8161BCF5DE1007A4937 /* NSWindowSPI.h */,
    1854618543                                937F4CCB1A2D48C100BB39F5 /* QuickLookMacSPI.h */,
    1854718544                                2D232BFF1A326EF9006BF2DB /* TUCallSPI.h */,
    … …  
    2784427841                                93F199F008245E59001E9ABC /* WebCoreView.h in Headers */,
    2784527842                                A5E616741894581F009ADF50 /* WebDebuggerAgent.h in Headers */,
    27846                                 2D0CF8171BCF5DE1007A4937 /* NSWindowSPI.h in Headers */,
    2784727843                                FE0D84E910484348001A179E /* WebEvent.h in Headers */,
    2784827844                                225A16B50D5C11E900090295 /* WebEventRegion.h in Headers */,

  • trunk/Source/WebKit2/ChangeLog

    r191311 r191315  
     12015-10-19  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r191307.
     4        https://bugs.webkit.org/show_bug.cgi?id=150338
     5
     6        broke lots of API tests, need time to figure out whats up
     7        (Requested by thorton on #webkit).
     8
     9        Reverted changeset:
     10
     11        "WKView being inside WKWebView leads to weird API issues"
     12        https://bugs.webkit.org/show_bug.cgi?id=150174
     13        http://trac.webkit.org/changeset/191307
     14
    1152015-10-19  Tim Horton  <timothy_horton@apple.com>
    216

  • trunk/Source/WebKit2/UIProcess/API/mac/WKView.mm

    r191307 r191315  
    6767#import "WKTextInputWindowController.h"
    6868#import "WKViewInternal.h"
     69#import "WKViewLayoutStrategy.h"
    6970#import "WKViewPrivate.h"
    7071#import "WKWebView.h"
    … …  
    8182#import "WebProcessProxy.h"
    8283#import "WebSystemInterface.h"
    83 #import "WebViewImpl.h"
    8484#import "_WKRemoteObjectRegistryInternal.h"
    8585#import "_WKThumbnailViewInternal.h"
    … …  
    131131@end
    132132
     133@interface NSWindow (WKNSWindowDetails)
     134- (id)_newFirstResponderAfterResigning;
     135@end
     136
    133137#if USE(ASYNC_NSTEXTINPUTCLIENT)
    134138@interface NSTextInputContext (WKNSTextInputContextDetails)
    … …  
    178182    std::unique_ptr<PageClientImpl> _pageClient;
    179183    RefPtr<WebPageProxy> _page;
    180     std::unique_ptr<WebViewImpl> _impl;
    181184
    182185#if WK_API_ENABLED
    … …  
    213216#endif
    214217
     218    NSSize _resizeScrollOffset;
     219
    215220    // The identifier of the plug-in we want to send complex text input to, or 0 if there is none.
    216221    uint64_t _pluginComplexTextInputIdentifier;
    … …  
    219224    PluginComplexTextInputState _pluginComplexTextInputState;
    220225
     226    bool _inBecomeFirstResponder;
     227    bool _inResignFirstResponder;
    221228    BOOL _willBecomeFirstResponderAgain;
    222229    NSEvent *_mouseDownEvent;
    … …  
    226233    id _flagsChangedEventMonitor;
    227234
     235#if ENABLE(FULLSCREEN_API)
     236    RetainPtr<WKFullScreenWindowController> _fullScreenWindowController;
     237#endif
     238
    228239    BOOL _hasSpellCheckerDocumentTag;
    229240    NSInteger _spellCheckerDocumentTag;
     241
     242    BOOL _inSecureInputState;
    230243
    231244    BOOL _shouldDeferViewInWindowChanges;
    … …  
    242255    String _promisedFilename;
    243256    String _promisedURL;
    244 
     257   
     258    NSSize _intrinsicContentSize;
     259    BOOL _clipsToVisibleRect;
     260    NSRect _contentPreparationRect;
     261    BOOL _useContentPreparationRectForVisibleRect;
    245262    BOOL _windowOcclusionDetectionEnabled;
    246263
    … …  
    254271    BOOL _allowsLinkPreview;
    255272
     273    RetainPtr<WKViewLayoutStrategy> _layoutStrategy;
     274    WKLayoutMode _lastRequestedLayoutMode;
     275    float _lastRequestedViewScale;
     276
    256277    RetainPtr<CALayer> _rootLayer;
    257278
    … …  
    349370@end
    350371
    351 @interface WKView () <WebViewImplDelegate>
    352 @end
    353 
    354372@implementation WKView
    355373
    … …  
    373391    [_data->_immediateActionController willDestroyView:self];
    374392#endif
    375 
    376     _data->_impl = nullptr;
     393    [_data->_layoutStrategy willDestroyView:self];
    377394
    378395#if WK_API_ENABLED
    … …  
    388405    ASSERT(!_data->_thumbnailView);
    389406#endif
     407    ASSERT(!_data->_inSecureInputState);
    390408
    391409    [_data release];
    … …  
    417435- (void)setDrawsBackground:(BOOL)drawsBackground
    418436{
    419     _data->_impl->setDrawsBackground(drawsBackground);
     437    _data->_page->setDrawsBackground(drawsBackground);
    420438}
    421439
    422440- (BOOL)drawsBackground
    423441{
    424     return _data->_impl->drawsBackground();
     442    return _data->_page->drawsBackground();
    425443}
    426444
    427445- (void)setDrawsTransparentBackground:(BOOL)drawsTransparentBackground
    428446{
    429     _data->_impl->setDrawsTransparentBackground(drawsTransparentBackground);
     447    _data->_page->setDrawsTransparentBackground(drawsTransparentBackground);
    430448}
    431449
    432450- (BOOL)drawsTransparentBackground
    433451{
    434     return _data->_impl->drawsTransparentBackground();
     452    return _data->_page->drawsTransparentBackground();
    435453}
    436454
    437455- (BOOL)acceptsFirstResponder
    438456{
    439     return _data->_impl->acceptsFirstResponder();
     457    return YES;
    440458}
    441459
    442460- (BOOL)becomeFirstResponder
    443461{
    444     return _data->_impl->becomeFirstResponder();
     462    // If we just became first responder again, there is no need to do anything,
     463    // since resignFirstResponder has correctly detected this situation.
     464    if (_data->_willBecomeFirstResponderAgain) {
     465        _data->_willBecomeFirstResponderAgain = NO;
     466        return YES;
     467    }
     468
     469    NSSelectionDirection direction = [[self window] keyViewSelectionDirection];
     470
     471    _data->_inBecomeFirstResponder = true;
     472   
     473    [self _updateSecureInputState];
     474    _data->_page->viewStateDidChange(ViewState::IsFocused);
     475    // Restore the selection in the editable region if resigning first responder cleared selection.
     476    _data->_page->restoreSelectionInFocusedEditableElement();
     477
     478    _data->_inBecomeFirstResponder = false;
     479   
     480    if (direction != NSDirectSelection) {
     481        NSEvent *event = [NSApp currentEvent];
     482        NSEvent *keyboardEvent = nil;
     483        if ([event type] == NSKeyDown || [event type] == NSKeyUp)
     484            keyboardEvent = event;
     485        _data->_page->setInitialFocus(direction == NSSelectingNext, keyboardEvent != nil, NativeWebKeyboardEvent(keyboardEvent, false, Vector<KeypressCommand>()), [](WebKit::CallbackBase::Error) { });
     486    }
     487    return YES;
    445488}
    446489
    447490- (BOOL)resignFirstResponder
    448491{
    449     return _data->_impl->resignFirstResponder();
     492#if WK_API_ENABLED
     493    // Predict the case where we are losing first responder status only to
     494    // gain it back again. We want resignFirstResponder to do nothing in that case.
     495    id nextResponder = [[self window] _newFirstResponderAfterResigning];
     496    if ([nextResponder isKindOfClass:[WKWebView class]] && self.superview == nextResponder) {
     497        _data->_willBecomeFirstResponderAgain = YES;
     498        return YES;
     499    }
     500#endif
     501
     502    _data->_willBecomeFirstResponderAgain = NO;
     503    _data->_inResignFirstResponder = true;
     504
     505#if USE(ASYNC_NSTEXTINPUTCLIENT)
     506    _data->_page->confirmCompositionAsync();
     507#else
     508    if (_data->_page->editorState().hasComposition && !_data->_page->editorState().shouldIgnoreCompositionSelectionChange)
     509        _data->_page->cancelComposition();
     510#endif
     511
     512    [self _notifyInputContextAboutDiscardedComposition];
     513
     514    [self _resetSecureInputState];
     515
     516    if (!_data->_page->maintainsInactiveSelection())
     517        _data->_page->clearSelection();
     518   
     519    _data->_page->viewStateDidChange(ViewState::IsFocused);
     520
     521    _data->_inResignFirstResponder = false;
     522
     523    return YES;
    450524}
    451525
    452526- (void)viewWillStartLiveResize
    453527{
    454     _data->_impl->viewWillStartLiveResize();
     528    _data->_page->viewWillStartLiveResize();
     529
     530    [_data->_layoutStrategy willStartLiveResize];
    455531}
    456532
    457533- (void)viewDidEndLiveResize
    458534{
    459     _data->_impl->viewDidEndLiveResize();
     535    _data->_page->viewWillEndLiveResize();
     536
     537    [_data->_layoutStrategy didEndLiveResize];
    460538}
    461539
    … …  
    467545- (NSSize)intrinsicContentSize
    468546{
    469     return NSSizeFromCGSize(_data->_impl->intrinsicContentSize());
     547    return _data->_intrinsicContentSize;
    470548}
    471549
    472550- (void)prepareContentInRect:(NSRect)rect
    473551{
    474     _data->_impl->setContentPreparationRect(NSRectToCGRect(rect));
    475     _data->_impl->updateViewExposedRect();
     552    _data->_contentPreparationRect = rect;
     553    _data->_useContentPreparationRectForVisibleRect = YES;
     554
     555    [self _updateViewExposedRect];
     556}
     557
     558- (void)_updateViewExposedRect
     559{
     560    NSRect exposedRect = [self visibleRect];
     561
     562    if (_data->_useContentPreparationRectForVisibleRect)
     563        exposedRect = NSUnionRect(_data->_contentPreparationRect, exposedRect);
     564
     565    if (auto drawingArea = _data->_page->drawingArea())
     566        drawingArea->setExposedRect(_data->_clipsToVisibleRect ? FloatRect(exposedRect) : FloatRect::infiniteRect());
    476567}
    477568
    … …  
    479570{
    480571    [super setFrameSize:size];
    481     _data->_impl->setFrameSize(NSSizeToCGSize(size));
     572
     573    [_data->_layoutStrategy didChangeFrameSize];
    482574}
    483575
    484576- (void)_updateWindowAndViewFrames
    485577{
    486     if (_data->_impl->clipsToVisibleRect())
    487         _data->_impl->updateViewExposedRect();
     578    if (_data->_clipsToVisibleRect)
     579        [self _updateViewExposedRect];
    488580
    489581    if (_data->_didScheduleWindowAndViewFrameUpdate)
    … …  
    17381830        text = string;
    17391831
    1740     if (_data->_impl->inSecureInputState()) {
     1832    if (_data->_inSecureInputState) {
    17411833        // In password fields, we only allow ASCII dead keys, and don't allow inline input, matching NSSecureTextInputField.
    17421834        // Allowing ASCII dead keys is necessary to enable full Roman input when using a Vietnamese keyboard.
    17431835        ASSERT(!_data->_page->editorState().hasComposition);
    1744         _data->_impl->notifyInputContextAboutDiscardedComposition();
     1836        [self _notifyInputContextAboutDiscardedComposition];
    17451837        // FIXME: We should store the command to handle it after DOM event processing, as it's regular keyboard input now, not a composition.
    17461838        if ([text length] == 1 && isASCII([text characterAtIndex:0]))
    … …  
    21342226        // Allowing ASCII dead keys is necessary to enable full Roman input when using a Vietnamese keyboard.
    21352227        ASSERT(!_data->_page->editorState().hasComposition);
    2136         _data->_impl->notifyInputContextAboutDiscardedComposition();
     2228        [self _notifyInputContextAboutDiscardedComposition];
    21372229        if ([text length] == 1 && [[text decomposedStringWithCanonicalMapping] characterAtIndex:0] < 0x80) {
    21382230            _data->_page->insertText(text, replacementRange);
    … …  
    23452437
    23462438#endif // USE(ASYNC_NSTEXTINPUTCLIENT)
    2347 
    2348 - (NSTextInputContext *)_superInputContext
    2349 {
    2350     return [super inputContext];
    2351 }
    23522439
    23532440- (NSArray *)validAttributesForMarkedText
    … …  
    26712758    NSWindow *keyWindow = [notification object];
    26722759    if (keyWindow == [self window] || keyWindow == [[self window] attachedSheet]) {
    2673         _data->_impl->updateSecureInputState();
     2760        [self _updateSecureInputState];
    26742761        _data->_page->viewStateDidChange(ViewState::WindowIsActive);
    26752762    }
    … …  
    26902777    NSWindow *formerKeyWindow = [notification object];
    26912778    if (formerKeyWindow == [self window] || formerKeyWindow == [[self window] attachedSheet]) {
    2692         _data->_impl->updateSecureInputState();
     2779        [self _updateSecureInputState];
    26932780        _data->_page->viewStateDidChange(ViewState::WindowIsActive);
    26942781    }
    … …  
    29143001}
    29153002
     3003- (void)_setDrawingAreaSize:(NSSize)size
     3004{
     3005    if (!_data->_page->drawingArea())
     3006        return;
     3007   
     3008    _data->_page->drawingArea()->setSize(IntSize(size), IntSize(0, 0), IntSize(_data->_resizeScrollOffset));
     3009    _data->_resizeScrollOffset = NSZeroSize;
     3010}
     3011
    29163012- (void)quickLookWithEvent:(NSEvent *)event
    29173013{
    … …  
    29363032
    29373033    return std::make_unique<TiledCoreAnimationDrawingAreaProxy>(*_data->_page);
     3034}
     3035
     3036- (BOOL)_isFocused
     3037{
     3038    if (_data->_inBecomeFirstResponder)
     3039        return YES;
     3040    if (_data->_inResignFirstResponder)
     3041        return NO;
     3042    return [[self window] firstResponder] == self;
    29383043}
    29393044
    … …  
    29573062- (void)_processDidExit
    29583063{
    2959     _data->_impl->notifyInputContextAboutDiscardedComposition();
     3064    [self _notifyInputContextAboutDiscardedComposition];
    29603065
    29613066    if (_data->_layerHostingView)
    … …  
    31903295    if (_data->_textIndicatorWindow)
    31913296        _data->_textIndicatorWindow->setAnimationProgress(progress);
     3297}
     3298
     3299- (CALayer *)_rootLayer
     3300{
     3301    return [_data->_layerHostingView layer];
    31923302}
    31933303
    … …  
    35233633}
    35243634
     3635- (void)_updateSecureInputState
     3636{
     3637    if (![[self window] isKeyWindow] || ![self _isFocused]) {
     3638        if (_data->_inSecureInputState) {
     3639            DisableSecureEventInput();
     3640            _data->_inSecureInputState = NO;
     3641        }
     3642        return;
     3643    }
     3644    // WKView has a single input context for all editable areas (except for plug-ins).
     3645    NSTextInputContext *context = [super inputContext];
     3646    bool isInPasswordField = _data->_page->editorState().isInPasswordField;
     3647
     3648    if (isInPasswordField) {
     3649        if (!_data->_inSecureInputState)
     3650            EnableSecureEventInput();
     3651        static NSArray *romanInputSources = [[NSArray alloc] initWithObjects:&NSAllRomanInputSourcesLocaleIdentifier count:1];
     3652        LOG(TextInput, "-> setAllowedInputSourceLocales:romanInputSources");
     3653        [context setAllowedInputSourceLocales:romanInputSources];
     3654    } else {
     3655        if (_data->_inSecureInputState)
     3656            DisableSecureEventInput();
     3657        LOG(TextInput, "-> setAllowedInputSourceLocales:nil");
     3658        [context setAllowedInputSourceLocales:nil];
     3659    }
     3660    _data->_inSecureInputState = isInPasswordField;
     3661}
     3662
     3663- (void)_resetSecureInputState
     3664{
     3665    if (_data->_inSecureInputState) {
     3666        DisableSecureEventInput();
     3667        _data->_inSecureInputState = NO;
     3668    }
     3669}
     3670
     3671- (void)_notifyInputContextAboutDiscardedComposition
     3672{
     3673    // <rdar://problem/9359055>: -discardMarkedText can only be called for active contexts.
     3674    // FIXME: We fail to ever notify the input context if something (e.g. a navigation) happens while the window is not key.
     3675    // This is not a problem when the window is key, because we discard marked text on resigning first responder.
     3676    if (![[self window] isKeyWindow] || self != [[self window] firstResponder])
     3677        return;
     3678
     3679    LOG(TextInput, "-> discardMarkedText");
     3680    [[super inputContext] discardMarkedText]; // Inform the input method that we won't have an inline input area despite having been asked to.
     3681}
    35253682
    35263683- (NSWindow *)_targetWindowForMovePreparation
    … …  
    35323689- (BOOL)_hasFullScreenWindowController
    35333690{
    3534     return _data->_impl->hasFullScreenWindowController();
     3691    return (bool)_data->_fullScreenWindowController;
    35353692}
    35363693
    35373694- (WKFullScreenWindowController *)_fullScreenWindowController
    35383695{
    3539     return _data->_impl->fullScreenWindowController();
     3696    if (!_data->_fullScreenWindowController)
     3697        _data->_fullScreenWindowController = adoptNS([[WKFullScreenWindowController alloc] initWithWindow:[self createFullScreenWindow] webView:self]);
     3698
     3699    return _data->_fullScreenWindowController.get();
    35403700}
    35413701
    35423702- (void)_closeFullScreenWindowController
    35433703{
    3544     _data->_impl->closeFullScreenWindowController();
     3704    if (!_data->_fullScreenWindowController)
     3705        return;
     3706
     3707    [_data->_fullScreenWindowController close];
     3708    _data->_fullScreenWindowController = nullptr;
    35453709}
    35463710#endif
    … …  
    35593723- (void)_setIntrinsicContentSize:(NSSize)intrinsicContentSize
    35603724{
    3561     _data->_impl->setIntrinsicContentSize(NSSizeToCGSize(intrinsicContentSize));
     3725    // If the intrinsic content size is less than the minimum layout width, the content flowed to fit,
     3726    // so we can report that that dimension is flexible. If not, we need to report our intrinsic width
     3727    // so that autolayout will know to provide space for us.
     3728
     3729    NSSize intrinsicContentSizeAcknowledgingFlexibleWidth = intrinsicContentSize;
     3730    if (intrinsicContentSize.width < _data->_page->minimumLayoutSize().width())
     3731        intrinsicContentSizeAcknowledgingFlexibleWidth.width = NSViewNoInstrinsicMetric;
     3732
     3733    _data->_intrinsicContentSize = intrinsicContentSizeAcknowledgingFlexibleWidth;
     3734    [self invalidateIntrinsicContentSize];
    35623735}
    35633736
    … …  
    36213794    _data->_pageClient = std::make_unique<PageClientImpl>(self, webView);
    36223795    _data->_page = processPool.createWebPage(*_data->_pageClient, WTF::move(configuration));
    3623 
    3624     _data->_impl = std::make_unique<WebViewImpl>(self, *_data->_page);
    3625     static_cast<PageClientImpl*>(_data->_pageClient.get())->setImpl(*_data->_impl);
    3626 
    36273796    _data->_page->setAddsVisitedLinks(processPool.historyClient().addsVisitedLinks());
    36283797
    … …  
    36333802    _data->_pressureEvent = nil;
    36343803    _data->_ignoringMouseDraggedEvents = NO;
     3804    _data->_clipsToVisibleRect = NO;
     3805    _data->_useContentPreparationRectForVisibleRect = NO;
    36353806    _data->_windowOcclusionDetectionEnabled = YES;
     3807    _data->_lastRequestedLayoutMode = kWKLayoutModeViewSize;
     3808    _data->_lastRequestedViewScale = 1;
    36363809
    36373810    _data->_windowVisibilityObserver = adoptNS([[WKWindowVisibilityObserver alloc] initWithView:self]);
    36383811
     3812    _data->_intrinsicContentSize = NSMakeSize(NSViewNoInstrinsicMetric, NSViewNoInstrinsicMetric);
     3813
    36393814    _data->_needsViewFrameInWindowCoordinates = _data->_page->preferences().pluginsEnabled();
     3815
     3816    _data->_layoutStrategy = [WKViewLayoutStrategy layoutStrategyWithPage:*_data->_page view:self mode:kWKLayoutModeViewSize];
    36403817
    36413818    [self _registerDraggedTypes];
    … …  
    37483925}
    37493926
     3927- (BOOL)_supportsArbitraryLayoutModes
     3928{
     3929    if ([_data->_fullScreenWindowController isFullScreen])
     3930        return NO;
     3931
     3932    WebPageProxy* page = _data->_page.get();
     3933    if (!page)
     3934        return YES;
     3935    WebFrameProxy* frame = page->mainFrame();
     3936    if (!frame)
     3937        return YES;
     3938
     3939    // If we have a plugin document in the main frame, avoid using custom WKLayoutModes
     3940    // and fall back to the defaults, because there's a good chance that it won't work (e.g. with PDFPlugin).
     3941    if (frame->containsPluginDocument())
     3942        return NO;
     3943
     3944    return YES;
     3945}
     3946
     3947- (void)_updateSupportsArbitraryLayoutModes
     3948{
     3949    if (![self _supportsArbitraryLayoutModes]) {
     3950        WKLayoutMode oldRequestedLayoutMode = _data->_lastRequestedLayoutMode;
     3951        float oldRequestedViewScale = _data->_lastRequestedViewScale;
     3952        [self _setViewScale:1];
     3953        [self _setLayoutMode:kWKLayoutModeViewSize];
     3954
     3955        // The 'last requested' parameters will have been overwritten by setting them above, but we don't
     3956        // want this to count as a request (only changes from the client count), so reset them.
     3957        _data->_lastRequestedLayoutMode = oldRequestedLayoutMode;
     3958        _data->_lastRequestedViewScale = oldRequestedViewScale;
     3959    } else if (_data->_lastRequestedLayoutMode != [_data->_layoutStrategy layoutMode]) {
     3960        [self _setViewScale:_data->_lastRequestedViewScale];
     3961        [self _setLayoutMode:_data->_lastRequestedLayoutMode];
     3962    }
     3963}
     3964
    37503965#if WK_API_ENABLED
    37513966- (_WKRemoteObjectRegistry *)_remoteObjectRegistry
    … …  
    37583973    return _data->_remoteObjectRegistry.get();
    37593974}
    3760 #endif
     3975
     3976#endif
     3977
     3978
     3979- (void)_didCommitLoadForMainFrame
     3980{
     3981    [self _updateSupportsArbitraryLayoutModes];
     3982}
    37613983
    37623984- (void)_didFinishLoadForMainFrame
    … …  
    37994021}
    38004022#endif
    3801 
    3802 // FIXME: Get rid of this when we have better plumbing to WKViewLayoutStrategy.
    3803 - (void)_updateViewExposedRect
    3804 {
    3805     _data->_impl->updateViewExposedRect();
    3806 }
    38074023
    38084024@end
    … …  
    38934109- (void)setFrame:(NSRect)rect andScrollBy:(NSSize)offset
    38944110{
    3895     _data->_impl->setFrameAndScrollBy(NSRectToCGRect(rect), NSSizeToCGSize(offset));
     4111    ASSERT(NSEqualSizes(_data->_resizeScrollOffset, NSZeroSize));
     4112
     4113    _data->_resizeScrollOffset = offset;
     4114    [self setFrame:rect];
    38964115}
    38974116
    38984117- (void)disableFrameSizeUpdates
    38994118{
    3900     _data->_impl->disableFrameSizeUpdates();
     4119    [_data->_layoutStrategy disableFrameSizeUpdates];
    39014120}
    39024121
    39034122- (void)enableFrameSizeUpdates
    39044123{
    3905     _data->_impl->enableFrameSizeUpdates();
     4124    [_data->_layoutStrategy enableFrameSizeUpdates];
    39064125}
    39074126
    39084127- (BOOL)frameSizeUpdatesDisabled
    39094128{
    3910     return _data->_impl->frameSizeUpdatesDisabled();
     4129    return [_data->_layoutStrategy frameSizeUpdatesDisabled];
    39114130}
    39124131
    … …  
    39434162- (BOOL)shouldClipToVisibleRect
    39444163{
    3945     return _data->_impl->clipsToVisibleRect();
     4164    return _data->_clipsToVisibleRect;
    39464165}
    39474166
    39484167- (void)setShouldClipToVisibleRect:(BOOL)clipsToVisibleRect
    39494168{
    3950     _data->_impl->setClipsToVisibleRect(clipsToVisibleRect);
     4169    _data->_clipsToVisibleRect = clipsToVisibleRect;
     4170    [self _updateViewExposedRect];
    39514171}
    39524172
    … …  
    39854205- (NSView *)fullScreenPlaceholderView
    39864206{
    3987     return _data->_impl->fullScreenPlaceholderView();
    3988 }
    3989 
    3990 // FIXME: This returns an autoreleased object. Should it really be prefixed 'create'?
     4207#if ENABLE(FULLSCREEN_API)
     4208    if (_data->_fullScreenWindowController && [_data->_fullScreenWindowController isFullScreen])
     4209        return [_data->_fullScreenWindowController webViewPlaceholder];
     4210#endif
     4211    return nil;
     4212}
     4213
    39914214- (NSWindow *)createFullScreenWindow
    39924215{
    3993     return _data->_impl->createFullScreenWindow();
     4216#if ENABLE(FULLSCREEN_API)
     4217    return [[[WebCoreFullScreenWindow alloc] initWithContentRect:[[NSScreen mainScreen] frame] styleMask:(NSBorderlessWindowMask | NSResizableWindowMask) backing:NSBackingStoreBuffered defer:NO] autorelease];
     4218#else
     4219    return nil;
     4220#endif
    39944221}
    39954222
    … …  
    41574384- (WKLayoutMode)_layoutMode
    41584385{
    4159     return _data->_impl->layoutMode();
     4386    return [_data->_layoutStrategy layoutMode];
    41604387}
    41614388
    41624389- (void)_setLayoutMode:(WKLayoutMode)layoutMode
    41634390{
    4164     _data->_impl->setLayoutMode(layoutMode);
     4391    _data->_lastRequestedLayoutMode = layoutMode;
     4392
     4393    if (![self _supportsArbitraryLayoutModes] && layoutMode != kWKLayoutModeViewSize)
     4394        return;
     4395
     4396    if (layoutMode == [_data->_layoutStrategy layoutMode])
     4397        return;
     4398
     4399    [_data->_layoutStrategy willChangeLayoutStrategy];
     4400    _data->_layoutStrategy = [WKViewLayoutStrategy layoutStrategyWithPage:*_data->_page view:self mode:layoutMode];
    41654401}
    41664402
    41674403- (CGSize)_fixedLayoutSize
    41684404{
    4169     return _data->_impl->fixedLayoutSize();
     4405    return _data->_page->fixedLayoutSize();
    41704406}
    41714407
    41724408- (void)_setFixedLayoutSize:(CGSize)fixedLayoutSize
    41734409{
    4174     _data->_impl->setFixedLayoutSize(fixedLayoutSize);
     4410    _data->_page->setFixedLayoutSize(expandedIntSize(FloatSize(fixedLayoutSize)));
    41754411}
    41764412
    41774413- (CGFloat)_viewScale
    41784414{
    4179     return _data->_impl->viewScale();
     4415    return _data->_page->viewScaleFactor();
    41804416}
    41814417
    41824418- (void)_setViewScale:(CGFloat)viewScale
    41834419{
    4184     _data->_impl->setViewScale(viewScale);
     4420    _data->_lastRequestedViewScale = viewScale;
     4421
     4422    if (![self _supportsArbitraryLayoutModes] && viewScale != 1)
     4423        return;
     4424
     4425    if (viewScale <= 0 || isnan(viewScale) || isinf(viewScale))
     4426        [NSException raise:NSInvalidArgumentException format:@"View scale should be a positive number"];
     4427
     4428    _data->_page->scaleView(viewScale);
     4429    [_data->_layoutStrategy didChangeViewScale];
    41854430}
    41864431
    … …  
    42834528    // This SPI is only used on 10.9 and below, and is incompatible with the fence-based drawing area size synchronization in 10.10+.
    42844529#if __MAC_OS_X_VERSION_MIN_REQUIRED <= 1090
    4285     if (_data->_impl->clipsToVisibleRect())
    4286         _data->_impl->updateViewExposedRect();
    4287     _data->_impl->setDrawingAreaSize(NSSizeToCGSize(size));
     4530    if (_data->_clipsToVisibleRect)
     4531        [self _updateViewExposedRect];
     4532    [self _setDrawingAreaSize:size];
    42884533
    42894534    // If a geometry update is pending the new update won't be sent. Poll without waiting for any

  • trunk/Source/WebKit2/UIProcess/API/mac/WKViewInternal.h

    r191307 r191315  
    7878
    7979- (std::unique_ptr<WebKit::DrawingAreaProxy>)_createDrawingAreaProxy;
     80- (BOOL)_isFocused;
    8081- (void)_processDidExit;
    8182- (void)_pageClosed;
    … …  
    110111- (void)_setPromisedDataForAttachment:(NSString *)filename withExtension:(NSString *)extension withTitle:(NSString *)title withURL:(NSString *)url withVisibleURL:(NSString *)visibleUrl forPasteboard:(NSString *)pasteboardName;
    111112#endif
     113- (void)_updateSecureInputState;
     114- (void)_resetSecureInputState;
     115- (void)_notifyInputContextAboutDiscardedComposition;
    112116
    113117- (WebKit::ColorSpaceData)_colorSpace;
    … …  
    120124
    121125- (void)_didFirstVisuallyNonEmptyLayoutForMainFrame;
     126- (void)_didCommitLoadForMainFrame;
    122127- (void)_didFinishLoadForMainFrame;
    123128- (void)_didFailLoadForMainFrame;
    … …  
    154159@property (readonly) NSWindow *_targetWindowForMovePreparation;
    155160
     161// For WKViewLayoutStrategy and subclasses:
     162- (void)_setDrawingAreaSize:(NSSize)size;
     163- (void)_updateViewExposedRect;
     164- (CALayer *)_rootLayer;
     165
     166- (void)_updateSupportsArbitraryLayoutModes;
     167
    156168#if WK_API_ENABLED
    157169@property (nonatomic, readonly) _WKRemoteObjectRegistry *_remoteObjectRegistry;

  • trunk/Source/WebKit2/UIProcess/mac/PageClientImpl.h

    r191307 r191315  
    4444namespace WebKit {
    4545
    46 class WebViewImpl;
    47 
    4846class PageClientImpl final : public PageClient
    4947#if ENABLE(FULLSCREEN_API)
    … …  
    5452    PageClientImpl(WKView *, WKWebView *);
    5553    virtual ~PageClientImpl();
    56 
    57     // FIXME: Eventually WebViewImpl should become the PageClient.
    58     void setImpl(WebViewImpl& impl) { m_impl = &impl; }
    59 
     54   
    6055    void viewWillMoveToAnotherWindow();
    6156
    … …  
    219214    WKView *m_wkView;
    220215    WKWebView *m_webView;
    221     WebViewImpl* m_impl { nullptr };
    222216    RetainPtr<WKEditorUndoTargetObjC> m_undoTarget;
    223217#if USE(AUTOCORRECTION_PANEL)

  • trunk/Source/WebKit2/UIProcess/mac/PageClientImpl.mm

    r191307 r191315  
    4848#import "WebEditCommandProxy.h"
    4949#import "WebPopupMenuProxyMac.h"
    50 #import "WebViewImpl.h"
    5150#import "WindowServerConnection.h"
    5251#import "_WKDownloadInternal.h"
    … …  
    221220bool PageClientImpl::isViewFocused()
    222221{
    223     // FIXME: This is called from the WebPageProxy constructor before we have a WebViewImpl.
    224     // Once WebViewImpl and PageClient merge, this won't be a problem.
    225     if (!m_impl)
    226         return NO;
    227 
    228     return m_impl->isFocused();
     222    return [m_wkView _isFocused];
    229223}
    230224
    … …  
    318312void PageClientImpl::didCommitLoadForMainFrame(const String& mimeType, bool useCustomContentProvider)
    319313{
    320     m_impl->updateSupportsArbitraryLayoutModes();
     314    [m_wkView _didCommitLoadForMainFrame];
    321315}
    322316
    … …  
    440434void PageClientImpl::updateSecureInputState()
    441435{
    442     m_impl->updateSecureInputState();
     436    [m_wkView _updateSecureInputState];
    443437}
    444438
    445439void PageClientImpl::resetSecureInputState()
    446440{
    447     m_impl->resetSecureInputState();
     441    [m_wkView _resetSecureInputState];
    448442}
    449443
    450444void PageClientImpl::notifyInputContextAboutDiscardedComposition()
    451445{
    452     m_impl->notifyInputContextAboutDiscardedComposition();
     446    [m_wkView _notifyInputContextAboutDiscardedComposition];
    453447}
    454448
    … …  
    730724{
    731725    [m_wkView._fullScreenWindowController beganEnterFullScreenWithInitialFrame:initialFrame finalFrame:finalFrame];
    732     m_impl->updateSupportsArbitraryLayoutModes();
     726    [m_wkView _updateSupportsArbitraryLayoutModes];
    733727}
    734728
    … …  
    736730{
    737731    [m_wkView._fullScreenWindowController beganExitFullScreenWithInitialFrame:initialFrame finalFrame:finalFrame];
    738     m_impl->updateSupportsArbitraryLayoutModes();
     732    [m_wkView _updateSupportsArbitraryLayoutModes];
    739733}
    740734

  • trunk/Source/WebKit2/UIProcess/mac/WKFullScreenWindowController.h

    r191307 r191315  
    3131namespace WebKit {
    3232class LayerTreeContext;
    33 class WebPageProxy;
    3433}
    3534
    … …  
    4645@interface WKFullScreenWindowController : NSWindowController<NSWindowDelegate> {
    4746@private
    48     NSView *_webView; // Cannot be retained, see <rdar://problem/14884666>.
    49     WebKit::WebPageProxy* _page;
     47    WKView *_webView; // Cannot be retained, see <rdar://problem/14884666>.
    5048    RetainPtr<WebCoreFullScreenPlaceholderView> _webViewPlaceholder;
    5149    RetainPtr<NSView> _clipView;
    … …  
    6361@property (readonly) NSRect finalFrame;
    6462
    65 - (id)initWithWindow:(NSWindow *)window webView:(NSView *)webView page:(WebKit::WebPageProxy&)page;
     63- (id)initWithWindow:(NSWindow *)window webView:(WKView *)webView;
    6664
    6765- (WebCoreFullScreenPlaceholderView*)webViewPlaceholder;

  • trunk/Source/WebKit2/UIProcess/mac/WKFullScreenWindowController.mm

    r191307 r191315  
    6464@end
    6565
    66 @interface WKFullScreenWindowController (Private) <NSAnimationDelegate>
     66@interface WKFullScreenWindowController(Private)<NSAnimationDelegate>
    6767- (void)_replaceView:(NSView*)view with:(NSView*)otherView;
     68- (WebPageProxy*)_page;
    6869- (WebFullScreenManagerProxy*)_manager;
    6970- (void)_startEnterFullScreenAnimationWithDuration:(NSTimeInterval)duration;
    … …  
    8687#pragma mark -
    8788#pragma mark Initialization
    88 - (id)initWithWindow:(NSWindow *)window webView:(NSView *)webView page:(WebPageProxy&)page
     89- (id)initWithWindow:(NSWindow *)window webView:(WKView *)webView
    8990{
    9091    self = [super initWithWindow:window];
    … …  
    106107    [self windowDidLoad];
    107108    _webView = webView;
    108     _page = &page;
    109109   
    110110    return self;
    … …  
    242242    // https://bugs.webkit.org/show_bug.cgi?id=88940 and https://bugs.webkit.org/show_bug.cgi?id=88374
    243243    // We will resume the normal behavior in _startEnterFullScreenAnimationWithDuration:
    244     _page->setSuppressVisibilityUpdates(true);
     244    [_webView _setSuppressVisibilityUpdates:YES];
    245245
    246246    // Swap the webView placeholder into place.
    … …  
    254254   
    255255    // Then insert the WebView into the full screen window
    256     NSView *contentView = [[self window] contentView];
     256    NSView* contentView = [[self window] contentView];
    257257    [_clipView addSubview:_webView positioned:NSWindowBelow relativeTo:nil];
    258258    [_webView setFrame:[contentView bounds]];
    … …  
    260260    makeResponderFirstResponderIfDescendantOfView(self.window, webWindowFirstResponder, _webView);
    261261
    262     _savedScale = _page->pageScaleFactor();
    263     _page->scalePage(1, IntPoint());
     262    _savedScale = [self _page]->pageScaleFactor();
     263    [self _page]->scalePage(1, IntPoint());
    264264    [self _manager]->setAnimatingFullScreen(true);
    265265    [self _manager]->willEnterFullScreen();
    … …  
    310310
    311311        [[self window] setAutodisplay:YES];
    312         _page->setSuppressVisibilityUpdates(false);
     312        [_webView _setSuppressVisibilityUpdates:NO];
    313313
    314314        NSResponder *firstResponder = [[self window] firstResponder];
    … …  
    317317        [[_webView window] makeKeyAndOrderFront:self];
    318318
    319         _page->scalePage(_savedScale, IntPoint());
     319        [self _page]->scalePage(_savedScale, IntPoint());
    320320        [self _manager]->restoreScrollPosition();
    321321        [self _manager]->didExitFullScreen();
    … …  
    345345    // See the related comment in enterFullScreen:
    346346    // We will resume the normal behavior in _startExitFullScreenAnimationWithDuration:
    347     _page->setSuppressVisibilityUpdates(true);
     347    [_webView _setSuppressVisibilityUpdates:YES];
    348348    [_webViewPlaceholder setTarget:nil];
    349349
    … …  
    380380    // Screen updates to be re-enabled in completeFinishExitFullScreenAnimationAfterRepaint.
    381381    NSDisableScreenUpdates();
    382     _page->setSuppressVisibilityUpdates(true);
     382    [_webView _setSuppressVisibilityUpdates:YES];
    383383    [[self window] orderOut:self];
    384384    NSView *contentView = [[self window] contentView];
    … …  
    395395    [self _manager]->didExitFullScreen();
    396396    [self _manager]->setAnimatingFullScreen(false);
    397     _page->scalePage(_savedScale, IntPoint());
     397    [self _page]->scalePage(_savedScale, IntPoint());
    398398    [self _manager]->restoreScrollPosition();
    399399
    … …  
    407407        [self completeFinishExitFullScreenAnimationAfterRepaint];
    408408    });
    409     _page->forceRepaint(_repaintCallback);
     409    [self _page]->forceRepaint(_repaintCallback);
    410410}
    411411
    … …  
    415415    [[_webView window] setAutodisplay:YES];
    416416    [[_webView window] displayIfNeeded];
    417     _page->setSuppressVisibilityUpdates(false);
     417    [_webView _setSuppressVisibilityUpdates:NO];
    418418    NSEnableScreenUpdates();
    419419}
    … …  
    488488#pragma mark Internal Interface
    489489
     490- (WebPageProxy*)_page
     491{
     492    return toImpl([_webView pageRef]);
     493}
     494
    490495- (WebFullScreenManagerProxy*)_manager
    491496{
    492     if (!_page)
    493         return nullptr;
    494     return _page->fullScreenManager();
     497    WebPageProxy* webPage = [self _page];
     498    if (!webPage)
     499        return 0;
     500    return webPage->fullScreenManager();
    495501}
    496502
    … …  
    599605    [window setCollectionBehavior:behavior];
    600606
    601     _page->setSuppressVisibilityUpdates(false);
     607    [_webView _setSuppressVisibilityUpdates:NO];
    602608    [[self window] setAutodisplay:YES];
    603609    [[self window] displayIfNeeded];
    … …  
    622628    [contentView.layer addAnimation:fadeAnimation(duration, AnimateOut) forKey:@"fullscreen"];
    623629
    624     _page->setSuppressVisibilityUpdates(false);
     630    [_webView _setSuppressVisibilityUpdates:NO];
    625631    [[self window] setAutodisplay:YES];
    626632    [[self window] displayIfNeeded];

  • trunk/Source/WebKit2/UIProcess/mac/WKViewLayoutStrategy.h

    r191307 r191315  
    3333namespace WebKit {
    3434class WebPageProxy;
    35 class WebViewImpl;
    3635}
    3736
    38 @class NSView;
     37@class WKView;
    3938
    4039@interface WKViewLayoutStrategy : NSObject {
    4140@package
    42     WebKit::WebPageProxy* _page;
    43     WebKit::WebViewImpl* _webViewImpl;
    44     NSView *_view;
     41    WebKit::WebPageProxy *_page;
     42    WKView *_wkView;
    4543
    4644    WKLayoutMode _layoutMode;
    … …  
    4846}
    4947
    50 + (instancetype)layoutStrategyWithPage:(WebKit::WebPageProxy&)page view:(NSView *)view viewImpl:(WebKit::WebViewImpl&)webViewImpl mode:(WKLayoutMode)mode;
     48+ (instancetype)layoutStrategyWithPage:(WebKit::WebPageProxy&)page view:(WKView *)wkView mode:(WKLayoutMode)mode;
    5149
    52 - (void)invalidate;
     50- (void)willDestroyView:(WKView *)view;
    5351
    5452- (void)enableFrameSizeUpdates;

  • trunk/Source/WebKit2/UIProcess/mac/WKViewLayoutStrategy.mm

    r191307 r191315  
    2929#if PLATFORM(MAC)
    3030
     31#import "WKViewInternal.h"
    3132#import "WebPageProxy.h"
    32 #import "WebViewImpl.h"
    3333#import <WebCore/MachSendRight.h>
    3434#import <WebCore/QuartzCoreSPI.h>
    … …  
    5151@implementation WKViewLayoutStrategy
    5252
    53 + (instancetype)layoutStrategyWithPage:(WebPageProxy&)page view:(NSView *)view viewImpl:(WebViewImpl&)webViewImpl mode:(WKLayoutMode)mode
     53+ (instancetype)layoutStrategyWithPage:(WebPageProxy&)page view:(WKView *)wkView mode:(WKLayoutMode)mode
    5454{
    5555    WKViewLayoutStrategy *strategy;
    … …  
    5757    switch (mode) {
    5858    case kWKLayoutModeFixedSize:
    59         strategy = [[WKViewFixedSizeLayoutStrategy alloc] initWithPage:page view:view viewImpl:webViewImpl mode:mode];
     59        strategy = [[WKViewFixedSizeLayoutStrategy alloc] initWithPage:page view:wkView mode:mode];
    6060        break;
    6161    case kWKLayoutModeDynamicSizeComputedFromViewScale:
    62         strategy = [[WKViewDynamicSizeComputedFromViewScaleLayoutStrategy alloc] initWithPage:page view:view viewImpl:webViewImpl mode:mode];
     62        strategy = [[WKViewDynamicSizeComputedFromViewScaleLayoutStrategy alloc] initWithPage:page view:wkView mode:mode];
    6363        break;
    6464    case kWKLayoutModeDynamicSizeComputedFromMinimumDocumentSize:
    65         strategy = [[WKViewDynamicSizeComputedFromMinimumDocumentSizeLayoutStrategy alloc] initWithPage:page view:view viewImpl:webViewImpl mode:mode];
     65        strategy = [[WKViewDynamicSizeComputedFromMinimumDocumentSizeLayoutStrategy alloc] initWithPage:page view:wkView mode:mode];
    6666        break;
    6767    case kWKLayoutModeViewSize:
    6868    default:
    69         strategy = [[WKViewViewSizeLayoutStrategy alloc] initWithPage:page view:view viewImpl:webViewImpl mode:mode];
     69        strategy = [[WKViewViewSizeLayoutStrategy alloc] initWithPage:page view:wkView mode:mode];
    7070        break;
    7171    }
    … …  
    7676}
    7777
    78 - (instancetype)initWithPage:(WebPageProxy&)page view:(NSView *)view viewImpl:(WebViewImpl&)webViewImpl mode:(WKLayoutMode)mode
     78- (instancetype)initWithPage:(WebPageProxy&)page view:(WKView *)wkView mode:(WKLayoutMode)mode
    7979{
    8080    self = [super init];
    … …  
    8484
    8585    _page = &page;
    86     _webViewImpl = &webViewImpl;
    87     _view = view;
     86    _wkView = wkView;
    8887    _layoutMode = mode;
    8988
    … …  
    9190}
    9291
    93 - (void)invalidate
     92- (void)willDestroyView:(WKView *)view
    9493{
    9594    _page = nullptr;
    96     _webViewImpl = nullptr;
    97     _view = nil;
     95    _wkView = nil;
    9896}
    9997
    … …  
    143141        return;
    144142
    145     if (_webViewImpl->clipsToVisibleRect())
    146         _webViewImpl->updateViewExposedRect();
    147     _webViewImpl->setDrawingAreaSize(NSSizeToCGSize(_view.frame.size));
     143    if (_wkView.shouldClipToVisibleRect)
     144        [_wkView _updateViewExposedRect];
     145    [_wkView _setDrawingAreaSize:_wkView.frame.size];
    148146}
    149147
    … …  
    156154@implementation WKViewViewSizeLayoutStrategy
    157155
    158 - (instancetype)initWithPage:(WebPageProxy&)page view:(NSView *)view viewImpl:(WebViewImpl&)webViewImpl mode:(WKLayoutMode)mode
    159 {
    160     self = [super initWithPage:page view:view viewImpl:webViewImpl mode:mode];
     156- (instancetype)initWithPage:(WebPageProxy&)page view:(WKView *)wkView mode:(WKLayoutMode)mode
     157{
     158    self = [super initWithPage:page view:wkView mode:mode];
    161159
    162160    if (!self)
    … …  
    176174@implementation WKViewFixedSizeLayoutStrategy
    177175
    178 - (instancetype)initWithPage:(WebPageProxy&)page view:(NSView *)view viewImpl:(WebViewImpl&)webViewImpl mode:(WKLayoutMode)mode
    179 {
    180     self = [super initWithPage:page view:view viewImpl:webViewImpl mode:mode];
     176- (instancetype)initWithPage:(WebPageProxy&)page view:(WKView *)wkView mode:(WKLayoutMode)mode
     177{
     178    self = [super initWithPage:page view:wkView mode:mode];
    181179
    182180    if (!self)
    … …  
    196194@implementation WKViewDynamicSizeComputedFromViewScaleLayoutStrategy
    197195
    198 - (instancetype)initWithPage:(WebPageProxy&)page view:(NSView *)view viewImpl:(WebViewImpl&)webViewImpl mode:(WKLayoutMode)mode
    199 {
    200     self = [super initWithPage:page view:view viewImpl:webViewImpl mode:mode];
     196- (instancetype)initWithPage:(WebPageProxy&)page view:(WKView *)wkView mode:(WKLayoutMode)mode
     197{
     198    self = [super initWithPage:page view:wkView mode:mode];
    201199
    202200    if (!self)
    … …  
    211209{
    212210    CGFloat inverseScale = 1 / _page->viewScaleFactor();
    213     _webViewImpl->setFixedLayoutSize(CGSizeMake(_view.frame.size.width * inverseScale, _view.frame.size.height * inverseScale));
     211    [_wkView _setFixedLayoutSize:CGSizeMake(_wkView.frame.size.width * inverseScale, _wkView.frame.size.height * inverseScale)];
    214212}
    215213
    … …  
    225223    [super didChangeFrameSize];
    226224
    227     if (self.frameSizeUpdatesDisabled)
     225    if ([_wkView frameSizeUpdatesDisabled])
    228226        return;
    229227
    … …  
    235233@implementation WKViewDynamicSizeComputedFromMinimumDocumentSizeLayoutStrategy
    236234
    237 - (instancetype)initWithPage:(WebPageProxy&)page view:(NSView *)view viewImpl:(WebViewImpl&)webViewImpl mode:(WKLayoutMode)mode
    238 {
    239     self = [super initWithPage:page view:view viewImpl:webViewImpl mode:mode];
     235- (instancetype)initWithPage:(WebPageProxy&)page view:(WKView *)wkView mode:(WKLayoutMode)mode
     236{
     237    self = [super initWithPage:page view:wkView mode:mode];
    240238
    241239    if (!self)

  • trunk/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj

    r191307 r191315  
    697697                2E0B8A7A1BC59A590044B32D /* _WKFormDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = 2E0B8A791BC59A590044B32D /* _WKFormDelegate.h */; settings = {ATTRIBUTES = (Private, ); }; };
    698698                2E7A944A1BBD97C300945547 /* _WKFocusedElementInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 2E7A94491BBD95C600945547 /* _WKFocusedElementInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
    699                 2DFC7DBB1BCCC19500C1548C /* WebViewImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = 2DFC7DB91BCCC19500C1548C /* WebViewImpl.h */; settings = {ASSET_TAGS = (); }; };
    700                 2DFC7DBC1BCCC19500C1548C /* WebViewImpl.mm in Sources */ = {isa = PBXBuildFile; fileRef = 2DFC7DBA1BCCC19500C1548C /* WebViewImpl.mm */; settings = {ASSET_TAGS = (); }; };
    701699                31099973146C75A20029DEB9 /* WebNotificationClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 31099971146C759B0029DEB9 /* WebNotificationClient.cpp */; };
    702700                310999C7146C9E3D0029DEB9 /* WebNotificationClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 31099968146C71F50029DEB9 /* WebNotificationClient.h */; };
    … …  
    28632861                2E0B8A791BC59A590044B32D /* _WKFormDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _WKFormDelegate.h; sourceTree = "<group>"; };
    28642862                2E7A94491BBD95C600945547 /* _WKFocusedElementInfo.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = _WKFocusedElementInfo.h; sourceTree = "<group>"; };
    2865                 2DFC7DB91BCCC19500C1548C /* WebViewImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebViewImpl.h; sourceTree = "<group>"; };
    2866                 2DFC7DBA1BCCC19500C1548C /* WebViewImpl.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebViewImpl.mm; sourceTree = "<group>"; };
    28672863                31099968146C71F50029DEB9 /* WebNotificationClient.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebNotificationClient.h; sourceTree = "<group>"; };
    28682864                31099971146C759B0029DEB9 /* WebNotificationClient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebNotificationClient.cpp; sourceTree = "<group>"; };
    … …  
    49464942                                7CE4D2151A49148400C7F152 /* WebProcessPoolCocoa.mm */,
    49474943                                1A04F6171A4A3A7A00A21B6E /* WebProcessProxyCocoa.mm */,
    4948                                 2DFC7DB91BCCC19500C1548C /* WebViewImpl.h */,
    4949                                 2DFC7DBA1BCCC19500C1548C /* WebViewImpl.mm */,
    49504944                                1AD01BCB1905D54900C9C45F /* WKReloadFrameErrorRecoveryAttempter.h */,
    49514945                                1AD01BCA1905D54900C9C45F /* WKReloadFrameErrorRecoveryAttempter.mm */,
    … …  
    76727666                                BC82837A16B36A4F00A278FE /* ChildProcessEntryPoint.h in Headers */,
    76737667                                51FAEC3A1B0657630009C4E7 /* ChildProcessMessages.h in Headers */,
    7674                                 2DFC7DBB1BCCC19500C1548C /* WebViewImpl.h in Headers */,
    76757668                                E1513C67166EABB200149FCB /* ChildProcessProxy.h in Headers */,
    76767669                                290F4272172A0C7400939FF0 /* ChildProcessSupplement.h in Headers */,
    … …  
    98139806                                BC111A5B112F4FBB00337BAB /* WebContextMenuClient.cpp in Sources */,
    98149807                                51021E9C12B16788005C033C /* WebContextMenuClientMac.mm in Sources */,
    9815                                 2DFC7DBC1BCCC19500C1548C /* WebViewImpl.mm in Sources */,
    98169808                                512935D71288D19400A4B695 /* WebContextMenuItem.cpp in Sources */,
    98179809                                510FBB9A1288C95E00AFFDF4 /* WebContextMenuItemData.cpp in Sources */,
Note: See TracChangeset for help on using the changeset viewer.