Changeset 156861 in webkit


Ignore:
Timestamp:
Oct 3, 2013 3:52:36 PM (11 years ago)
Author:
commit-queue@webkit.org
Message:

Create CoordinatedDrawingArea / CoordinatedDrawingAreaProxy
​https://bugs.webkit.org/show_bug.cgi?id=122207

Patch by Sergio Correia <Sergio Correia> on 2013-10-03
Reviewed by Anders Carlsson.

Since Apple are moving away from DrawingAreaImpl, Coordinated Graphics
should have its own drawing area.

  • CMakeLists.txt: Use CoordinatedDrawingArea and

CoordinatedDrawingAreaProxy instead of the DrawingAreaImpl /
DrawingAreaProxyImpl.

  • Shared/DrawingAreaInfo.h: Add DrawingAreaTypeCoordinated.
  • UIProcess/CoordinatedGraphics/CoordinatedDrawingAreaProxy.cpp:

Added, copied from DrawingAreaProxyImpl.cpp.

  • UIProcess/CoordinatedGraphics/CoordinatedDrawingAreaProxy.h: Added,

copied from DrawingAreaProxyImpl.h.

  • UIProcess/CoordinatedGraphics/WebView.cpp:

(WebKit::WebView::createDrawingAreaProxy): Use CoordinatedDrawingAreaProxy.

  • UIProcess/DrawingAreaProxyImpl.cpp: Remove Coordinated Graphics

bits.

  • UIProcess/DrawingAreaProxyImpl.h: Ditto.
  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedDrawingArea.cpp:

Added, copied from DrawingAreaImpl.cpp.

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedDrawingArea.h:

Added, copied from DrawingAreaImpl.h.

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp:

(WebKit::CoordinatedLayerTreeHost::performScheduledLayerFlush): Use
CoordinatedDrawingArea.

  • WebProcess/WebPage/DrawingArea.cpp:

(WebKit::DrawingArea::create): Handle the DrawingAreaTypeCoordinated
in the DrawingArea creation code.

  • WebProcess/WebPage/DrawingAreaImpl.cpp: Remove Coordinated Graphics

bits.

  • WebProcess/WebPage/DrawingAreaImpl.h: Ditto.
Location:
trunk/Source/WebKit2
Files:
10 edited
4 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/CMakeLists.txt

    r156265 r156861  
    260260    UIProcess/BackingStore.cpp
    261261    UIProcess/DrawingAreaProxy.cpp
    262     UIProcess/DrawingAreaProxyImpl.cpp
    263262    UIProcess/FindIndicator.cpp
    264263    UIProcess/GeolocationPermissionRequestManagerProxy.cpp
    … …  
    371370    UIProcess/Authentication/WebProtectionSpace.cpp
    372371
     372    UIProcess/CoordinatedGraphics/CoordinatedDrawingAreaProxy.cpp
    373373    UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.cpp
    374374    UIProcess/CoordinatedGraphics/WebPageProxyCoordinatedGraphics.cpp
    … …  
    502502    WebProcess/WebPage/DecoderAdapter.cpp
    503503    WebProcess/WebPage/DrawingArea.cpp
    504     WebProcess/WebPage/DrawingAreaImpl.cpp
    505504    WebProcess/WebPage/EncoderAdapter.cpp
    506505    WebProcess/WebPage/EventDispatcher.cpp
    … …  
    519518    WebProcess/WebPage/WebUndoStep.cpp
    520519
     520    WebProcess/WebPage/CoordinatedGraphics/CoordinatedDrawingArea.cpp
    521521    WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp
    522522    WebProcess/WebPage/CoordinatedGraphics/WebPageCoordinatedGraphics.cpp

  • trunk/Source/WebKit2/ChangeLog

    r156860 r156861  
     12013-10-03  Sergio Correia  <sergio.correia@openbossa.org>
     2
     3        Create CoordinatedDrawingArea / CoordinatedDrawingAreaProxy
     4        https://bugs.webkit.org/show_bug.cgi?id=122207
     5
     6        Reviewed by Anders Carlsson.
     7
     8        Since Apple are moving away from DrawingAreaImpl, Coordinated Graphics
     9        should have its own drawing area.
     10
     11        * CMakeLists.txt: Use CoordinatedDrawingArea and
     12        CoordinatedDrawingAreaProxy instead of the DrawingAreaImpl /
     13        DrawingAreaProxyImpl.
     14        * Shared/DrawingAreaInfo.h: Add DrawingAreaTypeCoordinated.
     15        * UIProcess/CoordinatedGraphics/CoordinatedDrawingAreaProxy.cpp:
     16        Added, copied from DrawingAreaProxyImpl.cpp.
     17        * UIProcess/CoordinatedGraphics/CoordinatedDrawingAreaProxy.h: Added,
     18        copied from DrawingAreaProxyImpl.h.
     19        * UIProcess/CoordinatedGraphics/WebView.cpp:
     20        (WebKit::WebView::createDrawingAreaProxy): Use CoordinatedDrawingAreaProxy.
     21        * UIProcess/DrawingAreaProxyImpl.cpp: Remove Coordinated Graphics
     22        bits.
     23        * UIProcess/DrawingAreaProxyImpl.h: Ditto.
     24        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedDrawingArea.cpp:
     25        Added, copied from DrawingAreaImpl.cpp.
     26        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedDrawingArea.h:
     27        Added, copied from DrawingAreaImpl.h.
     28        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp:
     29        (WebKit::CoordinatedLayerTreeHost::performScheduledLayerFlush): Use
     30        CoordinatedDrawingArea.
     31        * WebProcess/WebPage/DrawingArea.cpp:
     32        (WebKit::DrawingArea::create): Handle the DrawingAreaTypeCoordinated
     33        in the DrawingArea creation code.
     34        * WebProcess/WebPage/DrawingAreaImpl.cpp: Remove Coordinated Graphics
     35        bits.
     36        * WebProcess/WebPage/DrawingAreaImpl.h: Ditto.
     37
    1382013-10-03  Anders Carlsson  <andersca@apple.com>
    239

  • trunk/Source/WebKit2/Shared/DrawingAreaInfo.h

    r156793 r156861  
    3434    DrawingAreaTypeRemoteLayerTree,
    3535#else
     36#if USE(COORDINATED_GRAPHICS)
     37    DrawingAreaTypeCoordinated
     38#else
    3639    DrawingAreaTypeImpl,
     40#endif
    3741#endif
    3842};

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

    r156860 r156861  
    11/*
    22 * Copyright (C) 2011 Apple Inc. All rights reserved.
     3 * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies).
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2526
    2627#include "config.h"
    27 #include "DrawingAreaProxyImpl.h"
    28 
     28
     29#if USE(COORDINATED_GRAPHICS)
     30#include "CoordinatedDrawingAreaProxy.h"
     31
     32#include "CoordinatedLayerTreeHostProxy.h"
    2933#include "DrawingAreaMessages.h"
    3034#include "DrawingAreaProxyMessages.h"
    … …  
    3741#include <WebCore/Region.h>
    3842
    39 #if USE(COORDINATED_GRAPHICS)
    40 #include "CoordinatedLayerTreeHostProxy.h"
    41 #endif
    42 
    4343using namespace WebCore;
    4444
    4545namespace WebKit {
    4646
    47 DrawingAreaProxyImpl::DrawingAreaProxyImpl(WebPageProxy* webPageProxy)
    48     : DrawingAreaProxy(DrawingAreaTypeImpl, webPageProxy)
     47CoordinatedDrawingAreaProxy::CoordinatedDrawingAreaProxy(WebPageProxy* webPageProxy)
     48    : DrawingAreaProxy(DrawingAreaTypeCoordinated, webPageProxy)
    4949    , m_currentBackingStoreStateID(0)
    5050    , m_nextBackingStoreStateID(0)
    … …  
    5252    , m_hasReceivedFirstUpdate(false)
    5353    , m_isBackingStoreDiscardable(true)
    54     , m_discardBackingStoreTimer(RunLoop::current(), this, &DrawingAreaProxyImpl::discardBackingStore)
    55 {
    56 #if USE(COORDINATED_GRAPHICS)
     54    , m_discardBackingStoreTimer(RunLoop::current(), this, &CoordinatedDrawingAreaProxy::discardBackingStore)
     55{
    5756    // Construct the proxy early to allow messages to be sent to the web process while AC is entered there.
    5857    if (webPageProxy->pageGroup()->preferences()->forceCompositingMode())
    5958        m_coordinatedLayerTreeHostProxy = adoptPtr(new CoordinatedLayerTreeHostProxy(this));
    60 #endif
    61 }
    62 
    63 DrawingAreaProxyImpl::~DrawingAreaProxyImpl()
     59}
     60
     61CoordinatedDrawingAreaProxy::~CoordinatedDrawingAreaProxy()
    6462{
    6563#if USE(ACCELERATED_COMPOSITING)
    … …  
    7068}
    7169
    72 void DrawingAreaProxyImpl::paint(BackingStore::PlatformGraphicsContext context, const IntRect& rect, Region& unpaintedRegion)
     70void CoordinatedDrawingAreaProxy::paint(BackingStore::PlatformGraphicsContext context, const IntRect& rect, Region& unpaintedRegion)
    7371{
    7472    unpaintedRegion = rect;
    … …  
    8583        // If we haven't yet received our first bits from the WebProcess then don't paint anything.
    8684        if (!m_hasReceivedFirstUpdate)
    87             return;       
    88        
     85            return;
     86
    8987        if (m_isWaitingForDidUpdateBackingStoreState) {
    9088            // Wait for a DidUpdateBackingStoreState message that contains the new bits before we paint
    … …  
    113111}
    114112
    115 void DrawingAreaProxyImpl::sizeDidChange()
     113void CoordinatedDrawingAreaProxy::sizeDidChange()
    116114{
    117115    backingStoreStateDidChange(RespondImmediately);
    118116}
    119117
    120 void DrawingAreaProxyImpl::deviceScaleFactorDidChange()
     118void CoordinatedDrawingAreaProxy::deviceScaleFactorDidChange()
    121119{
    122120    backingStoreStateDidChange(RespondImmediately);
    123121}
    124122
    125 void DrawingAreaProxyImpl::layerHostingModeDidChange()
     123void CoordinatedDrawingAreaProxy::layerHostingModeDidChange()
    126124{
    127125    m_webPageProxy->process()->send(Messages::DrawingArea::SetLayerHostingMode(m_webPageProxy->layerHostingMode()), m_webPageProxy->pageID());
    128126}
    129127
    130 void DrawingAreaProxyImpl::visibilityDidChange()
     128void CoordinatedDrawingAreaProxy::visibilityDidChange()
    131129{
    132130    if (!m_webPageProxy->suppressVisibilityUpdates()) {
    … …  
    149147}
    150148
    151 void DrawingAreaProxyImpl::setBackingStoreIsDiscardable(bool isBackingStoreDiscardable)
     149void CoordinatedDrawingAreaProxy::setBackingStoreIsDiscardable(bool isBackingStoreDiscardable)
    152150{
    153151    if (m_isBackingStoreDiscardable == isBackingStoreDiscardable)
    … …  
    161159}
    162160
    163 void DrawingAreaProxyImpl::waitForBackingStoreUpdateOnNextPaint()
     161void CoordinatedDrawingAreaProxy::waitForBackingStoreUpdateOnNextPaint()
    164162{
    165163    m_hasReceivedFirstUpdate = true;
    166164}
    167165
    168 void DrawingAreaProxyImpl::update(uint64_t backingStoreStateID, const UpdateInfo& updateInfo)
     166void CoordinatedDrawingAreaProxy::update(uint64_t backingStoreStateID, const UpdateInfo& updateInfo)
    169167{
    170168    ASSERT_ARG(backingStoreStateID, backingStoreStateID <= m_currentBackingStoreStateID);
    … …  
    178176}
    179177
    180 void DrawingAreaProxyImpl::didUpdateBackingStoreState(uint64_t backingStoreStateID, const UpdateInfo& updateInfo, const LayerTreeContext& layerTreeContext)
     178void CoordinatedDrawingAreaProxy::didUpdateBackingStoreState(uint64_t backingStoreStateID, const UpdateInfo& updateInfo, const LayerTreeContext& layerTreeContext)
    181179{
    182180    ASSERT_ARG(backingStoreStateID, backingStoreStateID <= m_nextBackingStoreStateID);
    … …  
    199197            enterAcceleratedCompositingMode(layerTreeContext);
    200198            ASSERT(layerTreeContext == m_layerTreeContext);
    201         }           
     199        }
    202200    }
    203201#endif
    … …  
    223221}
    224222
    225 void DrawingAreaProxyImpl::enterAcceleratedCompositingMode(uint64_t backingStoreStateID, const LayerTreeContext& layerTreeContext)
     223void CoordinatedDrawingAreaProxy::enterAcceleratedCompositingMode(uint64_t backingStoreStateID, const LayerTreeContext& layerTreeContext)
    226224{
    227225    ASSERT_ARG(backingStoreStateID, backingStoreStateID <= m_currentBackingStoreStateID);
    … …  
    236234}
    237235
    238 void DrawingAreaProxyImpl::exitAcceleratedCompositingMode(uint64_t backingStoreStateID, const UpdateInfo& updateInfo)
     236void CoordinatedDrawingAreaProxy::exitAcceleratedCompositingMode(uint64_t backingStoreStateID, const UpdateInfo& updateInfo)
    239237{
    240238    ASSERT_ARG(backingStoreStateID, backingStoreStateID <= m_currentBackingStoreStateID);
    … …  
    249247}
    250248
    251 void DrawingAreaProxyImpl::updateAcceleratedCompositingMode(uint64_t backingStoreStateID, const LayerTreeContext& layerTreeContext)
     249void CoordinatedDrawingAreaProxy::updateAcceleratedCompositingMode(uint64_t backingStoreStateID, const LayerTreeContext& layerTreeContext)
    252250{
    253251    ASSERT_ARG(backingStoreStateID, backingStoreStateID <= m_currentBackingStoreStateID);
    … …  
    262260}
    263261
    264 void DrawingAreaProxyImpl::incorporateUpdate(const UpdateInfo& updateInfo)
     262void CoordinatedDrawingAreaProxy::incorporateUpdate(const UpdateInfo& updateInfo)
    265263{
    266264    ASSERT(!isInAcceleratedCompositingMode());
    … …  
    278276    if (shouldScroll)
    279277        m_webPageProxy->scrollView(updateInfo.scrollRect, updateInfo.scrollOffset);
    280    
     278
    281279    if (shouldScroll && !m_webPageProxy->canScrollView())
    282280        m_webPageProxy->setViewNeedsDisplay(IntRect(IntPoint(), m_webPageProxy->viewSize()));
    … …  
    285283            m_webPageProxy->setViewNeedsDisplay(updateInfo.updateRects[i]);
    286284    }
    287    
     285
    288286    if (WebPageProxy::debugPaintFlags() & kWKDebugFlashBackingStoreUpdates)
    289287        m_webPageProxy->flashBackingStoreUpdates(updateInfo.updateRects);
    … …  
    293291}
    294292
    295 void DrawingAreaProxyImpl::backingStoreStateDidChange(RespondImmediatelyOrNot respondImmediatelyOrNot)
     293void CoordinatedDrawingAreaProxy::backingStoreStateDidChange(RespondImmediatelyOrNot respondImmediatelyOrNot)
    296294{
    297295    ++m_nextBackingStoreStateID;
    … …  
    299297}
    300298
    301 void DrawingAreaProxyImpl::sendUpdateBackingStoreState(RespondImmediatelyOrNot respondImmediatelyOrNot)
     299void CoordinatedDrawingAreaProxy::sendUpdateBackingStoreState(RespondImmediatelyOrNot respondImmediatelyOrNot)
    302300{
    303301    ASSERT(m_currentBackingStoreStateID < m_nextBackingStoreStateID);
    … …  
    325323#if USE(ACCELERATED_COMPOSITING)
    326324    if (m_isWaitingForDidUpdateBackingStoreState && !m_layerTreeContext.isEmpty()) {
    327         // Wait for the DidUpdateBackingStoreState message. Normally we do this in DrawingAreaProxyImpl::paint, but that
     325        // Wait for the DidUpdateBackingStoreState message. Normally we do this in CoordinatedDrawingAreaProxy::paint, but that
    328326        // function is never called when in accelerated compositing mode.
    329327        waitForAndDispatchDidUpdateBackingStoreState();
    … …  
    332330}
    333331
    334 void DrawingAreaProxyImpl::waitForAndDispatchDidUpdateBackingStoreState()
     332void CoordinatedDrawingAreaProxy::waitForAndDispatchDidUpdateBackingStoreState()
    335333{
    336334    ASSERT(m_isWaitingForDidUpdateBackingStoreState);
    … …  
    354352
    355353#if USE(ACCELERATED_COMPOSITING)
    356 void DrawingAreaProxyImpl::enterAcceleratedCompositingMode(const LayerTreeContext& layerTreeContext)
     354void CoordinatedDrawingAreaProxy::enterAcceleratedCompositingMode(const LayerTreeContext& layerTreeContext)
    357355{
    358356    ASSERT(!isInAcceleratedCompositingMode());
    … …  
    361359    m_layerTreeContext = layerTreeContext;
    362360    m_webPageProxy->enterAcceleratedCompositingMode(layerTreeContext);
    363 #if USE(COORDINATED_GRAPHICS)
    364361    if (!m_coordinatedLayerTreeHostProxy)
    365362        m_coordinatedLayerTreeHostProxy = adoptPtr(new CoordinatedLayerTreeHostProxy(this));
    366 #endif
    367 }
    368 
    369 #if USE(COORDINATED_GRAPHICS)
    370 void DrawingAreaProxyImpl::setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectoryVector)
     363}
     364
     365void CoordinatedDrawingAreaProxy::setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectoryVector)
    371366{
    372367    if (m_coordinatedLayerTreeHostProxy)
    373368        m_coordinatedLayerTreeHostProxy->setVisibleContentsRect(visibleContentsRect, trajectoryVector);
    374369}
    375 #endif
    376 
    377 void DrawingAreaProxyImpl::exitAcceleratedCompositingMode()
     370
     371void CoordinatedDrawingAreaProxy::exitAcceleratedCompositingMode()
    378372{
    379373    ASSERT(isInAcceleratedCompositingMode());
    380374
    381     m_layerTreeContext = LayerTreeContext();   
     375    m_layerTreeContext = LayerTreeContext();
    382376    m_webPageProxy->exitAcceleratedCompositingMode();
    383377}
    384378
    385 void DrawingAreaProxyImpl::updateAcceleratedCompositingMode(const LayerTreeContext& layerTreeContext)
     379void CoordinatedDrawingAreaProxy::updateAcceleratedCompositingMode(const LayerTreeContext& layerTreeContext)
    386380{
    387381    ASSERT(isInAcceleratedCompositingMode());
    … …  
    392386#endif
    393387
    394 void DrawingAreaProxyImpl::discardBackingStoreSoon()
     388void CoordinatedDrawingAreaProxy::discardBackingStoreSoon()
    395389{
    396390    if (!m_isBackingStoreDiscardable || m_discardBackingStoreTimer.isActive())
    … …  
    404398}
    405399
    406 void DrawingAreaProxyImpl::discardBackingStore()
     400void CoordinatedDrawingAreaProxy::discardBackingStore()
    407401{
    408402    m_backingStore = nullptr;
    … …  
    411405
    412406} // namespace WebKit
     407#endif // USE(COORDINATED_GRAPHICS)

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

    r156860 r156861  
    11/*
    22 * Copyright (C) 2011 Apple Inc. All rights reserved.
     3 * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies).
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2425 */
    2526
    26 #ifndef DrawingAreaProxyImpl_h
    27 #define DrawingAreaProxyImpl_h
     27#ifndef CoordinatedDrawingAreaProxy_h
     28#define CoordinatedDrawingAreaProxy_h
     29
     30#if USE(COORDINATED_GRAPHICS)
    2831
    2932#include "BackingStore.h"
    … …  
    4144class CoordinatedLayerTreeHostProxy;
    4245
    43 class DrawingAreaProxyImpl : public DrawingAreaProxy {
     46class CoordinatedDrawingAreaProxy : public DrawingAreaProxy {
    4447public:
    45     explicit DrawingAreaProxyImpl(WebPageProxy*);
    46     virtual ~DrawingAreaProxyImpl();
     48    explicit CoordinatedDrawingAreaProxy(WebPageProxy*);
     49    virtual ~CoordinatedDrawingAreaProxy();
    4750
    4851    void paint(BackingStore::PlatformGraphicsContext, const WebCore::IntRect&, WebCore::Region& unpaintedRegion);
    … …  
    8285    void exitAcceleratedCompositingMode();
    8386    void updateAcceleratedCompositingMode(const LayerTreeContext&);
    84 #if USE(COORDINATED_GRAPHICS)
    8587    virtual void setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectory) OVERRIDE;
    86 #endif
    8788#else
    8889    bool isInAcceleratedCompositingMode() const { return false; }
    … …  
    109110    // Used to throttle UpdateBackingStoreState messages so we don't send them faster than the Web process can handle.
    110111    bool m_isWaitingForDidUpdateBackingStoreState;
    111    
     112
    112113    // For a new Drawing Area don't draw anything until the WebProcess has sent over the first content.
    113114    bool m_hasReceivedFirstUpdate;
    … …  
    116117    std::unique_ptr<BackingStore> m_backingStore;
    117118
    118     WebCore::RunLoop::Timer<DrawingAreaProxyImpl> m_discardBackingStoreTimer;
     119    WebCore::RunLoop::Timer<CoordinatedDrawingAreaProxy> m_discardBackingStoreTimer;
    119120};
    120121
    121122} // namespace WebKit
    122123
    123 #endif // DrawingAreaProxyImpl_h
     124#endif // USE(COORDINATED_GRAPHICS)
     125#endif // CoordinatedDrawingAreaProxy_h

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

    r156700 r156861  
    3030#include "WebView.h"
    3131
     32#include "CoordinatedDrawingAreaProxy.h"
    3233#include "CoordinatedLayerTreeHostProxy.h"
    33 #include "DrawingAreaProxyImpl.h"
    3434#include "NotImplemented.h"
    3535#include "WebContextMenuProxy.h"
    … …  
    284284std::unique_ptr<DrawingAreaProxy> WebView::createDrawingAreaProxy()
    285285{
    286     return std::make_unique<DrawingAreaProxyImpl>(page());
     286    return std::make_unique<CoordinatedDrawingAreaProxy>(page());
    287287}
    288288

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

    r156688 r156861  
    3737#include <WebCore/Region.h>
    3838
    39 #if USE(COORDINATED_GRAPHICS)
    40 #include "CoordinatedLayerTreeHostProxy.h"
    41 #endif
    42 
    4339using namespace WebCore;
    4440
    … …  
    5450    , m_discardBackingStoreTimer(RunLoop::current(), this, &DrawingAreaProxyImpl::discardBackingStore)
    5551{
    56 #if USE(COORDINATED_GRAPHICS)
    57     // Construct the proxy early to allow messages to be sent to the web process while AC is entered there.
    58     if (webPageProxy->pageGroup()->preferences()->forceCompositingMode())
    59         m_coordinatedLayerTreeHostProxy = adoptPtr(new CoordinatedLayerTreeHostProxy(this));
    60 #endif
    6152}
    6253
    … …  
    361352    m_layerTreeContext = layerTreeContext;
    362353    m_webPageProxy->enterAcceleratedCompositingMode(layerTreeContext);
    363 #if USE(COORDINATED_GRAPHICS)
    364     if (!m_coordinatedLayerTreeHostProxy)
    365         m_coordinatedLayerTreeHostProxy = adoptPtr(new CoordinatedLayerTreeHostProxy(this));
    366 #endif
    367 }
    368 
    369 #if USE(COORDINATED_GRAPHICS)
    370 void DrawingAreaProxyImpl::setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectoryVector)
    371 {
    372     if (m_coordinatedLayerTreeHostProxy)
    373         m_coordinatedLayerTreeHostProxy->setVisibleContentsRect(visibleContentsRect, trajectoryVector);
    374 }
    375 #endif
     354}
    376355
    377356void DrawingAreaProxyImpl::exitAcceleratedCompositingMode()

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

    r156688 r156861  
    8282    void exitAcceleratedCompositingMode();
    8383    void updateAcceleratedCompositingMode(const LayerTreeContext&);
    84 #if USE(COORDINATED_GRAPHICS)
    85     virtual void setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectory) OVERRIDE;
    86 #endif
    8784#else
    8885    bool isInAcceleratedCompositingMode() const { return false; }

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

    r156860 r156861  
    11/*
    22 * Copyright (C) 2011 Apple Inc. All rights reserved.
     3 * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies).
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2526
    2627#include "config.h"
    27 #include "DrawingAreaImpl.h"
     28
     29#if USE(COORDINATED_GRAPHICS)
     30#include "CoordinatedDrawingArea.h"
    2831
    2932#include "DrawingAreaProxyMessages.h"
    … …  
    4245namespace WebKit {
    4346
    44 DrawingAreaImpl::~DrawingAreaImpl()
     47CoordinatedDrawingArea::~CoordinatedDrawingArea()
    4548{
    4649    if (m_layerTreeHost)
    … …  
    4851}
    4952
    50 DrawingAreaImpl::DrawingAreaImpl(WebPage* webPage, const WebPageCreationParameters& parameters)
    51     : DrawingArea(DrawingAreaTypeImpl, webPage)
     53CoordinatedDrawingArea::CoordinatedDrawingArea(WebPage* webPage, const WebPageCreationParameters& parameters)
     54    : DrawingArea(DrawingAreaTypeCoordinated, webPage)
    5255    , m_backingStoreStateID(0)
    5356    , m_isPaintingEnabled(true)
    … …  
    5962    , m_wantsToExitAcceleratedCompositingMode(false)
    6063    , m_isPaintingSuspended(!parameters.isVisible)
    61     , m_alwaysUseCompositing(false)
    62     , m_displayTimer(RunLoop::main(), this, &DrawingAreaImpl::displayTimerFired)
    63     , m_exitCompositingTimer(RunLoop::main(), this, &DrawingAreaImpl::exitAcceleratedCompositingMode)
    64 {
    65     if (webPage->corePage()->settings().acceleratedDrawingEnabled() || webPage->corePage()->settings().forceCompositingMode())
    66         m_alwaysUseCompositing = true;
    67 
    68 #if USE(COORDINATED_GRAPHICS)
    69     m_alwaysUseCompositing = true;
    70 #endif
    71 
    72     if (m_alwaysUseCompositing)
    73         enterAcceleratedCompositingMode(0);
    74 }
    75 
    76 void DrawingAreaImpl::setNeedsDisplay()
     64    , m_displayTimer(RunLoop::main(), this, &CoordinatedDrawingArea::displayTimerFired)
     65    , m_exitCompositingTimer(RunLoop::main(), this, &CoordinatedDrawingArea::exitAcceleratedCompositingMode)
     66{
     67    // Always use compositing in CoordinatedGraphics
     68    enterAcceleratedCompositingMode(0);
     69}
     70
     71void CoordinatedDrawingArea::setNeedsDisplay()
    7772{
    7873    if (!m_isPaintingEnabled)
    … …  
    8883}
    8984
    90 void DrawingAreaImpl::setNeedsDisplayInRect(const IntRect& rect)
     85void CoordinatedDrawingArea::setNeedsDisplayInRect(const IntRect& rect)
    9186{
    9287    if (!m_isPaintingEnabled)
    … …  
    9893        return;
    9994    }
    100    
     95
    10196    IntRect dirtyRect = rect;
    10297    dirtyRect.intersect(m_webPage->bounds());
    … …  
    109104}
    110105
    111 void DrawingAreaImpl::scroll(const IntRect& scrollRect, const IntSize& scrollDelta)
     106void CoordinatedDrawingArea::scroll(const IntRect& scrollRect, const IntSize& scrollDelta)
    112107{
    113108    if (!m_isPaintingEnabled)
    … …  
    155150        // And add them back.
    156151        m_dirtyRegion.unite(movedDirtyRegionInScrollRect);
    157     } 
    158    
     152    }
     153
    159154    // Compute the scroll repaint region.
    160155    Region scrollRepaintRegion = subtract(scrollRect, translate(scrollRect, scrollDelta));
    … …  
    167162}
    168163
    169 void DrawingAreaImpl::pageBackgroundTransparencyChanged()
     164void CoordinatedDrawingArea::pageBackgroundTransparencyChanged()
    170165{
    171166    if (m_layerTreeHost)
    … …  
    173168}
    174169
    175 void DrawingAreaImpl::setLayerTreeStateIsFrozen(bool isFrozen)
     170void CoordinatedDrawingArea::setLayerTreeStateIsFrozen(bool isFrozen)
    176171{
    177172    if (m_layerTreeStateIsFrozen == isFrozen)
    … …  
    189184}
    190185
    191 void DrawingAreaImpl::forceRepaint()
     186void CoordinatedDrawingArea::forceRepaint()
    192187{
    193188    setNeedsDisplay();
    … …  
    202197            m_layerTreeHost->forceRepaint();
    203198        else {
    204             // Call setShouldNotifyAfterNextScheduledLayerFlush(false) here to 
     199            // Call setShouldNotifyAfterNextScheduledLayerFlush(false) here to
    205200            // prevent layerHostDidFlushLayers() from being called a second time.
    206201            m_layerTreeHost->setShouldNotifyAfterNextScheduledLayerFlush(false);
    … …  
    214209}
    215210
    216 bool DrawingAreaImpl::forceRepaintAsync(uint64_t callbackID)
     211bool CoordinatedDrawingArea::forceRepaintAsync(uint64_t callbackID)
    217212{
    218213    return m_layerTreeHost && m_layerTreeHost->forceRepaintAsync(callbackID);
    219214}
    220215
    221 void DrawingAreaImpl::didInstallPageOverlay(PageOverlay* pageOverlay)
     216void CoordinatedDrawingArea::didInstallPageOverlay(PageOverlay* pageOverlay)
    222217{
    223218    if (m_layerTreeHost)
    … …  
    225220}
    226221
    227 void DrawingAreaImpl::didUninstallPageOverlay(PageOverlay* pageOverlay)
     222void CoordinatedDrawingArea::didUninstallPageOverlay(PageOverlay* pageOverlay)
    228223{
    229224    if (m_layerTreeHost)
    … …  
    233228}
    234229
    235 void DrawingAreaImpl::setPageOverlayNeedsDisplay(PageOverlay* pageOverlay, const IntRect& rect)
     230void CoordinatedDrawingArea::setPageOverlayNeedsDisplay(PageOverlay* pageOverlay, const IntRect& rect)
    236231{
    237232    if (m_layerTreeHost) {
    … …  
    243238}
    244239
    245 void DrawingAreaImpl::setPageOverlayOpacity(PageOverlay* pageOverlay, float value)
     240void CoordinatedDrawingArea::setPageOverlayOpacity(PageOverlay* pageOverlay, float value)
    246241{
    247242    if (m_layerTreeHost)
    … …  
    249244}
    250245
    251 void DrawingAreaImpl::setPaintingEnabled(bool paintingEnabled)
     246void CoordinatedDrawingArea::setPaintingEnabled(bool paintingEnabled)
    252247{
    253248    m_isPaintingEnabled = paintingEnabled;
    254249}
    255250
    256 void DrawingAreaImpl::updatePreferences(const WebPreferencesStore& store)
     251void CoordinatedDrawingArea::updatePreferences(const WebPreferencesStore& store)
    257252{
    258253    m_webPage->corePage()->settings().setForceCompositingMode(store.getBoolValueForKey(WebPreferencesKey::forceCompositingModeKey()) && LayerTreeHost::supportsAcceleratedCompositing());
    259254}
    260255
    261 void DrawingAreaImpl::layerHostDidFlushLayers()
     256void CoordinatedDrawingArea::layerHostDidFlushLayers()
    262257{
    263258    ASSERT(m_layerTreeHost);
    … …  
    283278
    284279#if USE(ACCELERATED_COMPOSITING)
    285 GraphicsLayerFactory* DrawingAreaImpl::graphicsLayerFactory()
     280GraphicsLayerFactory* CoordinatedDrawingArea::graphicsLayerFactory()
    286281{
    287282    if (m_layerTreeHost)
    … …  
    291286}
    292287
    293 void DrawingAreaImpl::setRootCompositingLayer(GraphicsLayer* graphicsLayer)
     288void CoordinatedDrawingArea::setRootCompositingLayer(GraphicsLayer* graphicsLayer)
    294289{
    295290    // FIXME: Instead of using nested if statements, we should keep a compositing state
    296     // enum in the DrawingAreaImpl object and have a changeAcceleratedCompositingState function
     291    // enum in the CoordinatedDrawingArea object and have a changeAcceleratedCompositingState function
    297292    // that takes the new state.
    298293
    … …  
    315310        }
    316311    } else {
    317         if (m_layerTreeHost) {
     312        if (m_layerTreeHost)
    318313            m_layerTreeHost->setRootCompositingLayer(0);
    319             if (!m_alwaysUseCompositing) {
    320                 // We'll exit accelerated compositing mode on a timer, to avoid re-entering
    321                 // compositing code via display() and layout.
    322                 // If we're leaving compositing mode because of a setSize, it is safe to
    323                 // exit accelerated compositing mode right away.
    324                 if (m_inUpdateBackingStoreState)
    325                     exitAcceleratedCompositingMode();
    326                 else
    327                     exitAcceleratedCompositingModeSoon();
    328             }
    329         }
    330     }
    331 }
    332 
    333 void DrawingAreaImpl::scheduleCompositingLayerFlush()
     314    }
     315}
     316
     317void CoordinatedDrawingArea::scheduleCompositingLayerFlush()
    334318{
    335319    if (!m_layerTreeHost)
    … …  
    339323#endif
    340324
    341 void DrawingAreaImpl::updateBackingStoreState(uint64_t stateID, bool respondImmediately, float deviceScaleFactor, const WebCore::IntSize& size, const WebCore::IntSize& scrollOffset)
     325void CoordinatedDrawingArea::updateBackingStoreState(uint64_t stateID, bool respondImmediately, float deviceScaleFactor, const WebCore::IntSize& size, const WebCore::IntSize& scrollOffset)
    342326{
    343327    ASSERT(!m_inUpdateBackingStoreState);
    … …  
    355339
    356340        if (m_layerTreeHost) {
    357 #if USE(COORDINATED_GRAPHICS)
    358341            // Coordinated Graphics sets the size of the root layer to contents size.
    359342            if (!m_webPage->useFixedLayout())
    360 #endif
    361343                m_layerTreeHost->sizeDidChange(m_webPage->size());
    362344        } else
    … …  
    390372}
    391373
    392 void DrawingAreaImpl::sendDidUpdateBackingStoreState()
     374void CoordinatedDrawingArea::sendDidUpdateBackingStoreState()
    393375{
    394376    ASSERT(!m_isWaitingForDidUpdate);
    … …  
    424406}
    425407
    426 void DrawingAreaImpl::didUpdate()
     408void CoordinatedDrawingArea::didUpdate()
    427409{
    428410    // We might get didUpdate messages from the UI process even after we've
    … …  
    437419}
    438420
    439 void DrawingAreaImpl::suspendPainting()
     421void CoordinatedDrawingArea::suspendPainting()
    440422{
    441423    ASSERT(!m_isPaintingSuspended);
    … …  
    450432}
    451433
    452 void DrawingAreaImpl::resumePainting()
     434void CoordinatedDrawingArea::resumePainting()
    453435{
    454436    if (!m_isPaintingSuspended) {
    … …  
    457439        return;
    458440    }
    459    
     441
    460442    if (m_layerTreeHost)
    461443        m_layerTreeHost->resumeRendering();
    462        
     444
    463445    m_isPaintingSuspended = false;
    464446
    … …  
    469451}
    470452
    471 void DrawingAreaImpl::enterAcceleratedCompositingMode(GraphicsLayer* graphicsLayer)
     453void CoordinatedDrawingArea::enterAcceleratedCompositingMode(GraphicsLayer* graphicsLayer)
    472454{
    473455    m_exitCompositingTimer.stop();
    … …  
    481463
    482464    m_layerTreeHost->setRootCompositingLayer(graphicsLayer);
    483    
     465
    484466    // Non-composited content will now be handled exclusively by the layer tree host.
    485467    m_dirtyRegion = Region();
    … …  
    490472}
    491473
    492 void DrawingAreaImpl::exitAcceleratedCompositingMode()
    493 {
    494     if (m_alwaysUseCompositing)
    495         return;
    496 
    497     ASSERT(!m_layerTreeStateIsFrozen);
    498 
    499     m_exitCompositingTimer.stop();
    500     m_wantsToExitAcceleratedCompositingMode = false;
    501 
    502     ASSERT(m_layerTreeHost);
    503 
    504     m_layerTreeHost->invalidate();
    505     m_layerTreeHost = nullptr;
    506     m_dirtyRegion = m_webPage->bounds();
    507 
    508     if (m_inUpdateBackingStoreState)
    509         return;
    510 
    511     if (m_shouldSendDidUpdateBackingStoreState) {
    512         sendDidUpdateBackingStoreState();
    513         return;
    514     }
    515 
    516     UpdateInfo updateInfo;
    517     if (m_isPaintingSuspended) {
    518         updateInfo.viewSize = m_webPage->size();
    519         updateInfo.deviceScaleFactor = m_webPage->corePage()->deviceScaleFactor();
    520     } else
    521         display(updateInfo);
    522 
    523 #if USE(ACCELERATED_COMPOSITING)
    524     // Send along a complete update of the page so we can paint the contents right after we exit the
    525     // accelerated compositing mode, eliminiating flicker.
    526     if (m_compositingAccordingToProxyMessages) {
    527         m_webPage->send(Messages::DrawingAreaProxy::ExitAcceleratedCompositingMode(m_backingStoreStateID, updateInfo));
    528         m_compositingAccordingToProxyMessages = false;
    529     } else {
    530         // If we left accelerated compositing mode before we sent an EnterAcceleratedCompositingMode message to the
    531         // UI process, we still need to let it know about the new contents, so send an Update message.
    532         m_webPage->send(Messages::DrawingAreaProxy::Update(m_backingStoreStateID, updateInfo));
    533     }
    534 #endif
    535 }
    536 
    537 void DrawingAreaImpl::exitAcceleratedCompositingModeSoon()
     474void CoordinatedDrawingArea::exitAcceleratedCompositingModeSoon()
    538475{
    539476    if (m_layerTreeStateIsFrozen) {
    … …  
    548485}
    549486
    550 void DrawingAreaImpl::scheduleDisplay()
     487void CoordinatedDrawingArea::scheduleDisplay()
    551488{
    552489    ASSERT(!m_layerTreeHost);
    … …  
    567504}
    568505
    569 void DrawingAreaImpl::displayTimerFired()
     506void CoordinatedDrawingArea::displayTimerFired()
    570507{
    571508    display();
    572509}
    573510
    574 void DrawingAreaImpl::display()
     511void CoordinatedDrawingArea::display()
    575512{
    576513    ASSERT(!m_layerTreeHost);
    … …  
    611548
    612549    // Attempt to guess whether or not we should use the region bounds rect or the individual rects.
    613     // We do this by computing the percentage of "wasted space" in the bounds.  If that wasted space
     550    // We do this by computing the percentage of "wasted space" in the bounds. If that wasted space
    614551    // is too large, then we will do individual rect painting instead.
    615552    unsigned boundsArea = bounds.width() * bounds.height();
    … …  
    623560}
    624561
    625 void DrawingAreaImpl::display(UpdateInfo& updateInfo)
     562void CoordinatedDrawingArea::display(UpdateInfo& updateInfo)
    626563{
    627564    ASSERT(!m_isPaintingSuspended);
    … …  
    668605    auto graphicsContext = bitmap->createGraphicsContext();
    669606    graphicsContext->applyDeviceScaleFactor(deviceScaleFactor);
    670    
     607
    671608    updateInfo.updateRectBounds = bounds;
    672609
    … …  
    691628}
    692629
    693 #if USE(COORDINATED_GRAPHICS)
    694 void DrawingAreaImpl::didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
     630void CoordinatedDrawingArea::didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
    695631{
    696632    if (m_layerTreeHost)
    697633        m_layerTreeHost->didReceiveCoordinatedLayerTreeHostMessage(connection, decoder);
    698634}
    699 #endif
    700635
    701636} // namespace WebKit
     637#endif // USE(COORDINATED_GRAPHICS)

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

    r156860 r156861  
    11/*
    22 * Copyright (C) 2011 Apple Inc. All rights reserved.
     3 * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies).
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2425 */
    2526
    26 #ifndef DrawingAreaImpl_h
    27 #define DrawingAreaImpl_h
     27#ifndef CoordinatedDrawingArea_h
     28#define CoordinatedDrawingArea_h
     29
     30#if USE(COORDINATED_GRAPHICS)
    2831
    2932#include "DrawingArea.h"
    … …  
    3235#include <WebCore/RunLoop.h>
    3336
    34 namespace WebCore {
    35     class GraphicsContext;
    36 }
    37 
    3837namespace WebKit {
    3938
    40 class ShareableBitmap;
    41 class UpdateInfo;
    42 
    43 class DrawingAreaImpl : public DrawingArea {
     39class CoordinatedDrawingArea : public DrawingArea {
    4440public:
    45     DrawingAreaImpl(WebPage*, const WebPageCreationParameters&);
    46     virtual ~DrawingAreaImpl();
     41    CoordinatedDrawingArea(WebPage*, const WebPageCreationParameters&);
     42    virtual ~CoordinatedDrawingArea();
    4743
    4844    void layerHostDidFlushLayers();
    … …  
    7470#endif
    7571
    76 #if USE(COORDINATED_GRAPHICS)
    7772    virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
    78 #endif
    7973
    8074    // CoreIPC message handlers.
    … …  
    8377    virtual void suspendPainting();
    8478    virtual void resumePainting();
    85    
     79
    8680    void sendDidUpdateBackingStoreState();
    8781
    … …  
    8983    void exitAcceleratedCompositingModeSoon();
    9084    bool exitAcceleratedCompositingModePending() const { return m_exitCompositingTimer.isActive(); }
    91     void exitAcceleratedCompositingMode();
     85    void exitAcceleratedCompositingMode() { }
    9286
    9387    void scheduleDisplay();
    … …  
    112106    bool m_shouldSendDidUpdateBackingStoreState;
    113107
    114     // Whether we're waiting for a DidUpdate message. Used for throttling paints so that the 
     108    // Whether we're waiting for a DidUpdate message. Used for throttling paints so that the
    115109    // web process won't paint more frequent than the UI process can handle.
    116110    bool m_isWaitingForDidUpdate;
    117    
     111
    118112    // True between sending the 'enter compositing' messages, and the 'exit compositing' message.
    119113    bool m_compositingAccordingToProxyMessages;
    … …  
    127121    bool m_wantsToExitAcceleratedCompositingMode;
    128122
    129     // Whether painting is suspended. We'll still keep track of the dirty region but we 
     123    // Whether painting is suspended. We'll still keep track of the dirty region but we
    130124    // won't paint until painting has resumed again.
    131125    bool m_isPaintingSuspended;
    132     bool m_alwaysUseCompositing;
    133126
    134     WebCore::RunLoop::Timer<DrawingAreaImpl> m_displayTimer;
    135     WebCore::RunLoop::Timer<DrawingAreaImpl> m_exitCompositingTimer;
     127    WebCore::RunLoop::Timer<CoordinatedDrawingArea> m_displayTimer;
     128    WebCore::RunLoop::Timer<CoordinatedDrawingArea> m_exitCompositingTimer;
    136129
    137130    // The layer tree host that handles accelerated compositing.
    … …  
    141134} // namespace WebKit
    142135
    143 #endif // DrawingAreaImpl_h
     136#endif // USE(COORDINATED_GRAPHICS)
     137
     138#endif // CoordinatedDrawingArea_h

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

    r156566 r156861  
    3131#include "CoordinatedLayerTreeHost.h"
    3232
     33#include "CoordinatedDrawingArea.h"
    3334#include "CoordinatedGraphicsArgumentCoders.h"
    3435#include "CoordinatedLayerTreeHostProxyMessages.h"
    35 #include "DrawingAreaImpl.h"
    3636#include "GraphicsContext.h"
    3737#include "WebCoordinatedSurface.h"
    … …  
    319319
    320320    if (m_notifyAfterScheduledLayerFlush && didSync) {
    321         static_cast<DrawingAreaImpl*>(m_webPage->drawingArea())->layerHostDidFlushLayers();
     321        static_cast<CoordinatedDrawingArea*>(m_webPage->drawingArea())->layerHostDidFlushLayers();
    322322        m_notifyAfterScheduledLayerFlush = false;
    323323    }

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

    r156828 r156861  
    3232#include "TiledCoreAnimationDrawingArea.h"
    3333#else
     34#if USE(COORDINATED_GRAPHICS)
     35#include "CoordinatedDrawingArea.h"
     36#else
    3437#include "DrawingAreaImpl.h"
     38#endif
    3539#endif
    3640
    … …  
    4852        return std::make_unique<RemoteLayerTreeDrawingArea>(webPage, parameters);
    4953#else
     54#if USE(COORDINATED_GRAPHICS)
     55    case DrawingAreaTypeCoordinated:
     56        return std::make_unique<CoordinatedDrawingArea>(webPage, parameters);
     57#else
    5058    case DrawingAreaTypeImpl:
    5159        return std::make_unique<DrawingAreaImpl>(webPage, parameters);
     60#endif
    5261#endif
    5362    }

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

    r156793 r156861  
    6666        m_alwaysUseCompositing = true;
    6767
    68 #if USE(COORDINATED_GRAPHICS)
    69     m_alwaysUseCompositing = true;
    70 #endif
    71 
    7268    if (m_alwaysUseCompositing)
    7369        enterAcceleratedCompositingMode(0);
    … …  
    355351
    356352        if (m_layerTreeHost) {
    357 #if USE(COORDINATED_GRAPHICS)
    358             // Coordinated Graphics sets the size of the root layer to contents size.
    359             if (!m_webPage->useFixedLayout())
    360 #endif
    361                 m_layerTreeHost->sizeDidChange(m_webPage->size());
     353            m_layerTreeHost->sizeDidChange(m_webPage->size());
    362354        } else
    363355            m_dirtyRegion = m_webPage->bounds();
    … …  
    691683}
    692684
    693 #if USE(COORDINATED_GRAPHICS)
    694 void DrawingAreaImpl::didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
    695 {
    696     if (m_layerTreeHost)
    697         m_layerTreeHost->didReceiveCoordinatedLayerTreeHostMessage(connection, decoder);
    698 }
    699 #endif
    700 
    701685} // namespace WebKit

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

    r156793 r156861  
    7474#endif
    7575
    76 #if USE(COORDINATED_GRAPHICS)
    77     virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
    78 #endif
    79 
    8076    // CoreIPC message handlers.
    8177    virtual void updateBackingStoreState(uint64_t backingStoreStateID, bool respondImmediately, float deviceScaleFactor, const WebCore::IntSize&, const WebCore::IntSize& scrollOffset);
Note: See TracChangeset for help on using the changeset viewer.