Changeset 167152 in webkit


Ignore:
Timestamp:
Apr 11, 2014 2:41:28 PM (10 years ago)
Author:
timothy_horton@apple.com
Message:

Support document-relative and custom-frame page overlays
​https://bugs.webkit.org/show_bug.cgi?id=131560
<rdar://problem/16595556>

Reviewed by Simon Fraser.

Add "document-relative" overlays, which attach to (and scroll with) the document,
and can be given a frame rect within the document to avoid overallocation of backing store.

  • WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:

(WebKit::WebFrameLoaderClient::didChangeScrollOffset):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::mainFrame):
(WebKit::WebPage::mainFrameView):
(WebKit::WebPage::didChangeScrollOffsetForFrame):

  • WebProcess/WebPage/WebPage.h:

Let the PageOverlayController know *which* frame scrolled, instead of "any frame".

  • WebProcess/WebPage/FindController.cpp:

(WebKit::FindController::updateFindUIAfterPageScroll):
Factor out shared code.

(WebKit::FindController::willMoveToWebPage):
(WebKit::FindController::drawRect):
We can use clearRect() instead of a transparency layer and fillRect().
I've looked through all the other overlay clients I know of and none of them
depend on having a transparency layer at the overlay level.

  • WebProcess/WebPage/PageOverlay.cpp:

(WebKit::PageOverlay::create):
(WebKit::PageOverlay::PageOverlay):
(WebKit::PageOverlay::bounds):
(WebKit::PageOverlay::frame):
(WebKit::PageOverlay::setFrame):
(WebKit::PageOverlay::drawRect):
Add OverlayType, which allows creation of Document or View relative overlays.
All overlays up to this point are View relative, so we default to that.
Document-relative overlays scroll with the page instead of repainting as
the page scrolls. They can also be given an explicit frame, allowing them
to be smaller than the entire document.

  • WebProcess/WebPage/PageOverlay.h:

(WebKit::PageOverlay::overlayType):
(WebKit::PageOverlay::webPage):
(WebKit::PageOverlay::client): Deleted.

  • WebProcess/WebPage/PageOverlayController.cpp:

(WebKit::PageOverlayController::initialize):
(WebKit::PageOverlayController::installPageOverlay):
(WebKit::PageOverlayController::uninstallPageOverlay):
(WebKit::PageOverlayController::updateForceSynchronousScrollLayerPositionUpdates):
(WebKit::updateOverlayGeometry):
(WebKit::PageOverlayController::setPageOverlayNeedsDisplay):
(WebKit::PageOverlayController::didChangeViewSize):
(WebKit::PageOverlayController::didChangeDocumentSize):
(WebKit::PageOverlayController::didChangeDeviceScaleFactor):
(WebKit::PageOverlayController::didScrollFrame):
(WebKit::PageOverlayController::flushPageOverlayLayers):
(WebKit::PageOverlayController::didChangeOverlayFrame):
Keep two overlay root layers - one for view-relative
and one for document-relative overlays.
Don't force synchronous scrolling if we only have document-relative overlays.
Update the overlay's position as well as its size whenever necessary.
Update document-relative overlay geometry when the document size changes.
Only explicitly flush view-relative overlays; document-relative ones
are plugged into the WebCore layer tree and flushed along with the page.

  • WebProcess/WebPage/PageOverlayController.h:

(WebKit::PageOverlayController::documentOverlayRootLayer):
(WebKit::PageOverlayController::viewOverlayRootLayer):

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

(WebKit::RemoteLayerTreeDrawingArea::setRootCompositingLayer):
(WebKit::RemoteLayerTreeDrawingArea::mainFrameContentSizeChanged):

  • WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:

(WebKit::TiledCoreAnimationDrawingArea::mainFrameContentSizeChanged):
(WebKit::TiledCoreAnimationDrawingArea::setRootCompositingLayer):
Let the PageOverlay controller know when the document size changes.
When we set up compositing, push the document overlay root layer
down into WebCore.

  • WebCore.exp.in:
  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::RenderLayerCompositor):
(WebCore::RenderLayerCompositor::rebuildCompositingLayerTree):
(WebCore::RenderLayerCompositor::setDocumentOverlayRootLayer):

  • rendering/RenderLayerCompositor.h:

Add the concept of a document overlay layer, which is plugged in as the
last child of the root content layer. Expose it to WebKit2.

Location:
trunk/Source
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r167151 r167152  
     12014-04-11  Tim Horton  <timothy_horton@apple.com>
     2
     3        Support document-relative and custom-frame page overlays
     4        https://bugs.webkit.org/show_bug.cgi?id=131560
     5        <rdar://problem/16595556>
     6
     7        Reviewed by Simon Fraser.
     8
     9        * WebCore.exp.in:
     10        * rendering/RenderLayerCompositor.cpp:
     11        (WebCore::RenderLayerCompositor::RenderLayerCompositor):
     12        (WebCore::RenderLayerCompositor::rebuildCompositingLayerTree):
     13        (WebCore::RenderLayerCompositor::setDocumentOverlayRootLayer):
     14        * rendering/RenderLayerCompositor.h:
     15        Add the concept of a document overlay layer, which is plugged in as the
     16        last child of the root content layer. Expose it to WebKit2.
     17
    1182014-04-09  Myles C. Maxfield  <mmaxfield@apple.com>
    219

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

    r167138 r167152  
    869869__ZN7WebCore21PlatformKeyboardEvent24disambiguateKeyDownEventENS_13PlatformEvent4TypeEb
    870870__ZN7WebCore21RemoteCommandListener6createERNS_27RemoteCommandListenerClientE
     871__ZN7WebCore21RenderLayerCompositor27setDocumentOverlayRootLayerEPNS_13GraphicsLayerE
    871872__ZN7WebCore21ResourceLoadScheduler20servePendingRequestsENS_20ResourceLoadPriorityE
    872873__ZN7WebCore21ResourceLoadScheduler20servePendingRequestsEPNS0_15HostInformationENS_20ResourceLoadPriorityE

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

    r167138 r167152  
    256256    , m_layersWithTiledBackingCount(0)
    257257    , m_rootLayerAttachment(RootLayerUnattached)
     258    , m_documentOverlayRootLayer(nullptr)
    258259    , m_layerFlushTimer(this, &RenderLayerCompositor::layerFlushTimerFired)
    259260    , m_layerFlushThrottlingEnabled(page() && page()->progress().isMainLoadProgressing())
    … …  
    14611462        childLayersOfEnclosingLayer.append(layerBacking->childForSuperlayers());
    14621463    }
     1464
     1465    if (m_documentOverlayRootLayer)
     1466        childLayersOfEnclosingLayer.append(m_documentOverlayRootLayer);
    14631467}
    14641468
    … …  
    38113815}
    38123816
     3817void RenderLayerCompositor::setDocumentOverlayRootLayer(GraphicsLayer* documentOverlayRootLayer)
     3818{
     3819    if (m_documentOverlayRootLayer)
     3820        m_documentOverlayRootLayer->removeFromParent();
     3821    m_documentOverlayRootLayer = documentOverlayRootLayer;
     3822    scheduleCompositingLayerUpdate();
     3823}
     3824
    38133825} // namespace WebCore

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.h

    r167138 r167152  
    305305    Color rootExtendedBackgroundColor() const { return m_rootExtendedBackgroundColor; }
    306306
     307    void setDocumentOverlayRootLayer(GraphicsLayer*);
     308
    307309private:
    308310    class OverlapMap;
    … …  
    507509#endif
    508510
     511    GraphicsLayer* m_documentOverlayRootLayer;
     512
    509513    std::unique_ptr<GraphicsLayerUpdater> m_layerUpdater; // Updates tiled layer visible area periodically while animations are running.
    510514

  • trunk/Source/WebKit2/ChangeLog

    r167143 r167152  
     12014-04-11  Tim Horton  <timothy_horton@apple.com>
     2
     3        Support document-relative and custom-frame page overlays
     4        https://bugs.webkit.org/show_bug.cgi?id=131560
     5        <rdar://problem/16595556>
     6
     7        Reviewed by Simon Fraser.
     8
     9        Add "document-relative" overlays, which attach to (and scroll with) the document,
     10        and can be given a frame rect within the document to avoid overallocation of backing store.
     11
     12        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
     13        (WebKit::WebFrameLoaderClient::didChangeScrollOffset):
     14        * WebProcess/WebPage/WebPage.cpp:
     15        (WebKit::WebPage::mainFrame):
     16        (WebKit::WebPage::mainFrameView):
     17        (WebKit::WebPage::didChangeScrollOffsetForFrame):
     18        * WebProcess/WebPage/WebPage.h:
     19        Let the PageOverlayController know *which* frame scrolled, instead of "any frame".
     20
     21        * WebProcess/WebPage/FindController.cpp:
     22        (WebKit::FindController::updateFindUIAfterPageScroll):
     23        Factor out shared code.
     24
     25        (WebKit::FindController::willMoveToWebPage):
     26        (WebKit::FindController::drawRect):
     27        We can use clearRect() instead of a transparency layer and fillRect().
     28        I've looked through all the other overlay clients I know of and none of them
     29        depend on having a transparency layer at the overlay level.
     30
     31        * WebProcess/WebPage/PageOverlay.cpp:
     32        (WebKit::PageOverlay::create):
     33        (WebKit::PageOverlay::PageOverlay):
     34        (WebKit::PageOverlay::bounds):
     35        (WebKit::PageOverlay::frame):
     36        (WebKit::PageOverlay::setFrame):
     37        (WebKit::PageOverlay::drawRect):
     38        Add OverlayType, which allows creation of Document or View relative overlays.
     39        All overlays up to this point are View relative, so we default to that.
     40        Document-relative overlays scroll with the page instead of repainting as
     41        the page scrolls. They can also be given an explicit frame, allowing them
     42        to be smaller than the entire document.
     43
     44        * WebProcess/WebPage/PageOverlay.h:
     45        (WebKit::PageOverlay::overlayType):
     46        (WebKit::PageOverlay::webPage):
     47        (WebKit::PageOverlay::client): Deleted.
     48        * WebProcess/WebPage/PageOverlayController.cpp:
     49        (WebKit::PageOverlayController::initialize):
     50        (WebKit::PageOverlayController::installPageOverlay):
     51        (WebKit::PageOverlayController::uninstallPageOverlay):
     52        (WebKit::PageOverlayController::updateForceSynchronousScrollLayerPositionUpdates):
     53        (WebKit::updateOverlayGeometry):
     54        (WebKit::PageOverlayController::setPageOverlayNeedsDisplay):
     55        (WebKit::PageOverlayController::didChangeViewSize):
     56        (WebKit::PageOverlayController::didChangeDocumentSize):
     57        (WebKit::PageOverlayController::didChangeDeviceScaleFactor):
     58        (WebKit::PageOverlayController::didScrollFrame):
     59        (WebKit::PageOverlayController::flushPageOverlayLayers):
     60        (WebKit::PageOverlayController::didChangeOverlayFrame):
     61        Keep two overlay root layers - one for view-relative
     62        and one for document-relative overlays.
     63        Don't force synchronous scrolling if we only have document-relative overlays.
     64        Update the overlay's position as well as its size whenever necessary.
     65        Update document-relative overlay geometry when the document size changes.
     66        Only explicitly flush view-relative overlays; document-relative ones
     67        are plugged into the WebCore layer tree and flushed along with the page.
     68
     69        * WebProcess/WebPage/PageOverlayController.h:
     70        (WebKit::PageOverlayController::documentOverlayRootLayer):
     71        (WebKit::PageOverlayController::viewOverlayRootLayer):
     72        * WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h:
     73        * WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:
     74        (WebKit::RemoteLayerTreeDrawingArea::setRootCompositingLayer):
     75        (WebKit::RemoteLayerTreeDrawingArea::mainFrameContentSizeChanged):
     76        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:
     77        (WebKit::TiledCoreAnimationDrawingArea::mainFrameContentSizeChanged):
     78        (WebKit::TiledCoreAnimationDrawingArea::setRootCompositingLayer):
     79        Let the PageOverlay controller know when the document size changes.
     80        When we set up compositing, push the document overlay root layer
     81        down into WebCore.
     82
    1832014-04-11  Pratik Solanki  <psolanki@apple.com>
    284

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

    r166976 r167152  
    15801580        return;
    15811581
    1582     webPage->didChangeScrollOffsetForAnyFrame();
    1583 
    1584     if (!m_frame->isMainFrame())
    1585         return;
    1586 
    1587     // If this is called when tearing down a FrameView, the WebCore::Frame's
    1588     // current FrameView will be null.
    1589     if (!m_frame->coreFrame()->view())
    1590         return;
    1591 
    1592     webPage->updateMainFrameScrollOffsetPinning();
     1582    webPage->didChangeScrollOffsetForFrame(m_frame->coreFrame());
    15931583}
    15941584

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

    r167099 r167152  
    163163            m_findPageOverlay = findPageOverlay.get();
    164164            m_webPage->installPageOverlay(findPageOverlay.release(), PageOverlay::FadeMode::Fade);
    165             m_findPageOverlay->setNeedsDisplay();
    166         } else
    167             m_findPageOverlay->setNeedsDisplay();
     165        }
     166        m_findPageOverlay->setNeedsDisplay();
    168167    }
    169168}
    … …  
    395394static const float overlayBackgroundAlpha = 0.25;
    396395
    397 void FindController::drawRect(PageOverlay* /*pageOverlay*/, GraphicsContext& graphicsContext, const IntRect& dirtyRect)
     396void FindController::drawRect(PageOverlay*, GraphicsContext& graphicsContext, const IntRect& dirtyRect)
    398397{
    399398    Color overlayBackgroundColor(overlayBackgroundRed, overlayBackgroundGreen, overlayBackgroundBlue, overlayBackgroundAlpha);
    … …  
    414413            IntRect whiteFrameRect = rects[i];
    415414            whiteFrameRect.inflate(1);
    416 
    417415            graphicsContext.fillRect(whiteFrameRect);
    418416        }
    419417    }
    420418
    421     graphicsContext.setFillColor(Color::transparent, ColorSpaceSRGB);
    422 
    423419    // Clear out the holes.
    424420    for (size_t i = 0; i < rects.size(); ++i)
    425         graphicsContext.fillRect(rects[i]);
     421        graphicsContext.clearRect(rects[i]);
    426422
    427423    if (!m_isShowingFindIndicator)

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

    r166975 r167152  
    4343static const double fadeAnimationFrameRate = 30;
    4444
    45 PassRefPtr<PageOverlay> PageOverlay::create(Client* client)
    46 {
    47     return adoptRef(new PageOverlay(client));
    48 }
    49 
    50 PageOverlay::PageOverlay(Client* client)
     45PassRefPtr<PageOverlay> PageOverlay::create(Client* client, OverlayType overlayType)
     46{
     47    return adoptRef(new PageOverlay(client, overlayType));
     48}
     49
     50PageOverlay::PageOverlay(Client* client, OverlayType overlayType)
    5151    : m_client(client)
    5252    , m_webPage(0)
    … …  
    5656    , m_fadeAnimationType(NoAnimation)
    5757    , m_fractionFadedIn(1.0)
     58    , m_overlayType(overlayType)
    5859{
    5960}
    … …  
    6566IntRect PageOverlay::bounds() const
    6667{
    67     FrameView* frameView = m_webPage->corePage()->mainFrame().view();
    68 
    69     int width = frameView->width();
    70     int height = frameView->height();
    71 
    72     if (!ScrollbarTheme::theme()->usesOverlayScrollbars()) {
    73         if (frameView->verticalScrollbar())
    74             width -= frameView->verticalScrollbar()->width();
    75         if (frameView->horizontalScrollbar())
    76             height -= frameView->horizontalScrollbar()->height();
    77     }   
    78     return IntRect(0, 0, width, height);
     68    if (!m_overrideFrame.isEmpty())
     69        return IntRect(IntPoint(), m_overrideFrame.size());
     70
     71    FrameView* frameView = m_webPage->mainFrameView();
     72
     73    switch (m_overlayType) {
     74    case OverlayType::View: {
     75        int width = frameView->width();
     76        int height = frameView->height();
     77
     78        if (!ScrollbarTheme::theme()->usesOverlayScrollbars()) {
     79            if (frameView->verticalScrollbar())
     80                width -= frameView->verticalScrollbar()->width();
     81            if (frameView->horizontalScrollbar())
     82                height -= frameView->horizontalScrollbar()->height();
     83        }
     84        return IntRect(0, 0, width, height);
     85    }
     86    case OverlayType::Document:
     87        return IntRect(IntPoint(), frameView->contentsSize());
     88    };
     89}
     90
     91IntRect PageOverlay::frame() const
     92{
     93    if (!m_overrideFrame.isEmpty())
     94        return m_overrideFrame;
     95
     96    return bounds();
     97}
     98
     99void PageOverlay::setFrame(IntRect frame)
     100{
     101    m_overrideFrame = frame;
     102
     103    if (m_webPage)
     104        m_webPage->pageOverlayController().didChangeOverlayFrame(this);
    79105}
    80106
    … …  
    109135
    110136    GraphicsContextStateSaver stateSaver(graphicsContext);
    111     graphicsContext.beginTransparencyLayer(1);
    112     graphicsContext.setCompositeOperation(CompositeCopy);
    113 
    114137    m_client->drawRect(this, graphicsContext, paintRect);
    115 
    116     graphicsContext.endTransparencyLayer();
    117138}
    118139   

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

    r166975 r167152  
    2929#include "APIObject.h"
    3030#include "WKBase.h"
     31#include <WebCore/IntRect.h>
    3132#include <wtf/PassRefPtr.h>
    3233#include <wtf/RunLoop.h>
    3334
    3435namespace WebCore {
    35     class GraphicsContext;
    36     class IntPoint;
    37     class IntRect;
     36class GraphicsContext;
    3837}
    3938
    … …  
    6059    };
    6160
    62     static PassRefPtr<PageOverlay> create(Client*);
     61    enum class OverlayType {
     62        View, // Fixed to the view size; does not scale or scroll with the document, repaints on scroll.
     63        Document, // Scales and scrolls with the document.
     64    };
     65
     66    static PassRefPtr<PageOverlay> create(Client*, OverlayType = OverlayType::View);
    6367    virtual ~PageOverlay();
    6468
    … …  
    8286
    8387    enum class FadeMode { DoNotFade, Fade };
     88
     89    OverlayType overlayType() { return m_overlayType; }
     90
     91    WebCore::IntRect bounds() const;
     92    WebCore::IntRect frame() const;
     93    void setFrame(WebCore::IntRect);
    8494   
    8595protected:
    86     explicit PageOverlay(Client*);
     96    explicit PageOverlay(Client*, OverlayType);
    8797
    8898private:
    89     WebCore::IntRect bounds() const;
    90 
    9199    void startFadeAnimation();
    92100    void fadeAnimationTimerFired();
    … …  
    107115    FadeAnimationType m_fadeAnimationType;
    108116    float m_fractionFadedIn;
     117
     118    OverlayType m_overlayType;
     119    WebCore::IntRect m_overrideFrame;
    109120};
    110121

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

    r167002 r167152  
    3030#include "PageOverlay.h"
    3131#include "WebPage.h"
     32#include <WebCore/Frame.h>
    3233#include <WebCore/FrameView.h>
    3334#include <WebCore/GraphicsContext.h>
    3435#include <WebCore/GraphicsLayer.h>
     36#include <WebCore/MainFrame.h>
    3537#include <WebCore/ScrollingCoordinator.h>
    3638#include <WebCore/Settings.h>
    … …  
    4850void PageOverlayController::initialize()
    4951{
    50     ASSERT(!m_rootLayer);
    51 
    52     m_rootLayer = GraphicsLayer::create(m_webPage->drawingArea()->graphicsLayerFactory(), this);
     52    ASSERT(!m_documentOverlayRootLayer);
     53    ASSERT(!m_viewOverlayRootLayer);
     54
     55    m_documentOverlayRootLayer = GraphicsLayer::create(m_webPage->drawingArea()->graphicsLayerFactory(), this);
     56    m_viewOverlayRootLayer = GraphicsLayer::create(m_webPage->drawingArea()->graphicsLayerFactory(), this);
    5357#ifndef NDEBUG
    54     m_rootLayer->setName("Page Overlay container");
     58    m_documentOverlayRootLayer->setName("Page Overlay container (document-relative)");
     59    m_viewOverlayRootLayer->setName("Page Overlay container (view-relative)");
    5560#endif
    5661}
    … …  
    5863void PageOverlayController::installPageOverlay(PassRefPtr<PageOverlay> pageOverlay, PageOverlay::FadeMode fadeMode)
    5964{
    60     ASSERT(m_rootLayer);
     65    ASSERT(m_documentOverlayRootLayer);
     66    ASSERT(m_viewOverlayRootLayer);
    6167
    6268    RefPtr<PageOverlay> overlay = pageOverlay;
    … …  
    7278
    7379    std::unique_ptr<GraphicsLayer> layer = GraphicsLayer::create(m_webPage->drawingArea()->graphicsLayerFactory(), this);
     80    layer->setAnchorPoint(FloatPoint3D());
     81    layer->setPosition(overlay->frame().location());
    7482#ifndef NDEBUG
    7583    layer->setName("Page Overlay content");
    … …  
    7785
    7886    updateSettingsForLayer(layer.get());
    79     m_rootLayer->addChild(layer.get());
     87
     88    switch (overlay->overlayType()) {
     89    case PageOverlay::OverlayType::View:
     90        m_viewOverlayRootLayer->addChild(layer.get());
     91        break;
     92    case PageOverlay::OverlayType::Document:
     93        m_documentOverlayRootLayer->addChild(layer.get());
     94        break;
     95    }
     96
    8097    m_overlayGraphicsLayers.set(overlay.get(), std::move(layer));
    8198
    82 #if ENABLE(ASYNC_SCROLLING)
    83     if (Page* page = m_webPage->corePage()) {
    84         if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
    85             scrollingCoordinator->setForceSynchronousScrollLayerPositionUpdates(true);
    86     }
    87 #endif
     99    updateForceSynchronousScrollLayerPositionUpdates();
    88100}
    89101
    … …  
    103115    m_pageOverlays.remove(overlayIndex);
    104116
    105     if (!m_pageOverlays.isEmpty())
    106         return;
    107 
     117    updateForceSynchronousScrollLayerPositionUpdates();
     118}
     119
     120void PageOverlayController::updateForceSynchronousScrollLayerPositionUpdates()
     121{
    108122#if ENABLE(ASYNC_SCROLLING)
     123    bool forceSynchronousScrollLayerPositionUpdates = false;
     124
     125    for (auto& overlay : m_pageOverlays) {
     126        if (overlay->overlayType() == PageOverlay::OverlayType::View)
     127            forceSynchronousScrollLayerPositionUpdates = true;
     128    }
     129
    109130    if (Page* page = m_webPage->corePage()) {
    110131        if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
    111             scrollingCoordinator->setForceSynchronousScrollLayerPositionUpdates(false);
     132            scrollingCoordinator->setForceSynchronousScrollLayerPositionUpdates(forceSynchronousScrollLayerPositionUpdates);
    112133    }
    113134#endif
     135}
     136
     137static void updateOverlayGeometry(PageOverlay* overlay, GraphicsLayer* graphicsLayer)
     138{
     139    if (!graphicsLayer->drawsContent())
     140        return;
     141
     142    graphicsLayer->setPosition(overlay->frame().location());
     143    graphicsLayer->setSize(overlay->frame().size());
     144    graphicsLayer->setNeedsDisplay();
    114145}
    115146
    … …  
    122153    if (!graphicsLayer->drawsContent()) {
    123154        graphicsLayer->setDrawsContent(true);
    124         graphicsLayer->setSize(m_webPage->size());
    125     }
     155        updateOverlayGeometry(overlay, graphicsLayer);
     156    }
     157
    126158    graphicsLayer->setNeedsDisplayInRect(dirtyRect);
    127159}
    … …  
    148180void PageOverlayController::didChangeViewSize()
    149181{
    150     for (auto& graphicsLayer : m_overlayGraphicsLayers.values()) {
    151         if (!graphicsLayer->drawsContent())
    152             continue;
    153         graphicsLayer->setSize(m_webPage->size());
    154         graphicsLayer->setNeedsDisplay();
     182    for (auto& overlayAndLayer : m_overlayGraphicsLayers) {
     183        if (overlayAndLayer.key->overlayType() == PageOverlay::OverlayType::View)
     184            updateOverlayGeometry(overlayAndLayer.key, overlayAndLayer.value.get());
     185    }
     186}
     187
     188void PageOverlayController::didChangeDocumentSize()
     189{
     190    for (auto& overlayAndLayer : m_overlayGraphicsLayers) {
     191        if (overlayAndLayer.key->overlayType() == PageOverlay::OverlayType::Document)
     192            updateOverlayGeometry(overlayAndLayer.key, overlayAndLayer.value.get());
    155193    }
    156194}
    … …  
    164202void PageOverlayController::didChangeDeviceScaleFactor()
    165203{
    166     m_rootLayer->noteDeviceOrPageScaleFactorChangedIncludingDescendants();
    167     invalidateAllPageOverlayLayers();
    168 }
    169 
    170 void PageOverlayController::didChangeExposedRect()
    171 {
    172     m_webPage->drawingArea()->scheduleCompositingLayerFlush();
    173 }
    174 
    175 void PageOverlayController::didScrollAnyFrame()
    176 {
    177     invalidateAllPageOverlayLayers();
    178 }
    179 
    180 void PageOverlayController::invalidateAllPageOverlayLayers()
    181 {
     204    m_documentOverlayRootLayer->noteDeviceOrPageScaleFactorChangedIncludingDescendants();
     205    m_viewOverlayRootLayer->noteDeviceOrPageScaleFactorChangedIncludingDescendants();
     206
    182207    for (auto& graphicsLayer : m_overlayGraphicsLayers.values())
    183208        graphicsLayer->setNeedsDisplay();
    184209}
    185210
     211void PageOverlayController::didChangeExposedRect()
     212{
     213    m_webPage->drawingArea()->scheduleCompositingLayerFlush();
     214}
     215
     216void PageOverlayController::didScrollFrame(Frame* frame)
     217{
     218    for (auto& overlayAndLayer : m_overlayGraphicsLayers) {
     219        if (overlayAndLayer.key->overlayType() == PageOverlay::OverlayType::View || !frame->isMainFrame())
     220            overlayAndLayer.value->setNeedsDisplay();
     221    }
     222}
     223
    186224void PageOverlayController::flushPageOverlayLayers(FloatRect visibleRect)
    187225{
    188     m_rootLayer->flushCompositingState(visibleRect);
     226    m_viewOverlayRootLayer->flushCompositingState(visibleRect);
    189227}
    190228
    … …  
    260298}
    261299
     300void PageOverlayController::didChangeOverlayFrame(PageOverlay* overlay)
     301{
     302    ASSERT(m_pageOverlays.contains(overlay));
     303
     304    GraphicsLayer* graphicsLayer = m_overlayGraphicsLayers.get(overlay);
     305
     306    if (!graphicsLayer->drawsContent())
     307        return;
     308
     309    updateOverlayGeometry(overlay, graphicsLayer);
     310}
     311
    262312} // namespace WebKit

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

    r166975 r167152  
    3434#include <wtf/Vector.h>
    3535
     36namespace WebCore {
     37class Frame;
     38}
     39
    3640namespace WebKit {
    3741
    … …  
    4549    void initialize();
    4650
    47     WebCore::GraphicsLayer* rootLayer() const { return m_rootLayer.get(); }
     51    WebCore::GraphicsLayer* documentOverlayRootLayer() const { return m_documentOverlayRootLayer.get(); }
     52    WebCore::GraphicsLayer* viewOverlayRootLayer() const { return m_viewOverlayRootLayer.get(); }
    4853
    4954    void installPageOverlay(PassRefPtr<PageOverlay>, PageOverlay::FadeMode);
    … …  
    5560
    5661    void didChangeViewSize();
     62    void didChangeDocumentSize();
    5763    void didChangePreferences();
    5864    void didChangeDeviceScaleFactor();
    5965    void didChangeExposedRect();
    60     void didScrollAnyFrame();
     66    void didScrollFrame(WebCore::Frame*);
     67    void didChangeOverlayFrame(PageOverlay*);
    6168
    6269    void flushPageOverlayLayers(WebCore::FloatRect);
    … …  
    7077private:
    7178    void updateSettingsForLayer(WebCore::GraphicsLayer*);
    72     void invalidateAllPageOverlayLayers();
     79    void updateForceSynchronousScrollLayerPositionUpdates();
    7380
    7481    // WebCore::GraphicsLayerClient
    … …  
    7986    virtual void didCommitChangesForLayer(const WebCore::GraphicsLayer*) const override { }
    8087
    81     std::unique_ptr<WebCore::GraphicsLayer> m_rootLayer;
     88    std::unique_ptr<WebCore::GraphicsLayer> m_documentOverlayRootLayer;
     89    std::unique_ptr<WebCore::GraphicsLayer> m_viewOverlayRootLayer;
    8290    HashMap<PageOverlay*, std::unique_ptr<WebCore::GraphicsLayer>> m_overlayGraphicsLayers;
    8391    Vector<RefPtr<PageOverlay>> m_pageOverlays;

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

    r167099 r167152  
    38183818Frame* WebPage::mainFrame() const
    38193819{
    3820     return m_page ? &m_page->mainFrame() : 0;
     3820    return m_page ? &m_page->mainFrame() : nullptr;
    38213821}
    38223822
    … …  
    38263826        return frame->view();
    38273827   
    3828     return 0;
     3828    return nullptr;
    38293829}
    38303830
    … …  
    45074507#endif
    45084508
    4509 void WebPage::didChangeScrollOffsetForAnyFrame()
    4510 {
    4511     m_pageOverlayController.didScrollAnyFrame();
     4509void WebPage::didChangeScrollOffsetForFrame(Frame* frame)
     4510{
     4511    m_pageOverlayController.didScrollFrame(frame);
     4512
     4513    if (!frame->isMainFrame())
     4514        return;
     4515
     4516    // If this is called when tearing down a FrameView, the WebCore::Frame's
     4517    // current FrameView will be null.
     4518    if (!frame->view())
     4519        return;
     4520
     4521    updateMainFrameScrollOffsetPinning();
    45124522}
    45134523

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

    r167060 r167152  
    781781#endif
    782782
    783     void didChangeScrollOffsetForAnyFrame();
     783    void didChangeScrollOffsetForFrame(WebCore::Frame*);
    784784
    785785private:

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

    r166975 r167152  
    8282#endif
    8383
     84    virtual void mainFrameContentSizeChanged(const WebCore::IntSize&) override;
     85
    8486    void updateScrolledExposedRect();
    8587

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

    r166975 r167152  
    3939#import <WebCore/FrameView.h>
    4040#import <WebCore/MainFrame.h>
     41#import <WebCore/RenderLayerCompositor.h>
     42#import <WebCore/RenderView.h>
    4143#import <WebCore/Settings.h>
    4244#import <WebCore/TiledBacking.h>
    … …  
    9092    if (rootLayer) {
    9193        children.append(rootLayer);
    92         children.append(m_webPage->pageOverlayController().rootLayer());
     94        children.append(m_webPage->pageOverlayController().viewOverlayRootLayer());
    9395    }
    9496    m_rootLayer->setChildren(children);
     97
     98    m_webPage->mainFrameView()->renderView()->compositor().setDocumentOverlayRootLayer(m_webPage->pageOverlayController().documentOverlayRootLayer());
    9599}
    96100
    … …  
    294298}
    295299
     300void RemoteLayerTreeDrawingArea::mainFrameContentSizeChanged(const IntSize&)
     301{
     302    m_webPage->pageOverlayController().didChangeDocumentSize();
     303}
     304
    296305} // namespace WebKit

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

    r166975 r167152  
    202202void TiledCoreAnimationDrawingArea::mainFrameContentSizeChanged(const IntSize&)
    203203{
     204    m_webPage->pageOverlayController().didChangeDocumentSize();
     205
    204206    if (!m_webPage->minimumLayoutSize().width())
    205207        return;
    … …  
    446448    [CATransaction setDisableActions:YES];
    447449
    448     [m_hostingLayer setSublayers:layer ? @[ layer, m_webPage->pageOverlayController().rootLayer()->platformLayer() ] : @[ ]];
     450    [m_hostingLayer setSublayers:layer ? @[ layer, m_webPage->pageOverlayController().viewOverlayRootLayer()->platformLayer() ] : @[ ]];
     451
     452    m_webPage->mainFrameView()->renderView()->compositor().setDocumentOverlayRootLayer(m_webPage->pageOverlayController().documentOverlayRootLayer());
    449453
    450454    bool hadRootLayer = !!m_rootLayer;
Note: See TracChangeset for help on using the changeset viewer.