Changeset 161530 in webkit


Ignore:
Timestamp:
Jan 8, 2014 5:38:13 PM (10 years ago)
Author:
timothy_horton@apple.com
Message:

TileController can fail to receive exposedRect from the drawing area if set at the wrong time
​https://bugs.webkit.org/show_bug.cgi?id=126536

Reviewed by Simon Fraser.

  • Configurations/WebKit2.xcconfig:
  • UIProcess/API/mac/WKView.mm:

(-[WKView _updateViewExposedRect]):

  • UIProcess/DrawingAreaProxy.cpp:

(WebKit::DrawingAreaProxy::DrawingAreaProxy):
(WebKit::DrawingAreaProxy::setExposedRect):
(WebKit::DrawingAreaProxy::exposedRectChangedTimerFired):

  • UIProcess/DrawingAreaProxy.h:

(WebKit::DrawingAreaProxy::exposedRect):

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::WebPageProxy):
(WebKit::WebPageProxy::close):

  • UIProcess/WebPageProxy.h:

Move exposedRect stuff from WebPageProxy to DrawingAreaProxy.

  • WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:

(WebKit::WebFrameLoaderClient::transitionToCommittedForNewPage):
Push the exposedRect down into WebCore.

  • WebProcess/WebPage/DrawingArea.h:
  • WebProcess/WebPage/DrawingArea.messages.in:
  • WebProcess/WebPage/WebPage.cpp:
  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebPage/WebPage.messages.in:
  • WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h:
  • WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:

(WebKit::RemoteLayerTreeDrawingArea::RemoteLayerTreeDrawingArea):
(WebKit::RemoteLayerTreeDrawingArea::updateScrolledExposedRect):

  • WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.h:
  • WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:

(WebKit::TiledCoreAnimationDrawingArea::TiledCoreAnimationDrawingArea):
(WebKit::TiledCoreAnimationDrawingArea::flushLayers):
(WebKit::TiledCoreAnimationDrawingArea::updateScrolledExposedRect):
(WebKit::TiledCoreAnimationDrawingArea::setRootCompositingLayer):
(WebKit::TiledCoreAnimationDrawingArea::createPageOverlayLayer):
(WebKit::TiledCoreAnimationDrawingArea::didCommitChangesForLayer):
Get rid of "clipsToExposedRect", we just use infinite-ness of the rect
to indicate that now.
Don't scroll an infinite rect; it won't work.

  • WebCore.exp.in:

Export some things.

  • page/FrameView.cpp:

(WebCore::FrameView::FrameView):
(WebCore::FrameView::setExposedRect):
Store the exposed rect on FrameView. When it changes, if the main frame
has a TiledBacking, inform it of the change.

  • page/FrameView.h:
  • platform/graphics/TiledBacking.h:
  • platform/graphics/ca/mac/TileController.h:
  • platform/graphics/ca/mac/TileController.mm:

(WebCore::TileController::TileController):
(WebCore::TileController::tilesWouldChangeForVisibleRect):
(WebCore::TileController::computeTileCoverageRect):
(WebCore::TileController::revalidateTiles):
(WebCore::TileController::updateTileCoverageMap):
Make use of the fact that we can test if a rect is infinite
instead of having a separate boolean property for that.

  • rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::RenderLayerBacking):
(WebCore::computeTileCoverage):
Push the FrameView's cached exposed rect down into the TiledBacking when it is created.
We only support clipping for the main frame TileController for now.

Location:
trunk/Source
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r161521 r161530  
     12014-01-08  Tim Horton  <timothy_horton@apple.com>
     2
     3        TileController can fail to receive exposedRect from the drawing area if set at the wrong time
     4        https://bugs.webkit.org/show_bug.cgi?id=126536
     5
     6        Reviewed by Simon Fraser.
     7
     8        * WebCore.exp.in:
     9        Export some things.
     10
     11        * page/FrameView.cpp:
     12        (WebCore::FrameView::FrameView):
     13        (WebCore::FrameView::setExposedRect):
     14        Store the exposed rect on FrameView. When it changes, if the main frame
     15        has a TiledBacking, inform it of the change.
     16
     17        * page/FrameView.h:
     18        * platform/graphics/TiledBacking.h:
     19        * platform/graphics/ca/mac/TileController.h:
     20        * platform/graphics/ca/mac/TileController.mm:
     21        (WebCore::TileController::TileController):
     22        (WebCore::TileController::tilesWouldChangeForVisibleRect):
     23        (WebCore::TileController::computeTileCoverageRect):
     24        (WebCore::TileController::revalidateTiles):
     25        (WebCore::TileController::updateTileCoverageMap):
     26        Make use of the fact that we can test if a rect is infinite
     27        instead of having a separate boolean property for that.
     28
     29        * rendering/RenderLayerBacking.cpp:
     30        (WebCore::RenderLayerBacking::RenderLayerBacking):
     31        (WebCore::computeTileCoverage):
     32        Push the FrameView's cached exposed rect down into the TiledBacking when it is created.
     33        We only support clipping for the main frame TileController for now.
     34
    1352014-01-07  Myles C. Maxfield  <mmaxfield@apple.com>
    236

  • trunk/Source/WebCore/WebCore.exp.in

    r161481 r161530  
    12691269__ZN7WebCore9FrameView14adjustViewSizeEv
    12701270__ZN7WebCore9FrameView14invalidateRectERKNS_7IntRectE
     1271__ZN7WebCore9FrameView14setExposedRectENS_9FloatRectE
    12711272__ZN7WebCore9FrameView14setNeedsLayoutEv
    12721273__ZN7WebCore9FrameView14setTransparentEb
    … …  
    18601861__ZThn???_NK7WebCore15GraphicsLayerCA33platformCALayerShowRepaintCounterEPNS_15PlatformCALayerE
    18611862__ZThn???_NK7WebCore15GraphicsLayerCA49platformCALayerContentsScaleMultiplierForNewTilesEPNS_15PlatformCALayerE
     1863__ZThn???_NK7WebCore15GraphicsLayerCA26platformCALayerExposedRectEv
    18621864_filenameByFixingIllegalCharacters
    18631865_hasCaseInsensitivePrefix

  • trunk/Source/WebCore/page/FrameView.cpp

    r161452 r161530  
    202202    , m_isTrackingRepaints(false)
    203203    , m_shouldUpdateWhileOffscreen(true)
     204    , m_exposedRect(FloatRect::infiniteRect())
    204205    , m_deferSetNeedsLayouts(0)
    205206    , m_setNeedsLayoutWasDeferred(false)
    … …  
    43724373}
    43734374
     4375void FrameView::setExposedRect(FloatRect exposedRect)
     4376{
     4377    if (m_exposedRect == exposedRect)
     4378        return;
     4379
     4380    m_exposedRect = exposedRect;
     4381
     4382#if USE(ACCELERATED_COMPOSITING)
     4383    // FIXME: We should support clipping to the exposed rect for subframes as well.
     4384    if (m_frame->isMainFrame()) {
     4385        if (TiledBacking* tiledBacking = this->tiledBacking())
     4386            tiledBacking->setExposedRect(exposedRect);
     4387    }
     4388#endif
     4389}
     4390
    43744391} // namespace WebCore

  • trunk/Source/WebCore/page/FrameView.h

    r161452 r161530  
    446446    void addTrackedRepaintRect(const IntRect&);
    447447
     448    // exposedRect represents WebKit's understanding of what part
     449    // of the view is actually exposed on screen (taking into account
     450    // clipping by other UI elements), whereas visibleContentRect is
     451    // internal to WebCore and doesn't respect those things.
     452    void setExposedRect(FloatRect);
     453    FloatRect exposedRect() const { return m_exposedRect; }
     454
    448455protected:
    449456    virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect) OVERRIDE;
    … …  
    631638    bool m_shouldUpdateWhileOffscreen;
    632639
     640    FloatRect m_exposedRect;
     641
    633642    unsigned m_deferSetNeedsLayouts;
    634643    bool m_setNeedsLayoutWasDeferred;

  • trunk/Source/WebCore/platform/graphics/TiledBacking.h

    r161452 r161530  
    4949
    5050    virtual void setExposedRect(const FloatRect&) = 0;
    51     virtual void setClipsToExposedRect(bool) = 0;
    52     virtual bool clipsToExposedRect() = 0;
    5351
    5452    virtual void prepopulateRect(const FloatRect&) = 0;

  • trunk/Source/WebCore/platform/graphics/ca/mac/TileController.h

    r161452 r161530  
    104104    virtual bool tilesWouldChangeForVisibleRect(const FloatRect&) const OVERRIDE;
    105105    virtual void setExposedRect(const FloatRect&) OVERRIDE;
    106     virtual bool clipsToExposedRect() OVERRIDE { return m_clipsToExposedRect; }
    107     virtual void setClipsToExposedRect(bool) OVERRIDE;
    108106    virtual void prepopulateRect(const FloatRect&) OVERRIDE;
    109107    virtual void setIsInWindow(bool) OVERRIDE;
    … …  
    246244    bool m_acceleratesDrawing;
    247245    bool m_tilesAreOpaque;
    248     bool m_clipsToExposedRect;
    249246    bool m_hasTilesWithTemporaryScaleFactor; // Used to make low-res tiles when zooming.
    250247

  • trunk/Source/WebCore/platform/graphics/ca/mac/TileController.mm

    r161452 r161530  
    5353    : m_tileCacheLayer(rootPlatformLayer)
    5454    , m_tileSize(defaultTileWidth, defaultTileHeight)
     55    , m_exposedRect(FloatRect::infiniteRect())
    5556    , m_tileRevalidationTimer(this, &TileController::tileRevalidationTimerFired)
    5657    , m_cohortRemovalTimer(this, &TileController::cohortRemovalTimerFired)
    … …  
    6869    , m_acceleratesDrawing(false)
    6970    , m_tilesAreOpaque(false)
    70     , m_clipsToExposedRect(false)
    7171    , m_hasTilesWithTemporaryScaleFactor(false)
    7272    , m_tileDebugBorderWidth(0)
    … …  
    278278{
    279279    FloatRect visibleRect = newVisibleRect;
    280 
    281     if (m_clipsToExposedRect)
    282         visibleRect.intersect(m_exposedRect);
     280    visibleRect.intersect(m_exposedRect);
    283281
    284282    if (visibleRect.isEmpty() || bounds().isEmpty())
    … …  
    313311}
    314312
    315 void TileController::setClipsToExposedRect(bool clipsToExposedRect)
    316 {
    317     if (m_clipsToExposedRect == clipsToExposedRect)
    318         return;
    319 
    320     m_clipsToExposedRect = clipsToExposedRect;
    321 
    322     // Going from not clipping to clipping, we don't need to revalidate right away.
    323     if (clipsToExposedRect)
    324         setNeedsRevalidateTiles();
    325 }
    326 
    327313void TileController::prepopulateRect(const FloatRect& rect)
    328314{
    … …  
    488474{
    489475    FloatRect visibleRect = currentVisibleRect;
    490 
    491     if (m_clipsToExposedRect)
    492         visibleRect.intersect(m_exposedRect);
     476    visibleRect.intersect(m_exposedRect);
    493477
    494478    // If the page is not in a window (for example if it's in a background tab), we limit the tile coverage rect to the visible rect.
    … …  
    689673    IntRect bounds = this->bounds();
    690674
    691     if (m_clipsToExposedRect)
    692         visibleRect.intersect(m_exposedRect);
     675    visibleRect.intersect(m_exposedRect);
    693676
    694677    if (visibleRect.isEmpty() || bounds.isEmpty())
    … …  
    933916    FloatRect visibleRect = this->visibleRect();
    934917
    935     if (m_clipsToExposedRect)
    936         visibleRect.intersect(m_exposedRect);
    937 
     918    visibleRect.intersect(m_exposedRect);
    938919    visibleRect.contract(4, 4); // Layer is positioned 2px from top and left edges.
    939920
    … …  
    949930    mapBounds.scale(indicatorScale, indicatorScale);
    950931
    951     if (m_clipsToExposedRect)
     932    if (!m_exposedRect.isInfinite())
    952933        m_tiledScrollingIndicatorLayer->setPosition(m_exposedRect.location() + FloatPoint(2, 2));
    953934    else

  • trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

    r161452 r161530  
    143143
    144144        if (m_isMainFrameRenderViewLayer) {
     145            tiledBacking->setExposedRect(renderer().frame().view()->exposedRect());
    145146            tiledBacking->setUnparentsOffscreenTiles(true);
    146147            if (page->settings().backgroundShouldExtendBeyondPage())
    … …  
    229230    }
    230231    if (!(useMinimalTilesDuringLoading || useMinimalTilesDuringLiveResize)) {
    231         bool clipsToExposedRect = backing->tiledBacking()->clipsToExposedRect();
     232        bool clipsToExposedRect = !frameView.exposedRect().isInfinite();
    232233        if (frameView.horizontalScrollbarMode() != ScrollbarAlwaysOff || clipsToExposedRect)
    233234            tileCoverage |= TiledBacking::CoverageForHorizontalScrolling;

  • trunk/Source/WebKit2/ChangeLog

    r161529 r161530  
     12014-01-08  Tim Horton  <timothy_horton@apple.com>
     2
     3        TileController can fail to receive exposedRect from the drawing area if set at the wrong time
     4        https://bugs.webkit.org/show_bug.cgi?id=126536
     5
     6        Reviewed by Simon Fraser.
     7
     8        * Configurations/WebKit2.xcconfig:
     9        * UIProcess/API/mac/WKView.mm:
     10        (-[WKView _updateViewExposedRect]):
     11        * UIProcess/DrawingAreaProxy.cpp:
     12        (WebKit::DrawingAreaProxy::DrawingAreaProxy):
     13        (WebKit::DrawingAreaProxy::setExposedRect):
     14        (WebKit::DrawingAreaProxy::exposedRectChangedTimerFired):
     15        * UIProcess/DrawingAreaProxy.h:
     16        (WebKit::DrawingAreaProxy::exposedRect):
     17        * UIProcess/WebPageProxy.cpp:
     18        (WebKit::WebPageProxy::WebPageProxy):
     19        (WebKit::WebPageProxy::close):
     20        * UIProcess/WebPageProxy.h:
     21        Move exposedRect stuff from WebPageProxy to DrawingAreaProxy.
     22
     23        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
     24        (WebKit::WebFrameLoaderClient::transitionToCommittedForNewPage):
     25        Push the exposedRect down into WebCore.
     26
     27        * WebProcess/WebPage/DrawingArea.h:
     28        * WebProcess/WebPage/DrawingArea.messages.in:
     29        * WebProcess/WebPage/WebPage.cpp:
     30        * WebProcess/WebPage/WebPage.h:
     31        * WebProcess/WebPage/WebPage.messages.in:
     32        * WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h:
     33        * WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:
     34        (WebKit::RemoteLayerTreeDrawingArea::RemoteLayerTreeDrawingArea):
     35        (WebKit::RemoteLayerTreeDrawingArea::updateScrolledExposedRect):
     36        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.h:
     37        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:
     38        (WebKit::TiledCoreAnimationDrawingArea::TiledCoreAnimationDrawingArea):
     39        (WebKit::TiledCoreAnimationDrawingArea::flushLayers):
     40        (WebKit::TiledCoreAnimationDrawingArea::updateScrolledExposedRect):
     41        (WebKit::TiledCoreAnimationDrawingArea::setRootCompositingLayer):
     42        (WebKit::TiledCoreAnimationDrawingArea::createPageOverlayLayer):
     43        (WebKit::TiledCoreAnimationDrawingArea::didCommitChangesForLayer):
     44        Get rid of "clipsToExposedRect", we just use infinite-ness of the rect
     45        to indicate that now.
     46        Don't scroll an infinite rect; it won't work.
     47
    1482014-01-08  Simon Fraser  <simon.fraser@apple.com>
    249

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

    r161452 r161530  
    391391        exposedRect = NSUnionRect(_data->_contentPreparationRect, exposedRect);
    392392
    393     _data->_page->viewExposedRectChanged(exposedRect, _data->_clipsToVisibleRect ? WebPageProxy::ClipsToExposedRect::Clip : WebPageProxy::ClipsToExposedRect::DoNotClip);
     393    _data->_page->drawingArea()->setExposedRect(_data->_clipsToVisibleRect ? FloatRect(exposedRect) : FloatRect::infiniteRect());
    394394}
    395395

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

    r161452 r161530  
    2727#include "DrawingAreaProxy.h"
    2828
     29#include "DrawingAreaMessages.h"
    2930#include "DrawingAreaProxyMessages.h"
    3031#include "WebPageProxy.h"
    … …  
    3940    , m_webPageProxy(webPageProxy)
    4041    , m_size(webPageProxy->viewSize())
     42#if PLATFORM(MAC)
     43    , m_exposedRectChangedTimer(this, &DrawingAreaProxy::exposedRectChangedTimerFired)
     44#endif
    4145{
    4246    m_webPageProxy->process().addMessageReceiver(Messages::DrawingAreaProxy::messageReceiverName(), webPageProxy->pageID(), *this);
    … …  
    5963}
    6064
     65#if PLATFORM(MAC)
     66void DrawingAreaProxy::setExposedRect(const FloatRect& exposedRect)
     67{
     68    if (!m_webPageProxy->isValid())
     69        return;
     70
     71    m_exposedRect = exposedRect;
     72
     73    if (!m_exposedRectChangedTimer.isActive())
     74        m_exposedRectChangedTimer.startOneShot(0);
     75}
     76
     77void DrawingAreaProxy::exposedRectChangedTimerFired(Timer<DrawingAreaProxy>*)
     78{
     79    if (!m_webPageProxy->isValid())
     80        return;
     81
     82    if (m_exposedRect == m_lastSentExposedRect)
     83        return;
     84
     85    m_webPageProxy->process().send(Messages::DrawingArea::SetExposedRect(m_exposedRect), m_webPageProxy->pageID());
     86    m_lastSentExposedRect = m_exposedRect;
     87}
     88#endif
     89
    6190} // namespace WebKit

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

    r161474 r161530  
    3030#include "DrawingAreaInfo.h"
    3131#include "MessageReceiver.h"
    32 #include <WebCore/FloatPoint.h>
     32#include <WebCore/FloatRect.h>
    3333#include <WebCore/IntRect.h>
    3434#include <WebCore/IntSize.h>
     35#include <WebCore/Timer.h>
    3536#include <chrono>
    3637#include <stdint.h>
    … …  
    7374    virtual void commitTransientZoom(double, WebCore::FloatPoint) { }
    7475
     76#if PLATFORM(MAC)
     77    void setExposedRect(const WebCore::FloatRect&);
     78    WebCore::FloatRect exposedRect() const { return m_exposedRect; }
     79    void exposedRectChangedTimerFired(WebCore::Timer<DrawingAreaProxy>*);
     80#endif
     81
    7582protected:
    7683    explicit DrawingAreaProxy(DrawingAreaType, WebPageProxy*);
    … …  
    101108    virtual void didUpdateGeometry() { }
    102109    virtual void intrinsicContentSizeDidChange(const WebCore::IntSize& newIntrinsicContentSize) { }
     110
     111    WebCore::Timer<DrawingAreaProxy> m_exposedRectChangedTimer;
     112    WebCore::FloatRect m_exposedRect;
     113    WebCore::FloatRect m_lastSentExposedRect;
    103114#endif
    104115};

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

    r161452 r161530  
    309309    , m_mayStartMediaWhenInWindow(true)
    310310    , m_waitingForDidUpdateViewState(false)
    311 #if PLATFORM(MAC)
    312     , m_exposedRectChangedTimer(this, &WebPageProxy::exposedRectChangedTimerFired)
    313     , m_clipsToExposedRect(ClipsToExposedRect::DoNotClip)
    314     , m_lastSentClipsToExposedRect(ClipsToExposedRect::DoNotClip)
    315 #endif
    316311    , m_scrollPinningBehavior(DoNotPin)
    317312{
    … …  
    561556#if ENABLE(CONTEXT_MENUS)
    562557    m_contextMenuClient.initialize(0);
    563 #endif
    564 
    565 #if PLATFORM(MAC) && !PLATFORM(IOS)
    566     m_exposedRectChangedTimer.stop();
    567558#endif
    568559
    … …  
    44214412}
    44224413
    4423 #if PLATFORM(MAC) || PLATFORM(IOS)
    4424 void WebPageProxy::viewExposedRectChanged(const FloatRect& exposedRect, ClipsToExposedRect clipsToExposedRect)
    4425 {
    4426     if (!isValid())
    4427         return;
    4428 
    4429     m_exposedRect = exposedRect;
    4430     m_clipsToExposedRect = clipsToExposedRect;
    4431 
    4432     if (!m_exposedRectChangedTimer.isActive())
    4433         m_exposedRectChangedTimer.startOneShot(0);
    4434 }
    4435 
    4436 void WebPageProxy::exposedRectChangedTimerFired(Timer<WebPageProxy>*)
    4437 {
    4438     if (!isValid())
    4439         return;
    4440 
    4441     if (m_exposedRect == m_lastSentExposedRect && m_clipsToExposedRect == m_lastSentClipsToExposedRect)
    4442         return;
    4443 
    4444     process().send(Messages::WebPage::ViewExposedRectChanged(m_exposedRect, m_clipsToExposedRect == ClipsToExposedRect::Clip), m_pageID);
    4445     m_lastSentExposedRect = m_exposedRect;
    4446     m_lastSentClipsToExposedRect = m_clipsToExposedRect;
    4447 }
    4448 #endif
    4449 
    44504414} // namespace WebKit

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

    r161452 r161530  
    473473#if PLATFORM(MAC)
    474474    void windowAndViewFramesChanged(const WebCore::FloatRect& viewFrameInWindowCoordinates, const WebCore::FloatPoint& accessibilityViewCoordinates);
    475     enum class ClipsToExposedRect { DoNotClip, Clip };
    476     void viewExposedRectChanged(const WebCore::FloatRect& exposedRect, ClipsToExposedRect);
    477     WebCore::FloatRect viewExposedRect() const { return m_exposedRect; }
    478     void exposedRectChangedTimerFired(WebCore::Timer<WebPageProxy>*);
    479475    void setMainFrameIsScrollable(bool);
    480476
    … …  
    13751371
    13761372#if PLATFORM(MAC)
    1377     WebCore::Timer<WebPageProxy> m_exposedRectChangedTimer;
    1378     WebCore::FloatRect m_exposedRect;
    1379     WebCore::FloatRect m_lastSentExposedRect;
    1380     ClipsToExposedRect m_clipsToExposedRect;
    1381     ClipsToExposedRect m_lastSentClipsToExposedRect;
    1382 #endif
    1383 
    1384 #if PLATFORM(MAC)
    13851373    HashMap<String, String> m_temporaryPDFFiles;
    13861374#endif

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp

    r161452 r161530  
    12391239    m_frame->coreFrame()->view()->setProhibitsScrolling(shouldDisableScrolling);
    12401240    m_frame->coreFrame()->view()->setVisualUpdatesAllowedByClient(!webPage->shouldExtendIncrementalRenderingSuppression());
     1241    m_frame->coreFrame()->view()->setExposedRect(webPage->drawingArea()->exposedRect());
    12411242#if PLATFORM(IOS)
    12421243    m_frame->coreFrame()->view()->setDelegatesScrolling(true);

  • trunk/Source/WebKit2/WebProcess/WebPage/DrawingArea.h

    r161452 r161530  
    2929#include "DrawingAreaInfo.h"
    3030#include "LayerTreeContext.h"
    31 #include <WebCore/FloatPoint.h>
     31#include <WebCore/FloatRect.h>
    3232#include <WebCore/IntRect.h>
    3333#include <WebCore/ViewState.h>
    … …  
    8787    virtual void mainFrameContentSizeChanged(const WebCore::IntSize&) { }
    8888
    89     virtual void setExposedRect(const WebCore::FloatRect&) { }
    90     virtual void setClipsToExposedRect(bool) { }
     89    virtual void setExposedRect(const WebCore::FloatRect&) = 0;
     90    virtual WebCore::FloatRect exposedRect() const = 0;
    9191    virtual void mainFrameScrollabilityChanged(bool) { }
    9292

  • trunk/Source/WebKit2/WebProcess/WebPage/DrawingArea.messages.in

    r161452 r161530  
    3030    SetDeviceScaleFactor(float deviceScaleFactor)
    3131    SetColorSpace(WebKit::ColorSpaceData colorSpace)
    32    
     32    SetExposedRect(WebCore::FloatRect exposedRect)
     33
    3334    AdjustTransientZoom(double scale, WebCore::FloatPoint origin)
    3435    CommitTransientZoom(double scale, WebCore::FloatPoint origin)

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r161452 r161530  
    30763076#endif
    30773077
    3078 void WebPage::viewExposedRectChanged(const FloatRect& exposedRect, bool clipsToExposedRect)
    3079 {
    3080     m_drawingArea->setExposedRect(exposedRect);
    3081     m_drawingArea->setClipsToExposedRect(clipsToExposedRect);
    3082 }
    3083 
    30843078void WebPage::setMainFrameIsScrollable(bool isScrollable)
    30853079{

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.h

    r161452 r161530  
    803803#endif
    804804
    805     void viewExposedRectChanged(const WebCore::FloatRect& exposedRect, bool clipsToExposedRect);
    806805    void setMainFrameIsScrollable(bool);
    807806

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.messages.in

    r161452 r161530  
    269269
    270270    WindowAndViewFramesChanged(WebCore::FloatRect windowFrameInScreenCoordinates, WebCore::FloatRect windowFrameInUnflippedScreenCoordinates, WebCore::FloatRect viewFrameInWindowCoordinates, WebCore::FloatPoint accessibilityViewCoordinates)
    271     ViewExposedRectChanged(WebCore::FloatRect exposedRect, bool clipsToExposedRect)
    272271    SetMainFrameIsScrollable(bool isScrollable)
    273272    RegisterUIProcessAccessibilityTokens(IPC::DataReference elemenToken, IPC::DataReference windowToken)

  • trunk/Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h

    r161452 r161530  
    7373
    7474    virtual void setExposedRect(const WebCore::FloatRect&) OVERRIDE;
    75     virtual void setClipsToExposedRect(bool) OVERRIDE;
     75    virtual WebCore::FloatRect exposedRect() const OVERRIDE { return m_scrolledExposedRect; }
    7676
    7777    // WebCore::GraphicsLayerClient
    … …  
    8686#endif
    8787
    88     void updateMainFrameClipsToExposedRect();
    8988    void updateScrolledExposedRect();
    9089
    … …  
    103102    WebCore::FloatRect m_exposedRect;
    104103    WebCore::FloatRect m_scrolledExposedRect;
    105     bool m_clipsToExposedRect;
    106104
    107105    WebCore::Timer<RemoteLayerTreeDrawingArea> m_layerFlushTimer;

  • trunk/Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm

    r161452 r161530  
    4747    : DrawingArea(DrawingAreaTypeRemoteLayerTree, webPage)
    4848    , m_remoteLayerTreeContext(std::make_unique<RemoteLayerTreeContext>(webPage))
    49     , m_clipsToExposedRect(false)
     49    , m_exposedRect(FloatRect::infiniteRect())
     50    , m_scrolledExposedRect(FloatRect::infiniteRect())
    5051    , m_layerFlushTimer(this, &RemoteLayerTreeDrawingArea::layerFlushTimerFired)
    5152    , m_isFlushingSuspended(false)
    … …  
    5556#if PLATFORM(IOS)
    5657    webPage->corePage()->settings().setDelegatesPageScaling(true);
    57     setClipsToExposedRect(true);
    5858#endif
    5959}
    … …  
    235235}
    236236
    237 void RemoteLayerTreeDrawingArea::setClipsToExposedRect(bool clipsToExposedRect)
    238 {
    239     m_clipsToExposedRect = clipsToExposedRect;
    240     updateScrolledExposedRect();
    241     updateMainFrameClipsToExposedRect();
    242 }
    243 
    244237void RemoteLayerTreeDrawingArea::updateScrolledExposedRect()
    245238{
    246     if (!m_clipsToExposedRect)
    247         return;
    248 
    249239    FrameView* frameView = m_webPage->corePage()->mainFrame().view();
    250240    if (!frameView)
    … …  
    254244
    255245#if !PLATFORM(IOS)
    256     IntPoint scrollPositionWithOrigin = frameView->scrollPosition() + toIntSize(frameView->scrollOrigin());
    257     m_scrolledExposedRect.moveBy(scrollPositionWithOrigin);
     246    if (!m_exposedRect.isInfinite()) {
     247        IntPoint scrollPositionWithOrigin = frameView->scrollPosition() + toIntSize(frameView->scrollOrigin());
     248        m_scrolledExposedRect.moveBy(scrollPositionWithOrigin);
     249    }
    258250#endif
    259251
    260     mainFrameTiledBacking()->setExposedRect(m_scrolledExposedRect);
    261 
    262     for (auto it = m_pageOverlayLayers.begin(), end = m_pageOverlayLayers.end(); it != end; ++it) {
    263         if (TiledBacking* tiledBacking = it->value->tiledBacking())
     252    frameView->setExposedRect(m_scrolledExposedRect);
     253
     254    for (const auto& layer : m_pageOverlayLayers.values()) {
     255        if (TiledBacking* tiledBacking = layer->tiledBacking())
    264256            tiledBacking->setExposedRect(m_scrolledExposedRect);
    265257    }
    266 }
    267 
    268 void RemoteLayerTreeDrawingArea::updateMainFrameClipsToExposedRect()
    269 {
    270     if (TiledBacking* tiledBacking = mainFrameTiledBacking())
    271         tiledBacking->setClipsToExposedRect(m_clipsToExposedRect);
    272 
    273     for (auto it = m_pageOverlayLayers.begin(), end = m_pageOverlayLayers.end(); it != end; ++it)
    274         if (TiledBacking* tiledBacking = it->value->tiledBacking())
    275             tiledBacking->setClipsToExposedRect(m_clipsToExposedRect);
    276 
    277     FrameView* frameView = m_webPage->corePage()->mainFrame().view();
    278     if (!frameView)
    279         return;
    280258   
    281259    frameView->adjustTiledBackingCoverage();

  • trunk/Source/WebKit2/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.h

    r161452 r161530  
    7979
    8080    virtual void setExposedRect(const WebCore::FloatRect&) OVERRIDE;
    81     virtual void setClipsToExposedRect(bool) OVERRIDE;
     81    virtual WebCore::FloatRect exposedRect() const OVERRIDE { return m_scrolledExposedRect; }
     82
    8283    virtual bool supportsAsyncScrolling() OVERRIDE { return true; }
    8384
    … …  
    120121
    121122    void updateIntrinsicContentSizeTimerFired(WebCore::Timer<TiledCoreAnimationDrawingArea>*);
    122     void updateMainFrameClipsToExposedRect();
    123123    void updateScrolledExposedRect();
    124124   
    … …  
    144144    WebCore::FloatRect m_exposedRect;
    145145    WebCore::FloatRect m_scrolledExposedRect;
    146     bool m_clipsToExposedRect;
    147146
    148147    WebCore::IntSize m_lastSentIntrinsicContentSize;

  • trunk/Source/WebKit2/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm

    r161452 r161530  
    7272    , m_layerFlushScheduler(this)
    7373    , m_isPaintingSuspended(!(parameters.viewState & ViewState::IsVisible))
    74     , m_clipsToExposedRect(false)
     74    , m_exposedRect(FloatRect::infiniteRect())
     75    , m_scrolledExposedRect(FloatRect::infiniteRect())
    7576    , m_updateIntrinsicContentSizeTimer(this, &TiledCoreAnimationDrawingArea::updateIntrinsicContentSizeTimerFired)
    7677    , m_transientZoomScale(1)
    … …  
    375376    }
    376377
    377     IntRect visibleRect = enclosingIntRect(m_rootLayer.get().frame);
    378     if (m_clipsToExposedRect)
    379         visibleRect.intersect(enclosingIntRect(m_scrolledExposedRect));
     378    FloatRect visibleRect = [m_rootLayer frame];
     379    visibleRect.intersect(m_scrolledExposedRect);
    380380
    381381    for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(), end = m_pageOverlayLayers.end(); it != end; ++it) {
    … …  
    428428}
    429429
    430 void TiledCoreAnimationDrawingArea::setClipsToExposedRect(bool clipsToExposedRect)
    431 {
    432     m_clipsToExposedRect = clipsToExposedRect;
    433     updateScrolledExposedRect();
    434     updateMainFrameClipsToExposedRect();
    435 }
    436 
    437430void TiledCoreAnimationDrawingArea::updateScrolledExposedRect()
    438431{
    439     if (!m_clipsToExposedRect)
    440         return;
    441 
    442432    FrameView* frameView = m_webPage->corePage()->mainFrame().view();
    443433    if (!frameView)
    444434        return;
    445435
    446     IntPoint scrollPositionWithOrigin = frameView->scrollPosition() + toIntSize(frameView->scrollOrigin());
    447 
    448436    m_scrolledExposedRect = m_exposedRect;
    449     m_scrolledExposedRect.moveBy(scrollPositionWithOrigin);
    450 
    451     mainFrameTiledBacking()->setExposedRect(m_scrolledExposedRect);
    452 
    453     for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(), end = m_pageOverlayLayers.end(); it != end; ++it) {
    454         if (TiledBacking* tiledBacking = it->value->tiledBacking())
     437
     438#if !PLATFORM(IOS)
     439    if (!m_exposedRect.isInfinite()) {
     440        IntPoint scrollPositionWithOrigin = frameView->scrollPosition() + toIntSize(frameView->scrollOrigin());
     441        m_scrolledExposedRect.moveBy(scrollPositionWithOrigin);
     442    }
     443#endif
     444
     445    frameView->setExposedRect(m_scrolledExposedRect);
     446
     447    for (const auto& layer : m_pageOverlayLayers.values()) {
     448        if (TiledBacking* tiledBacking = layer->tiledBacking())
    455449            tiledBacking->setExposedRect(m_scrolledExposedRect);
    456450    }
     451
     452    frameView->adjustTiledBackingCoverage();
    457453}
    458454
    … …  
    561557}
    562558
    563 void TiledCoreAnimationDrawingArea::updateMainFrameClipsToExposedRect()
    564 {
    565     if (TiledBacking* tiledBacking = mainFrameTiledBacking())
    566         tiledBacking->setClipsToExposedRect(m_clipsToExposedRect);
    567 
    568     for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(), end = m_pageOverlayLayers.end(); it != end; ++it)
    569         if (TiledBacking* tiledBacking = it->value->tiledBacking())
    570             tiledBacking->setClipsToExposedRect(m_clipsToExposedRect);
    571 
    572     FrameView* frameView = m_webPage->corePage()->mainFrame().view();
    573     if (!frameView)
    574         return;
    575 
    576     frameView->adjustTiledBackingCoverage();
    577 }
    578 
    579559void TiledCoreAnimationDrawingArea::setRootCompositingLayer(CALayer *layer)
    580560{
    … …  
    595575        [m_rootLayer.get() addSublayer:it->value->platformLayer()];
    596576
    597     if (TiledBacking* tiledBacking = mainFrameTiledBacking()) {
     577    if (TiledBacking* tiledBacking = mainFrameTiledBacking())
    598578        tiledBacking->setAggressivelyRetainsTiles(m_webPage->corePage()->settings().aggressiveTileRetentionEnabled());
    599         tiledBacking->setExposedRect(m_scrolledExposedRect);
    600     }
    601 
    602     updateMainFrameClipsToExposedRect();
    603579
    604580    updateDebugInfoLayer(m_webPage->corePage()->settings().showTiledScrollingIndicator());
    … …  
    620596    m_pageOverlayPlatformLayers.set(layer.get(), layer->platformLayer());
    621597
    622     if (TiledBacking* tiledBacking = layer->tiledBacking()) {
    623         tiledBacking->setExposedRect(m_scrolledExposedRect);
    624         tiledBacking->setClipsToExposedRect(m_clipsToExposedRect);
    625     }
    626 
    627598    [CATransaction begin];
    628599    [CATransaction setDisableActions:YES];
    … …  
    667638
    668639    [CATransaction commit];
    669 
    670     if (TiledBacking* tiledBacking = layer->tiledBacking()) {
    671         tiledBacking->setExposedRect(m_scrolledExposedRect);
    672         tiledBacking->setClipsToExposedRect(m_clipsToExposedRect);
    673     }
    674640
    675641    m_pageOverlayPlatformLayers.set(layer, layer->platformLayer());
Note: See TracChangeset for help on using the changeset viewer.