Changeset 169465 in webkit


Ignore:
Timestamp:
May 29, 2014, 2:44:27 PM (11 years ago)
Author:
matthew_hanson@apple.com
Message:

Roll out r169439. <rdar://problem/17069364>

Location:
trunk/Source/WebKit2
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r169460 r169465  
     12014-05-29  Matthew Hanson  <matthew_hanson@apple.com>
     2
     3        Roll out r169439. <rdar://problem/17069364>
     4
     5    2014-05-28  Gavin Barraclough  <baraclough@apple.com>
     6
     7            viewStateDidChange should always fully update ViewState
     8            https://bugs.webkit.org/show_bug.cgi?id=133159
     9
     10            Reviewed by Anders Carlson.
     11
     12            Currently WebPageProxy::viewStateDidChange is passed a mask of bits to update.
     13
     14            This has the following negative consequences:
     15             – WKWebView implicitly requires more detailed knowledge of the internal implementation of the PageClient.
     16             – Updates may unnecessarily be split over multiple IPC messages.
     17             – In order to support partial updates we make multiple virtual function calls to PageClient, which then makes duplicate objc calls.
     18
     19            Better to just always update the entire ViewState.
     20
     21            * UIProcess/API/Cocoa/WKWebView.mm:
     22            (-[WKWebView didMoveToWindow]):
     23                - removed argument to viewStateDidChange.
     24            * UIProcess/API/gtk/PageClientImpl.cpp:
     25            (WebKit::PageClientImpl::viewState):
     26            (WebKit::PageClientImpl::isViewWindowActive): Deleted.
     27            (WebKit::PageClientImpl::isViewFocused): Deleted.
     28            (WebKit::PageClientImpl::isViewVisible): Deleted.
     29            (WebKit::PageClientImpl::isViewInWindow): Deleted.
     30            * UIProcess/API/gtk/PageClientImpl.h:
     31                - merged isViewWindowActive/isViewFocused/isViewVisible/isViewInWindow to viewState.
     32            * UIProcess/API/mac/WKView.mm:
     33            (-[WKView becomeFirstResponder]):
     34            (-[WKView resignFirstResponder]):
     35            (-[WKView viewDidMoveToWindow]):
     36            (-[WKView _windowDidBecomeKey:]):
     37            (-[WKView _windowDidResignKey:]):
     38            (-[WKView _windowDidMiniaturize:]):
     39            (-[WKView _windowDidDeminiaturize:]):
     40            (-[WKView _windowDidOrderOffScreen:]):
     41            (-[WKView _windowDidOrderOnScreen:]):
     42            (-[WKView _windowDidChangeOcclusionState:]):
     43            (-[WKView viewDidHide]):
     44            (-[WKView viewDidUnhide]):
     45            (-[WKView _activeSpaceDidChange:]):
     46            (-[WKView _setThumbnailView:]):
     47            (-[WKView endDeferringViewInWindowChanges]):
     48            (-[WKView endDeferringViewInWindowChangesSync]):
     49                - removed argument to viewStateDidChange.
     50            * UIProcess/CoordinatedGraphics/WebView.cpp:
     51            (WebKit::WebView::viewState):
     52            (WebKit::WebView::isViewWindowActive): Deleted.
     53            (WebKit::WebView::isViewFocused): Deleted.
     54            (WebKit::WebView::isViewVisible): Deleted.
     55            (WebKit::WebView::isViewInWindow): Deleted.
     56            * UIProcess/CoordinatedGraphics/WebView.h:
     57                - merged isViewWindowActive/isViewFocused/isViewVisible/isViewInWindow to viewState.
     58            * UIProcess/PageClient.h:
     59            (WebKit::PageClient::isViewVisibleOrOccluded): Deleted.
     60            (WebKit::PageClient::isVisuallyIdle): Deleted.
     61                - merged isViewVisibleOrOccluded/isVisuallyIdle to subclass viewState methods.
     62            * UIProcess/WebPageProxy.cpp:
     63            (WebKit::WebPageProxy::WebPageProxy):
     64            (WebKit::WebPageProxy::reattachToWebProcess):
     65                - updateViewState -> PageClient::viewState
     66            (WebKit::WebPageProxy::viewStateDidChange):
     67                - argument removed; updateViewState -> PageClient::viewState.
     68            (WebKit::WebPageProxy::setCursor):
     69                - call isViewWindowActive on WebPageProxy, rather than PageClient.
     70            (WebKit::WebPageProxy::updateBackingStoreDiscardableState):
     71                - call isViewWindowActive on WebPageProxy, rather than PageClient.
     72            (WebKit::WebPageProxy::updateViewState): Deleted.
     73                - removed - viewState method moved to PageClient.
     74            * UIProcess/WebPageProxy.h:
     75            (WebKit::WebPageProxy::isViewWindowActive):
     76                - added missing implementation.
     77            (WebKit::WebPageProxy::isViewVisible):
     78                - removed argument to viewStateDidChange.
     79            * UIProcess/WebProcessProxy.cpp:
     80            (WebKit::WebProcessProxy::windowServerConnectionStateChanged):
     81                - removed argument to viewStateDidChange.
     82            * UIProcess/ios/PageClientImplIOS.h:
     83            * UIProcess/ios/PageClientImplIOS.mm:
     84            (WebKit::PageClientImpl::viewState):
     85            (WebKit::PageClientImpl::isViewWindowActive): Deleted.
     86            (WebKit::PageClientImpl::isViewFocused): Deleted.
     87            (WebKit::PageClientImpl::isViewVisible): Deleted.
     88            (WebKit::PageClientImpl::isViewInWindow): Deleted.
     89            (WebKit::PageClientImpl::isViewVisibleOrOccluded): Deleted.
     90            (WebKit::PageClientImpl::isVisuallyIdle): Deleted.
     91                - merged isViewWindowActive/isViewFocused/isViewVisible/isViewInWindow to viewState.
     92            * UIProcess/ios/WKContentView.mm:
     93            (-[WKContentView didMoveToWindow]):
     94            (-[WKContentView _applicationDidEnterBackground:]):
     95            (-[WKContentView _applicationWillEnterForeground:]):
     96                - removed argument to viewStateDidChange.
     97            * UIProcess/mac/PageClientImpl.h:
     98            * UIProcess/mac/PageClientImpl.mm:
     99            (WebKit::PageClientImpl::viewState):
     100            (WebKit::PageClientImpl::showCorrectionPanel):
     101            (WebKit::PageClientImpl::showDictationAlternativeUI):
     102            (WebKit::PageClientImpl::isViewWindowActive): Deleted.
     103            (WebKit::PageClientImpl::isViewFocused): Deleted.
     104            (WebKit::PageClientImpl::isViewVisibleOrOccluded): Deleted.
     105            (WebKit::PageClientImpl::isVisuallyIdle): Deleted.
     106                - merged isViewWindowActive/isViewFocused/isViewVisible/isViewInWindow to viewState.
     107
    11082014-05-29  Dan Bernstein  <mitz@apple.com>
    2109

  • trunk/Source/WebKit2/UIProcess/API/Cocoa/WKWebView.mm

    r169439 r169465  
    919919- (void)didMoveToWindow
    920920{
    921     _page->viewStateDidChange();
     921    _page->viewStateDidChange(WebCore::ViewState::IsInWindow);
    922922}
    923923

  • trunk/Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp

    r169439 r169465  
    9898}
    9999
    100 ViewState::Flags PageClientImpl::viewState()
    101 {
    102     WebKitWebViewBase* webView = WEBKIT_WEB_VIEW_BASE(m_viewWidget);
    103     ViewState::Flags viewState = ViewState::NoFlags;
    104    
    105     if (webkitWebViewBaseIsFocused(webView))
    106         viewState |= ViewState::IsFocused;
    107     if (webkitWebViewBaseIsInWindowActive(webView))
    108         viewState |= ViewState::WindowIsActive;
    109     if (webkitWebViewBaseIsInWindow(webView))
    110         viewState |= ViewState::IsInWindow;
    111     if (webkitWebViewBaseIsVisible(webView))
    112         viewState |= (ViewState::IsVisible | ViewState::IsVisibleOrOccluded);
    113     else
    114         viewState |= ViewState::IsVisuallyIdle;
    115    
    116     return viewState;
    117 }
    118    
     100bool PageClientImpl::isViewWindowActive()
     101{
     102    return webkitWebViewBaseIsInWindowActive(WEBKIT_WEB_VIEW_BASE(m_viewWidget));
     103}
     104
     105bool PageClientImpl::isViewFocused()
     106{
     107    return webkitWebViewBaseIsFocused(WEBKIT_WEB_VIEW_BASE(m_viewWidget));
     108}
     109
     110bool PageClientImpl::isViewVisible()
     111{
     112    return webkitWebViewBaseIsVisible(WEBKIT_WEB_VIEW_BASE(m_viewWidget));
     113}
     114
     115bool PageClientImpl::isViewInWindow()
     116{
     117    return webkitWebViewBaseIsInWindow(WEBKIT_WEB_VIEW_BASE(m_viewWidget));
     118}
     119
    119120void PageClientImpl::PageClientImpl::processDidExit()
    120121{

  • trunk/Source/WebKit2/UIProcess/API/gtk/PageClientImpl.h

    r169439 r169465  
    6868    virtual void requestScroll(const WebCore::FloatPoint& scrollPosition, bool isProgrammaticScroll) override;
    6969    virtual WebCore::IntSize viewSize() override;
    70     virtual WebCore::ViewState::Flags viewState() override;
     70    virtual bool isViewWindowActive() override;
     71    virtual bool isViewFocused() override;
     72    virtual bool isViewVisible() override;
     73    virtual bool isViewInWindow() override;
    7174    virtual void processDidExit() override;
    7275    virtual void didRelaunchProcess() override;

  • trunk/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp

    r169445 r169465  
    176176    if (!priv->isInWindowActive) {
    177177        priv->isInWindowActive = true;
    178         priv->pageProxy->viewStateDidChange();
     178        priv->pageProxy->viewStateDidChange(ViewState::WindowIsActive);
    179179    }
    180180
    … …  
    187187    if (priv->isInWindowActive) {
    188188        priv->isInWindowActive = false;
    189         priv->pageProxy->viewStateDidChange();
     189        priv->pageProxy->viewStateDidChange(ViewState::WindowIsActive);
    190190    }
    191191
    … …  
    199199    if (priv->isWindowVisible != isWindowVisible) {
    200200        priv->isWindowVisible = isWindowVisible;
    201         priv->pageProxy->viewStateDidChange();
     201        priv->pageProxy->viewStateDidChange(ViewState::IsVisible);
    202202    }
    203203
    … …  
    229229
    230230    priv->toplevelOnScreenWindow = window;
    231     priv->pageProxy->viewStateDidChange();
     231    priv->pageProxy->viewStateDidChange(ViewState::IsInWindow);
    232232    if (!priv->toplevelOnScreenWindow)
    233233        return;
    … …  
    570570    if (!priv->isVisible) {
    571571        priv->isVisible = true;
    572         priv->pageProxy->viewStateDidChange();
     572        priv->pageProxy->viewStateDidChange(ViewState::IsVisible);
    573573    }
    574574
    … …  
    589589    if (priv->isVisible) {
    590590        priv->isVisible = false;
    591         priv->pageProxy->viewStateDidChange();
     591        priv->pageProxy->viewStateDidChange(ViewState::IsVisible);
    592592    }
    593593}
    … …  
    11431143        return;
    11441144
     1145    unsigned viewStateFlags = ViewState::IsFocused;
    11451146    priv->isFocused = focused;
    11461147
    … …  
    11501151    // set programatically like WebKitTestRunner does, because POPUP
    11511152    // can't be focused.
    1152     if (priv->isFocused && !priv->isInWindowActive)
     1153    if (priv->isFocused && !priv->isInWindowActive) {
    11531154        priv->isInWindowActive = true;
    1154     priv->pageProxy->viewStateDidChange();
     1155        viewStateFlags |= ViewState::WindowIsActive;
     1156    }
     1157    priv->pageProxy->viewStateDidChange(viewStateFlags);
    11551158}
    11561159

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

    r169439 r169465  
    354354   
    355355    [self _updateSecureInputState];
    356     _data->_page->viewStateDidChange();
     356    _data->_page->viewStateDidChange(ViewState::IsFocused);
    357357
    358358    _data->_inBecomeFirstResponder = false;
    … …  
    386386        _data->_page->clearSelection();
    387387   
    388     _data->_page->viewStateDidChange();
     388    _data->_page->viewStateDidChange(ViewState::IsFocused);
    389389
    390390    _data->_inResignFirstResponder = false;
    … …  
    24492449        [self doWindowDidChangeScreen];
    24502450
     2451        ViewState::Flags viewStateChanges = ViewState::WindowIsActive | ViewState::IsVisible;
    24512452        if ([self isDeferringViewInWindowChanges])
    24522453            _data->_viewInWindowChangeWasDeferred = YES;
    2453         _data->_page->viewStateDidChange();
     2454        else
     2455            viewStateChanges |= ViewState::IsInWindow;
     2456        _data->_page->viewStateDidChange(viewStateChanges);
    24542457
    24552458        [self _updateWindowAndViewFrames];
    … …  
    24642467        [self _accessibilityRegisterUIProcessTokens];
    24652468    } else {
     2469        ViewState::Flags viewStateChanges = ViewState::WindowIsActive | ViewState::IsVisible;
    24662470        if ([self isDeferringViewInWindowChanges])
    24672471            _data->_viewInWindowChangeWasDeferred = YES;
    2468         _data->_page->viewStateDidChange();
     2472        else
     2473            viewStateChanges |= ViewState::IsInWindow;
     2474        _data->_page->viewStateDidChange(viewStateChanges);
    24692475
    24702476        [NSEvent removeMonitor:_data->_flagsChangedEventMonitor];
    … …  
    24872493    if (keyWindow == [self window] || keyWindow == [[self window] attachedSheet]) {
    24882494        [self _updateSecureInputState];
    2489         _data->_page->viewStateDidChange();
     2495        _data->_page->viewStateDidChange(ViewState::WindowIsActive);
    24902496    }
    24912497}
    … …  
    25062512    if (formerKeyWindow == [self window] || formerKeyWindow == [[self window] attachedSheet]) {
    25072513        [self _updateSecureInputState];
    2508         _data->_page->viewStateDidChange();
     2514        _data->_page->viewStateDidChange(ViewState::WindowIsActive);
    25092515    }
    25102516}
    … …  
    25122518- (void)_windowDidMiniaturize:(NSNotification *)notification
    25132519{
    2514     _data->_page->viewStateDidChange();
     2520    _data->_page->viewStateDidChange(ViewState::IsVisible);
    25152521}
    25162522
    25172523- (void)_windowDidDeminiaturize:(NSNotification *)notification
    25182524{
    2519     _data->_page->viewStateDidChange();
     2525    _data->_page->viewStateDidChange(ViewState::IsVisible);
    25202526}
    25212527
    … …  
    25322538- (void)_windowDidOrderOffScreen:(NSNotification *)notification
    25332539{
    2534     _data->_page->viewStateDidChange();
     2540    _data->_page->viewStateDidChange(ViewState::IsVisible | ViewState::WindowIsActive);
    25352541}
    25362542
    25372543- (void)_windowDidOrderOnScreen:(NSNotification *)notification
    25382544{
    2539     _data->_page->viewStateDidChange();
     2545    _data->_page->viewStateDidChange(ViewState::IsVisible | ViewState::WindowIsActive);
    25402546}
    25412547
    … …  
    25532559- (void)_windowDidChangeOcclusionState:(NSNotification *)notification
    25542560{
    2555     _data->_page->viewStateDidChange();
     2561    _data->_page->viewStateDidChange(ViewState::IsVisible);
    25562562}
    25572563#endif
    … …  
    25772583- (void)viewDidHide
    25782584{
    2579     _data->_page->viewStateDidChange();
     2585    _data->_page->viewStateDidChange(ViewState::IsVisible);
    25802586}
    25812587
    25822588- (void)viewDidUnhide
    25832589{
    2584     _data->_page->viewStateDidChange();
     2590    _data->_page->viewStateDidChange(ViewState::IsVisible);
    25852591}
    25862592
    … …  
    25982604- (void)_activeSpaceDidChange:(NSNotification *)notification
    25992605{
    2600     _data->_page->viewStateDidChange();
     2606    _data->_page->viewStateDidChange(ViewState::IsVisible);
    26012607}
    26022608
    … …  
    34853491        [self _setAcceleratedCompositingModeRootLayer:_data->_rootLayer.get()];
    34863492
    3487     _data->_page->viewStateDidChange();
     3493    _data->_page->viewStateDidChange(ViewState::WindowIsActive | ViewState::IsInWindow | ViewState::IsVisible);
    34883494}
    34893495
    … …  
    37433749
    37443750    if (_data->_viewInWindowChangeWasDeferred) {
    3745         _data->_page->viewStateDidChange();
     3751        _data->_page->viewStateDidChange(ViewState::IsInWindow);
    37463752        _data->_viewInWindowChangeWasDeferred = NO;
    37473753    }
    … …  
    37613767
    37623768    if (_data->_viewInWindowChangeWasDeferred) {
    3763         _data->_page->viewStateDidChange(hasPendingViewInWindowChange ? WebPageProxy::WantsReplyOrNot::DoesWantReply : WebPageProxy::WantsReplyOrNot::DoesNotWantReply);
     3769        _data->_page->viewStateDidChange(ViewState::IsInWindow, hasPendingViewInWindowChange ? WebPageProxy::WantsReplyOrNot::DoesWantReply : WebPageProxy::WantsReplyOrNot::DoesNotWantReply);
    37643770        _data->_viewInWindowChangeWasDeferred = NO;
    37653771    }

  • trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp

    r169439 r169465  
    9393
    9494    scene->setActive(active);
    95     m_page->viewStateDidChange();
     95    m_page->viewStateDidChange(ViewState::WindowIsActive);
    9696}
    9797
    … …  
    112112
    113113    m_focused = focused;
    114     m_page->viewStateDidChange();
     114    m_page->viewStateDidChange(ViewState::IsFocused | ViewState::WindowIsActive);
    115115}
    116116
    … …  
    121121
    122122    m_visible = visible;
    123     m_page->viewStateDidChange();
     123    m_page->viewStateDidChange(ViewState::IsVisible);
    124124
    125125    if (CoordinatedDrawingAreaProxy* drawingArea = static_cast<CoordinatedDrawingAreaProxy*>(page()->drawingArea()))
    … …  
    127127}
    128128
    129 ViewState::Flags WebView::viewState()
    130 {
    131     ViewState::Flags viewState = ViewState::IsInWindow | ViewState::WindowIsActive;
    132    
    133     if (isFocused())
    134         viewState |= ViewState::IsFocused;
    135    
    136     if (isVisible())
    137         viewState |= (ViewState::IsVisible | ViewState::IsVisibleOrOccluded);
    138     else
    139         viewState |= ViewState::IsVisuallyIdle;
    140    
    141     return viewState;
    142 }
    143    
    144129void WebView::setUserViewportTranslation(double tx, double ty)
    145130{
    … …  
    339324}
    340325
     326bool WebView::isViewWindowActive()
     327{
     328    notImplemented();
     329    return true;
     330}
     331
     332bool WebView::isViewFocused()
     333{
     334    return isFocused();
     335}
     336
     337bool WebView::isViewVisible()
     338{
     339    return isVisible();
     340}
     341
     342bool WebView::isViewInWindow()
     343{
     344    notImplemented();
     345    return true;
     346}
     347
    341348void WebView::processDidExit()
    342349{

  • trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.h

    r169439 r169465  
    136136    virtual WebCore::IntSize viewSize() override;
    137137
    138     virtual WebCore::ViewState::Flags viewState() override;
     138    virtual bool isViewWindowActive() override;
     139    virtual bool isViewFocused() override;
     140    virtual bool isViewVisible() override;
     141    virtual bool isViewInWindow() override;
    139142
    140143    virtual void processDidExit() override;

  • trunk/Source/WebKit2/UIProcess/PageClient.h

    r169439 r169465  
    3333#include <WebCore/AlternativeTextClient.h>
    3434#include <WebCore/EditorClient.h>
    35 #include <WebCore/ViewState.h>
    3635#include <wtf/Forward.h>
    3736
    … …  
    102101    virtual WebCore::IntSize viewSize() = 0;
    103102
    104 #if PLATFORM(MAC)
     103    // Return whether the view's containing window is active.
     104    virtual bool isViewWindowActive() = 0;
     105
     106    // Return whether the view is focused.
     107    virtual bool isViewFocused() = 0;
     108
     109    // Return whether the view is visible.
     110    virtual bool isViewVisible() = 0;
     111
     112    // Return whether the view is visible, or occluded by another window.
     113    virtual bool isViewVisibleOrOccluded() { return isViewVisible(); }
     114
    105115    // Return whether the view is in a window.
    106116    virtual bool isViewInWindow() = 0;
    107 #endif
    108 
    109     virtual WebCore::ViewState::Flags viewState() = 0;
     117
     118    // Return whether the view is visually idle.
     119    virtual bool isVisuallyIdle() { return !isViewVisible(); }
    110120
    111121    // Return the layer hosting mode for the view.

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.cpp

    r169445 r169465  
    275275    , m_geolocationPermissionRequestManager(*this)
    276276    , m_notificationPermissionRequestManager(*this)
    277     , m_viewState(m_pageClient.viewState())
     277    , m_viewState(ViewState::NoFlags)
    278278    , m_backForwardList(WebBackForwardList::create(*this))
    279279    , m_loadStateAtProcessExit(FrameLoadState::State::Finished)
    … …  
    367367        m_visitedLinkProvider->addProcess(m_process.get());
    368368    }
    369    
     369
     370    updateViewState();
    370371    updateActivityToken();
    371372   
    … …  
    534535    m_process->addMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_pageID, *this);
    535536
    536     m_viewState = m_pageClient.viewState();
     537    updateViewState();
    537538    updateActivityToken();
    538539
    … …  
    10541055}
    10551056
    1056 void WebPageProxy::viewStateDidChange(WantsReplyOrNot wantsReply)
    1057 {
    1058     if (!isValid())
    1059         return;
     1057void WebPageProxy::updateViewState(ViewState::Flags flagsToUpdate)
     1058{
     1059    m_viewState &= ~flagsToUpdate;
     1060    if (flagsToUpdate & ViewState::IsFocused && m_pageClient.isViewFocused())
     1061        m_viewState |= ViewState::IsFocused;
     1062    if (flagsToUpdate & ViewState::WindowIsActive && m_pageClient.isViewWindowActive())
     1063        m_viewState |= ViewState::WindowIsActive;
     1064    if (flagsToUpdate & ViewState::IsVisible && m_pageClient.isViewVisible())
     1065        m_viewState |= ViewState::IsVisible;
     1066    if (flagsToUpdate & ViewState::IsVisibleOrOccluded && m_pageClient.isViewVisibleOrOccluded())
     1067        m_viewState |= ViewState::IsVisibleOrOccluded;
     1068    if (flagsToUpdate & ViewState::IsInWindow && m_pageClient.isViewInWindow())
     1069        m_viewState |= ViewState::IsInWindow;
     1070    if (flagsToUpdate & ViewState::IsVisuallyIdle && m_pageClient.isVisuallyIdle())
     1071        m_viewState |= ViewState::IsVisuallyIdle;
     1072}
     1073
     1074void WebPageProxy::viewStateDidChange(ViewState::Flags mayHaveChanged, WantsReplyOrNot wantsReply)
     1075{
     1076    if (!isValid())
     1077        return;
     1078
     1079    // If the visibility state may have changed, then so may the visually idle & occluded agnostic state.
     1080    if (mayHaveChanged & ViewState::IsVisible)
     1081        mayHaveChanged |= ViewState::IsVisibleOrOccluded | ViewState::IsVisuallyIdle;
    10601082
    10611083    // Record the prior view state, update the flags that may have changed,
    10621084    // and check which flags have actually changed.
    10631085    ViewState::Flags previousViewState = m_viewState;
    1064     m_viewState = m_pageClient.viewState();
     1086    updateViewState(mayHaveChanged);
    10651087    ViewState::Flags changed = m_viewState ^ previousViewState;
    10661088
    … …  
    10801102        m_process->responsivenessTimer()->stop();
    10811103
    1082     if ((changed & ViewState::IsInWindow) && (m_viewState & ViewState::IsInWindow)) {
     1104    if ((mayHaveChanged & ViewState::IsInWindow) && (m_viewState & ViewState::IsInWindow)) {
    10831105        LayerHostingMode layerHostingMode = m_pageClient.viewLayerHostingMode();
    10841106        if (m_layerHostingMode != layerHostingMode) {
    … …  
    10881110    }
    10891111
    1090     if ((changed & ViewState::IsInWindow) && !(m_viewState & ViewState::IsInWindow)) {
     1112    if ((mayHaveChanged & ViewState::IsInWindow) && !(m_viewState & ViewState::IsInWindow)) {
    10911113#if ENABLE(INPUT_TYPE_COLOR_POPOVER)
    10921114        // When leaving the current page, close the popover color well.
    … …  
    37903812    // The Web process may have asked to change the cursor when the view was in an active window, but
    37913813    // if it is no longer in a window or the window is not active, then the cursor should not change.
    3792     if (isViewWindowActive())
     3814    if (m_pageClient.isViewWindowActive())
    37933815        m_pageClient.setCursor(cursor);
    37943816}
    … …  
    46784700        isDiscardable = false;
    46794701    else
    4680         isDiscardable = !isViewWindowActive() || !isViewVisible();
     4702        isDiscardable = !m_pageClient.isViewWindowActive() || !isViewVisible();
    46814703
    46824704    m_drawingArea->setBackingStoreIsDiscardable(isDiscardable);

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.h

    r169439 r169465  
    569569
    570570    enum class WantsReplyOrNot { DoesNotWantReply, DoesWantReply };
    571     void viewStateDidChange(WantsReplyOrNot = WantsReplyOrNot::DoesNotWantReply);
     571    void viewStateDidChange(WebCore::ViewState::Flags mayHaveChanged, WantsReplyOrNot = WantsReplyOrNot::DoesNotWantReply);
    572572    bool isInWindow() const { return m_viewState & WebCore::ViewState::IsInWindow; }
    573573    void waitForDidUpdateViewState();
    … …  
    576576
    577577    WebCore::IntSize viewSize() const;
    578     bool isViewWindowActive() const { return m_viewState & WebCore::ViewState::WindowIsActive; }
    579578    bool isViewVisible() const { return m_viewState & WebCore::ViewState::IsVisible; }
     579    bool isViewWindowActive() const;
    580580    bool isProcessSuppressible() const;
    581581
    … …  
    11031103    void platformInitialize();
    11041104
     1105    void updateViewState(WebCore::ViewState::Flags flagsToUpdate = WebCore::ViewState::AllFlags);
    11051106    void updateActivityToken();
    11061107       

  • trunk/Source/WebKit2/UIProcess/WebProcessProxy.cpp

    r169439 r169465  
    670670{
    671671    for (const auto& page : m_pageMap.values())
    672         page->viewStateDidChange();
     672        page->viewStateDidChange(ViewState::IsVisuallyIdle);
    673673}
    674674

  • trunk/Source/WebKit2/UIProcess/ios/PageClientImplIOS.h

    r169439 r169465  
    5656    virtual void requestScroll(const WebCore::FloatPoint& scrollPosition, bool isProgrammaticScroll) override;
    5757    virtual WebCore::IntSize viewSize() override;
    58     virtual WebCore::ViewState::Flags viewState() override;
    59        
     58    virtual bool isViewWindowActive() override;
     59    virtual bool isViewFocused() override;
     60    virtual bool isViewVisible() override;
     61    virtual bool isViewInWindow() override;
     62    virtual bool isViewVisibleOrOccluded() override;
     63    virtual bool isVisuallyIdle() override;
    6064    virtual void processDidExit() override;
    6165    virtual void didRelaunchProcess() override;

  • trunk/Source/WebKit2/UIProcess/ios/PageClientImplIOS.mm

    r169439 r169465  
    111111}
    112112
    113 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=133098
    114 ViewState::Flags PageClientImpl::viewState()
    115 {
    116     ViewState::Flags viewState = ViewState::NoFlags;
    117    
    118     bool isInWindow = [m_webView window];
    119     bool isVisible = isInWindow && [UIApplication sharedApplication].applicationState != UIApplicationStateBackground;
    120    
    121     if (isInWindow)
    122         viewState |= ViewState::IsInWindow;
    123    
    124     if (isVisible)
    125         viewState |= ViewState::WindowIsActive | ViewState::IsFocused | ViewState::IsVisible | ViewState::IsVisibleOrOccluded;
    126     else
    127         viewState |= ViewState::IsVisuallyIdle;
    128    
    129     return viewState;
    130 }
    131    
     113bool PageClientImpl::isViewWindowActive()
     114{
     115    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=133098
     116    return isViewVisible();
     117}
     118
     119bool PageClientImpl::isViewFocused()
     120{
     121    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=133098
     122    return isViewWindowActive();
     123}
     124
     125bool PageClientImpl::isViewVisible()
     126{
     127    return [m_webView window] && [UIApplication sharedApplication].applicationState != UIApplicationStateBackground;
     128}
     129
     130bool PageClientImpl::isViewInWindow()
     131{
     132    return [m_webView window];
     133}
     134
     135bool PageClientImpl::isViewVisibleOrOccluded()
     136{
     137    return isViewVisible();
     138}
     139
     140bool PageClientImpl::isVisuallyIdle()
     141{
     142    return !isViewVisible();
     143}
     144
    132145void PageClientImpl::processDidExit()
    133146{

  • trunk/Source/WebKit2/UIProcess/ios/WKContentView.mm

    r169439 r169465  
    251251    if (self.window)
    252252        [self _updateForScreen:self.window.screen];
    253     _page->viewStateDidChange();
     253    _page->viewStateDidChange(ViewState::AllFlags);
    254254}
    255255
    … …  
    452452- (void)_applicationDidEnterBackground:(NSNotification*)notification
    453453{
    454     _page->viewStateDidChange();
     454    _page->viewStateDidChange(ViewState::AllFlags & ~ViewState::IsInWindow);
    455455}
    456456
    … …  
    458458{
    459459    _page->applicationWillEnterForeground();
    460     _page->viewStateDidChange();
     460    _page->viewStateDidChange(ViewState::AllFlags & ~ViewState::IsInWindow);
    461461}
    462462

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

    r169439 r169465  
    6666
    6767    virtual WebCore::IntSize viewSize();
    68     bool isViewVisible();
     68    virtual bool isViewWindowActive();
     69    virtual bool isViewFocused();
     70    virtual bool isViewVisible();
     71    virtual bool isViewVisibleOrOccluded();
    6972    virtual bool isViewInWindow();
    70     virtual WebCore::ViewState::Flags viewState() override;
    71        
     73    virtual bool isVisuallyIdle();
    7274    virtual LayerHostingMode viewLayerHostingMode() override;
    7375    virtual ColorSpaceData colorSpace() override;

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

    r169439 r169465  
    191191}
    192192
     193bool PageClientImpl::isViewWindowActive()
     194{
     195    NSWindow *activeViewWindow = activeView().window;
     196    return activeViewWindow.isKeyWindow || [NSApp keyWindow] == activeViewWindow;
     197}
     198
     199bool PageClientImpl::isViewFocused()
     200{
     201    return [m_wkView _isFocused];
     202}
     203
    193204void PageClientImpl::makeFirstResponder()
    194205{
    … …  
    225236}
    226237
     238bool PageClientImpl::isViewVisibleOrOccluded()
     239{
     240    return activeView().window.isVisible;
     241}
     242
    227243bool PageClientImpl::isViewInWindow()
    228244{
    … …  
    230246}
    231247
    232 ViewState::Flags PageClientImpl::viewState()
    233 {
    234     ViewState::Flags viewState = ViewState::NoFlags;
    235    
    236     NSWindow *activeViewWindow = activeView().window;
    237     bool isVisible = isViewVisible();
    238    
    239     if (activeViewWindow)
    240         viewState |= ViewState::IsInWindow;
    241     if (activeViewWindow.isKeyWindow || [NSApp keyWindow] == activeViewWindow)
    242         viewState |= ViewState::WindowIsActive;
    243     if ([m_wkView _isFocused])
    244         viewState |= ViewState::IsFocused;
    245     if (isVisible)
    246         viewState |= ViewState::IsVisible;
    247     if (activeViewWindow.isVisible)
    248         viewState |= ViewState::IsVisibleOrOccluded;
    249     if (!isVisible || WindowServerConnection::shared().applicationWindowModificationsHaveStopped())
    250         viewState |= ViewState::IsVisuallyIdle;
    251    
    252     return viewState;
    253 }
    254    
     248bool PageClientImpl::isVisuallyIdle()
     249{
     250    return WindowServerConnection::shared().applicationWindowModificationsHaveStopped() || !isViewVisible();
     251}
     252
    255253LayerHostingMode PageClientImpl::viewLayerHostingMode()
    256254{
    … …  
    543541{
    544542#if USE(AUTOCORRECTION_PANEL)
    545     if (!isViewVisible())
     543    if (!isViewVisible() || !isViewInWindow())
    546544        return;
    547     ASSERT(isViewInWindow());
    548545    m_correctionPanel.show(m_wkView, type, boundingBoxOfReplacedString, replacedString, replacementString, alternativeReplacementStrings);
    549546#endif
    … …  
    624621void PageClientImpl::showDictationAlternativeUI(const WebCore::FloatRect& boundingBoxOfDictatedText, uint64_t dictationContext)
    625622{
    626     if (!isViewVisible())
     623    if (!isViewVisible() || !isViewInWindow())
    627624        return;
    628     ASSERT(isViewInWindow());
    629625    m_alternativeTextUIController->showAlternatives(m_wkView, boundingBoxOfDictatedText, dictationContext, ^(NSString* acceptedAlternative){
    630626        [m_wkView handleAcceptedAlternativeText:acceptedAlternative];
Note: See TracChangeset for help on using the changeset viewer.