Changeset 96655 in webkit


Ignore:
Timestamp:
Oct 4, 2011 3:38:27 PM (13 years ago)
Author:
commit-queue@webkit.org
Message:

[chromium] Extract scheduling logic from CCThreadProxy to its own class
​https://bugs.webkit.org/show_bug.cgi?id=69049

Patch by James Robinson <​jamesr@chromium.org> on 2011-10-04
Reviewed by Kenneth Russell.

Source/WebCore:

This partially extracts the commit/draw scheduling from CCThreadProxy to a separate isolated class. This makes
the commit/draw logic easier to test, understand and extend.

There is one subtle behavior change here to the way that the function formerly known as
CCLayerTreeHost::setNeedsCommitAndRedraw works. Previously, this would trigger a begin frame message, if one
wasn't pending, and then trigger a redraw if one wasn't pending. This was subtly wrong - the intent of that call
is that a redraw should happen after the commit. It isn't useful to draw before the commit occurs. This patch
changes the name of the function to setNeedsCommitThenRedraw and only requests a redraw after a commit occurs.

Covered by new CCSchedulerTest unit tests, CCLayerTreeHostTest unit tests, and compositing/ layout tests.

  • WebCore.gypi:
  • platform/graphics/chromium/cc/CCLayerTreeHost.cpp:

(WebCore::CCLayerTreeHost::initialize):
(WebCore::CCLayerTreeHost::setZoomAnimatorTransform):
(WebCore::CCLayerTreeHost::setNeedsCommitThenRedraw):
(WebCore::CCLayerTreeHost::setViewport):
(WebCore::CCLayerTreeHost::setVisible):

  • platform/graphics/chromium/cc/CCLayerTreeHost.h:
  • platform/graphics/chromium/cc/CCProxy.h:
  • platform/graphics/chromium/cc/CCScheduler.cpp: Added.

(WebCore::CCScheduler::CCScheduler):
(WebCore::CCScheduler::requestCommit):
(WebCore::CCScheduler::requestCommitThenRedraw):
(WebCore::CCScheduler::requestRedraw):
(WebCore::CCScheduler::didCommit):
(WebCore::CCScheduler::didDraw):

  • platform/graphics/chromium/cc/CCScheduler.h: Added.

(WebCore::CCSchedulerClient::~CCSchedulerClient):
(WebCore::CCScheduler::create):
(WebCore::CCScheduler::commitPending):
(WebCore::CCScheduler::redrawPending):
(WebCore::CCScheduler::redrawAfterCommit):

  • platform/graphics/chromium/cc/CCSingleThreadProxy.cpp:

(WebCore::CCSingleThreadProxy::setNeedsCommitThenRedraw):
(WebCore::CCSingleThreadProxy::setNeedsRedraw):
(WebCore::CCSingleThreadProxy::recreateContextIfNeeded):
(WebCore::CCSingleThreadProxy::doComposite):

  • platform/graphics/chromium/cc/CCSingleThreadProxy.h:
  • platform/graphics/chromium/cc/CCThreadProxy.cpp:

(WebCore::CCThreadProxySchedulerClient::create):
(WebCore::CCThreadProxySchedulerClient::~CCThreadProxySchedulerClient):
(WebCore::CCThreadProxySchedulerClient::scheduleBeginFrameAndCommit):
(WebCore::CCThreadProxySchedulerClient::scheduleDrawAndPresent):
(WebCore::CCThreadProxySchedulerClient::CCThreadProxySchedulerClient):
(WebCore::CCThreadProxy::CCThreadProxy):
(WebCore::CCThreadProxy::compositeAndReadback):
(WebCore::CCThreadProxy::initializeLayerRenderer):
(WebCore::CCThreadProxy::setNeedsCommit):
(WebCore::CCThreadProxy::setNeedsCommitOnCCThread):
(WebCore::CCThreadProxy::setNeedsCommitThenRedraw):
(WebCore::CCThreadProxy::setNeedsCommitThenRedrawOnCCThread):
(WebCore::CCThreadProxy::setNeedsRedraw):
(WebCore::CCThreadProxy::setNeedsRedrawOnCCThread):
(WebCore::CCThreadProxy::finishAllRenderingOnCCThread):
(WebCore::CCThreadProxy::obtainBeginFrameAndCommitTaskFromCCThread):
(WebCore::CCThreadProxy::createBeginFrameAndCommitTaskOnCCThread):
(WebCore::CCThreadProxy::beginFrameAndCommit):
(WebCore::CCThreadProxy::commitOnCCThread):
(WebCore::CCThreadProxy::drawLayersAndPresentOnCCThread):
(WebCore::CCThreadProxy::initializeImplOnCCThread):

  • platform/graphics/chromium/cc/CCThreadProxy.h:

Source/WebKit/chromium:

Adds some unit tests for the new CCScheduler class. Since the class is very simple today, the tests are
similarly quite simple.

  • WebKit.gypi:
  • src/WebViewImpl.cpp:

(WebKit::WebViewImpl::setRootLayerNeedsDisplay):

  • tests/CCLayerTreeHostTest.cpp:

(WTF::CCLayerTreeHostTest::postSetNeedsCommitThenRedrawToMainThread):
(WTF::CCLayerTreeHostTest::dispatchSetNeedsCommitThenRedraw):
(WTF::CCLayerTreeHostTestShortlived2::beginTest):
(WTF::CCLayerTreeHostTestCommitingWithContinuousRedraw::beginTest):
(WTF::CCLayerTreeHostTestCommitingWithContinuousRedraw::drawLayersOnCCThread):
(WTF::CCLayerTreeHostTestSetNeedsCommit1::beginTest):
(WTF::CCLayerTreeHostTestSetNeedsCommit2::beginTest):
(WTF::CCLayerTreeHostTestSetNeedsCommit2::drawLayersOnCCThread):
(WTF::CCLayerTreeHostTestSetNeedsRedraw::beginTest):

  • tests/CCSchedulerTest.cpp: Added.
Location:
trunk/Source
Files:
3 added
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r96653 r96655  
     12011-10-04  James Robinson  <jamesr@chromium.org>
     2
     3        [chromium] Extract scheduling logic from CCThreadProxy to its own class
     4        https://bugs.webkit.org/show_bug.cgi?id=69049
     5
     6        Reviewed by Kenneth Russell.
     7
     8        This partially extracts the commit/draw scheduling from CCThreadProxy to a separate isolated class. This makes
     9        the commit/draw logic easier to test, understand and extend.
     10
     11        There is one subtle behavior change here to the way that the function formerly known as
     12        CCLayerTreeHost::setNeedsCommitAndRedraw works. Previously, this would trigger a begin frame message, if one
     13        wasn't pending, and then trigger a redraw if one wasn't pending. This was subtly wrong - the intent of that call
     14        is that a redraw should happen after the commit. It isn't useful to draw before the commit occurs. This patch
     15        changes the name of the function to setNeedsCommitThenRedraw and only requests a redraw after a commit occurs.
     16
     17        Covered by new CCSchedulerTest unit tests, CCLayerTreeHostTest unit tests, and compositing/ layout tests.
     18
     19        * WebCore.gypi:
     20        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
     21        (WebCore::CCLayerTreeHost::initialize):
     22        (WebCore::CCLayerTreeHost::setZoomAnimatorTransform):
     23        (WebCore::CCLayerTreeHost::setNeedsCommitThenRedraw):
     24        (WebCore::CCLayerTreeHost::setViewport):
     25        (WebCore::CCLayerTreeHost::setVisible):
     26        * platform/graphics/chromium/cc/CCLayerTreeHost.h:
     27        * platform/graphics/chromium/cc/CCProxy.h:
     28        * platform/graphics/chromium/cc/CCScheduler.cpp: Added.
     29        (WebCore::CCScheduler::CCScheduler):
     30        (WebCore::CCScheduler::requestCommit):
     31        (WebCore::CCScheduler::requestCommitThenRedraw):
     32        (WebCore::CCScheduler::requestRedraw):
     33        (WebCore::CCScheduler::didCommit):
     34        (WebCore::CCScheduler::didDraw):
     35        * platform/graphics/chromium/cc/CCScheduler.h: Added.
     36        (WebCore::CCSchedulerClient::~CCSchedulerClient):
     37        (WebCore::CCScheduler::create):
     38        (WebCore::CCScheduler::commitPending):
     39        (WebCore::CCScheduler::redrawPending):
     40        (WebCore::CCScheduler::redrawAfterCommit):
     41        * platform/graphics/chromium/cc/CCSingleThreadProxy.cpp:
     42        (WebCore::CCSingleThreadProxy::setNeedsCommitThenRedraw):
     43        (WebCore::CCSingleThreadProxy::setNeedsRedraw):
     44        (WebCore::CCSingleThreadProxy::recreateContextIfNeeded):
     45        (WebCore::CCSingleThreadProxy::doComposite):
     46        * platform/graphics/chromium/cc/CCSingleThreadProxy.h:
     47        * platform/graphics/chromium/cc/CCThreadProxy.cpp:
     48        (WebCore::CCThreadProxySchedulerClient::create):
     49        (WebCore::CCThreadProxySchedulerClient::~CCThreadProxySchedulerClient):
     50        (WebCore::CCThreadProxySchedulerClient::scheduleBeginFrameAndCommit):
     51        (WebCore::CCThreadProxySchedulerClient::scheduleDrawAndPresent):
     52        (WebCore::CCThreadProxySchedulerClient::CCThreadProxySchedulerClient):
     53        (WebCore::CCThreadProxy::CCThreadProxy):
     54        (WebCore::CCThreadProxy::compositeAndReadback):
     55        (WebCore::CCThreadProxy::initializeLayerRenderer):
     56        (WebCore::CCThreadProxy::setNeedsCommit):
     57        (WebCore::CCThreadProxy::setNeedsCommitOnCCThread):
     58        (WebCore::CCThreadProxy::setNeedsCommitThenRedraw):
     59        (WebCore::CCThreadProxy::setNeedsCommitThenRedrawOnCCThread):
     60        (WebCore::CCThreadProxy::setNeedsRedraw):
     61        (WebCore::CCThreadProxy::setNeedsRedrawOnCCThread):
     62        (WebCore::CCThreadProxy::finishAllRenderingOnCCThread):
     63        (WebCore::CCThreadProxy::obtainBeginFrameAndCommitTaskFromCCThread):
     64        (WebCore::CCThreadProxy::createBeginFrameAndCommitTaskOnCCThread):
     65        (WebCore::CCThreadProxy::beginFrameAndCommit):
     66        (WebCore::CCThreadProxy::commitOnCCThread):
     67        (WebCore::CCThreadProxy::drawLayersAndPresentOnCCThread):
     68        (WebCore::CCThreadProxy::initializeImplOnCCThread):
     69        * platform/graphics/chromium/cc/CCThreadProxy.h:
     70
    1712011-10-04  Alexey Proskuryakov  <ap@apple.com>
    272

  • trunk/Source/WebCore/WebCore.gypi

    r96599 r96655  
    34993499            'platform/graphics/chromium/cc/CCLayerTilingData.cpp',
    35003500            'platform/graphics/chromium/cc/CCLayerTilingData.h',
     3501            'platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp',
     3502            'platform/graphics/chromium/cc/CCLayerTreeHostCommon.h',
    35013503            'platform/graphics/chromium/cc/CCLayerTreeHost.cpp',
    35023504            'platform/graphics/chromium/cc/CCLayerTreeHost.h',
    3503             'platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp',
    3504             'platform/graphics/chromium/cc/CCLayerTreeHostCommon.h',
    35053505            'platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp',
    35063506            'platform/graphics/chromium/cc/CCLayerTreeHostImpl.h',
    … …  
    35103510            'platform/graphics/chromium/cc/CCPluginLayerImpl.cpp',
    35113511            'platform/graphics/chromium/cc/CCPluginLayerImpl.h',
     3512            'platform/graphics/chromium/cc/CCProxy.cpp',
    35123513            'platform/graphics/chromium/cc/CCProxy.h',
    3513             'platform/graphics/chromium/cc/CCProxy.cpp',
    3514             'platform/graphics/chromium/cc/CCSingleThreadProxy.h',
    3515             'platform/graphics/chromium/cc/CCSingleThreadProxy.cpp',
    35163514            'platform/graphics/chromium/cc/CCRenderSurface.cpp',
    35173515            'platform/graphics/chromium/cc/CCRenderSurface.h',
     3516            'platform/graphics/chromium/cc/CCScheduler.cpp',
     3517            'platform/graphics/chromium/cc/CCScheduler.h',
     3518            'platform/graphics/chromium/cc/CCSingleThreadProxy.cpp',
     3519            'platform/graphics/chromium/cc/CCSingleThreadProxy.h',
    35183520            'platform/graphics/chromium/cc/CCThread.h',
     3521            'platform/graphics/chromium/cc/CCThreadProxy.cpp',
    35193522            'platform/graphics/chromium/cc/CCThreadProxy.h',
    3520             'platform/graphics/chromium/cc/CCThreadProxy.cpp',
    35213523            'platform/graphics/chromium/cc/CCThreadTask.h',
    35223524            'platform/graphics/chromium/cc/CCTiledLayerImpl.cpp',

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp

    r96454 r96655  
    6161bool CCLayerTreeHost::initialize()
    6262{
     63    TRACE_EVENT("CCLayerTreeHost::initialize", this, 0);
    6364    if (m_settings.enableCompositorThread) {
    6465        // Accelerated Painting is not supported in threaded mode. Turn it off.
    … …  
    7980    m_settings.acceleratePainting = m_proxy->layerRendererCapabilities().usingAcceleratedPainting;
    8081
    81     // We changed the root layer. Tell the proxy a commit is needed.
    82     m_proxy->setNeedsCommitAndRedraw();
     82    setNeedsCommitThenRedraw();
    8383
    8484    m_contentsTextureManager = TextureManager::create(TextureManager::highLimitBytes(), m_proxy->layerRendererCapabilities().maxTextureSize);
    … …  
    197197
    198198    if (zoomChanged)
    199         setNeedsCommitAndRedraw();
    200 }
    201 
    202 void CCLayerTreeHost::setNeedsCommitAndRedraw()
     199        setNeedsCommitThenRedraw();
     200}
     201
     202void CCLayerTreeHost::setNeedsCommitThenRedraw()
    203203{
    204204#if USE(THREADED_COMPOSITING)
    205     TRACE_EVENT("CCLayerTreeHost::setNeedsRedraw", this, 0);
    206     m_proxy->setNeedsCommitAndRedraw();
     205    TRACE_EVENT("CCLayerTreeHost::setNeedsCommitThenRedraw", this, 0);
     206    m_proxy->setNeedsCommitThenRedraw();
    207207#else
    208208    m_client->scheduleComposite();
    … …  
    222222{
    223223    m_viewportSize = viewportSize;
    224     setNeedsCommitAndRedraw();
     224    setNeedsCommitThenRedraw();
    225225}
    226226
    … …  
    229229    m_visible = visible;
    230230    if (visible)
    231         m_proxy->setNeedsCommitAndRedraw();
     231        setNeedsCommitThenRedraw();
    232232    else {
    233233        m_contentsTextureManager->reduceMemoryToLimit(TextureManager::lowLimitBytes());

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h

    r96454 r96655  
    136136    void loseCompositorContext(int numTimes);
    137137
    138     void setNeedsCommitAndRedraw();
     138    void setNeedsCommitThenRedraw();
    139139    void setNeedsRedraw();
    140140

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCProxy.h

    r96454 r96655  
    6464
    6565    virtual void setNeedsCommit() = 0;
    66     virtual void setNeedsCommitAndRedraw() = 0;
     66    virtual void setNeedsCommitThenRedraw() = 0;
    6767    virtual void setNeedsRedraw() = 0;
    6868

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.cpp

    r96454 r96655  
    157157}
    158158
    159 void CCSingleThreadProxy::setNeedsCommitAndRedraw()
     159void CCSingleThreadProxy::setNeedsCommitThenRedraw()
    160160{
    161161    ASSERT(CCProxy::isMainThread());
    … …  
    172172    // FIXME: Once we move render_widget scheduling into this class, we can
    173173    // treat redraw requests more efficiently than commitAndRedraw requests.
    174     setNeedsCommitAndRedraw();
     174    setNeedsCommitThenRedraw();
    175175}
    176176
    … …  
    234234    m_numFailedRecreateAttempts++;
    235235    if (m_numFailedRecreateAttempts < 5) {
    236         setNeedsCommitAndRedraw();
     236        setNeedsCommitThenRedraw();
    237237        return false;
    238238    }
    … …  
    277277          m_graphicsContextLost = true;
    278278          m_numFailedRecreateAttempts = 0;
    279           setNeedsCommitAndRedraw();
     279          setNeedsCommitThenRedraw();
    280280          return false;
    281281      }

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.h

    r96529 r96655  
    4949    virtual void loseCompositorContext(int numTimes);
    5050    virtual void setNeedsCommit();
    51     virtual void setNeedsCommitAndRedraw();
     51    virtual void setNeedsCommitThenRedraw();
    5252    virtual void setNeedsRedraw();
    5353    virtual void start();

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp

    r96454 r96655  
    3131#include "cc/CCLayerTreeHost.h"
    3232#include "cc/CCMainThreadTask.h"
     33#include "cc/CCScheduler.h"
    3334#include "cc/CCThreadTask.h"
    3435#include <wtf/CurrentTime.h>
    … …  
    4849#endif
    4950}
     51
     52class CCThreadProxySchedulerClient : public CCSchedulerClient {
     53public:
     54    static PassOwnPtr<CCThreadProxySchedulerClient> create(CCThreadProxy* proxy)
     55    {
     56        return adoptPtr(new CCThreadProxySchedulerClient(proxy));
     57    }
     58    virtual ~CCThreadProxySchedulerClient() { }
     59
     60    virtual void scheduleBeginFrameAndCommit()
     61    {
     62        CCMainThread::postTask(m_proxy->createBeginFrameAndCommitTaskOnCCThread());
     63    }
     64
     65    virtual void scheduleDrawAndPresent()
     66    {
     67        m_proxy->drawLayersAndPresentOnCCThread();
     68    }
     69
     70private:
     71    explicit CCThreadProxySchedulerClient(CCThreadProxy* proxy)
     72    {
     73        m_proxy = proxy;
     74    }
     75
     76    CCThreadProxy* m_proxy;
     77};
    5078
    5179PassOwnPtr<CCProxy> CCThreadProxy::create(CCLayerTreeHost* layerTreeHost)
    … …  
    6088    , m_lastExecutedBeginFrameAndCommitSequenceNumber(-1)
    6189    , m_numBeginFrameAndCommitsIssuedOnCCThread(0)
    62     , m_beginFrameAndCommitPendingOnCCThread(false)
    63     , m_drawTaskPostedOnCCThread(false)
    64     , m_redrawRequestedOnCCThread(false)
    6590{
    6691    TRACE_EVENT("CCThreadProxy::CCThreadProxy", this, 0);
    … …  
    77102bool CCThreadProxy::compositeAndReadback(void *pixels, const IntRect& rect)
    78103{
     104    TRACE_EVENT("CCThreadPRoxy::compositeAndReadback", this, 0);
    79105    ASSERT(isMainThread());
    80106    ASSERT(m_layerTreeHost);
    … …  
    143169bool CCThreadProxy::initializeLayerRenderer()
    144170{
     171    TRACE_EVENT("CCThreadProxy::initializeLayerRenderer", this, 0);
    145172    RefPtr<GraphicsContext3D> context = m_layerTreeHost->createLayerTreeHostContext3D();
    146173    if (!context)
    … …  
    184211    TRACE_EVENT("CCThreadProxy::setNeedsCommit", this, 0);
    185212    m_commitRequested = true;
    186     s_ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::updateSchedulerStateOnCCThread, m_commitRequested, true));
    187 }
    188 
    189 void CCThreadProxy::setNeedsCommitAndRedraw()
    190 {
    191     ASSERT(isMainThread());
    192     if (m_commitRequested)
    193         return;
    194     m_commitRequested = true;
    195 
    196     TRACE_EVENT("CCThreadProxy::setNeedsCommitAndRedraw", this, 0);
    197     s_ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::updateSchedulerStateOnCCThread, m_commitRequested, true));
     213    s_ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::setNeedsCommitOnCCThread));
     214}
     215
     216void CCThreadProxy::setNeedsCommitThenRedraw()
     217{
     218    ASSERT(isMainThread());
     219    m_redrawAfterCommit = true;
     220    setNeedsCommit();
     221}
     222
     223void CCThreadProxy::setNeedsCommitOnCCThread()
     224{
     225    ASSERT(isImplThread());
     226    TRACE_EVENT("CCThreadProxy::setNeedsCommitOnCCThread", this, 0);
     227    m_schedulerOnCCThread->requestCommit();
    198228}
    199229
    … …  
    201231{
    202232    ASSERT(isMainThread());
    203     if (m_commitRequested) // Implies that a commit is in flight.
    204         return;
    205     // Unlike setNeedsCommit that tracks whether a commit message has been sent,
    206     // setNeedsRedraw always sends a message to the compositor thread. This is
    207     // because the compositor thread can draw without telling the main
    208     // thread. This should not be much of a problem because calls to
    209     // setNeedsRedraw messages are uncommon (only triggered by WM_PAINT/etc),
    210     // compared to setNeedsCommitAndRedraw messages.
    211233    TRACE_EVENT("CCThreadProxy::setNeedsRedraw", this, 0);
    212     s_ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::updateSchedulerStateOnCCThread, false, true));
     234    s_ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::setNeedsRedrawOnCCThread));
     235}
     236
     237void CCThreadProxy::setNeedsRedrawOnCCThread()
     238{
     239    ASSERT(isImplThread());
     240    TRACE_EVENT("CCThreadProxy::setNeedsRedrawOnCCThread", this, 0);
     241    m_schedulerOnCCThread->requestRedraw();
    213242}
    214243
    … …  
    245274    TRACE_EVENT("CCThreadProxy::finishAllRenderingOnCCThread", this, 0);
    246275    ASSERT(isImplThread());
    247     ASSERT(!m_beginFrameAndCommitPendingOnCCThread);
    248     if (m_redrawRequestedOnCCThread) {
     276    if (m_schedulerOnCCThread->redrawPending()) {
    249277        drawLayersOnCCThread();
    250278        m_layerTreeHostImpl->present();
    251         m_redrawRequestedOnCCThread = false;
     279        m_schedulerOnCCThread->didDraw();
    252280    }
    253281    m_layerTreeHostImpl->finishAllRendering();
    … …  
    267295    ASSERT(isImplThread());
    268296    double frameBeginTime = currentTime();
    269     m_beginFrameAndCommitPendingOnCCThread = true;
    270297
    271298    // NOTE, it is possible to receieve a request for a
    … …  
    329356    m_layerTreeHost->commitComplete();
    330357
     358    if (m_redrawAfterCommit)
     359        setNeedsRedraw();
     360    m_redrawAfterCommit = false;
     361
    331362    ASSERT(m_lastExecutedBeginFrameAndCommitSequenceNumber == sequenceNumber);
    332363}
    … …  
    336367    TRACE_EVENT("CCThreadProxy::beginFrameAndCommitOnCCThread", this, 0);
    337368    ASSERT(isImplThread());
    338     ASSERT(m_beginFrameAndCommitPendingOnCCThread);
    339     m_beginFrameAndCommitPendingOnCCThread = false;
     369    ASSERT(m_schedulerOnCCThread->commitPending());
    340370    if (!m_layerTreeHostImpl) {
    341371        completion->signal();
    … …  
    348378    completion->signal();
    349379
    350     if (m_redrawRequestedOnCCThread)
    351         scheduleDrawTaskOnCCThread();
    352 }
    353 
    354 void CCThreadProxy::scheduleDrawTaskOnCCThread()
    355 {
    356     ASSERT(isImplThread());
    357     if (m_drawTaskPostedOnCCThread)
    358         return;
    359     TRACE_EVENT("CCThreadProxy::scheduleDrawTaskOnCCThread", this, 0);
    360     ASSERT(m_layerTreeHostImpl);
    361     m_drawTaskPostedOnCCThread = true;
    362     s_ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::drawLayersAndPresentOnCCThread));
     380    m_schedulerOnCCThread->didCommit();
    363381}
    364382
    … …  
    372390    drawLayersOnCCThread();
    373391    m_layerTreeHostImpl->present();
    374     m_redrawRequestedOnCCThread = false;
    375     m_drawTaskPostedOnCCThread = false;
     392    m_schedulerOnCCThread->didDraw();
    376393}
    377394
    … …  
    386403}
    387404
    388 void CCThreadProxy::updateSchedulerStateOnCCThread(bool commitRequested, bool redrawRequested)
    389 {
    390     TRACE_EVENT("CCThreadProxy::updateSchedulerStateOnCCThread", this, 0);
    391     ASSERT(isImplThread());
    392     ASSERT(m_layerTreeHostImpl);
    393 
    394     // FIXME: use CCScheduler to decide when to manage the conversion of this
    395     // commit request into an actual createBeginFrameAndCommitTaskOnCCThread call.
    396     m_redrawRequestedOnCCThread |= redrawRequested;
    397     if (commitRequested && !m_beginFrameAndCommitPendingOnCCThread) {
    398         CCMainThread::postTask(createBeginFrameAndCommitTaskOnCCThread());
    399         return;
    400     }
    401 
    402     // If no commit is pending, but a redraw is requested, then post a redraw right away
    403     if (m_redrawRequestedOnCCThread)
    404         scheduleDrawTaskOnCCThread();
    405 }
    406 
    407405void CCThreadProxy::initializeImplOnCCThread(CCCompletionEvent* completion)
    408406{
    … …  
    410408    ASSERT(isImplThread());
    411409    m_layerTreeHostImpl = m_layerTreeHost->createLayerTreeHostImpl();
     410    m_schedulerClientOnCCThread = CCThreadProxySchedulerClient::create(this);
     411    m_schedulerOnCCThread = CCScheduler::create(m_schedulerClientOnCCThread.get());
    412412    completion->signal();
    413413}

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.h

    r96454 r96655  
    3535
    3636class CCLayerTreeHost;
     37class CCScheduler;
    3738class CCThread;
     39class CCThreadProxySchedulerClient;
    3840
    3941class CCThreadProxy : public CCProxy {
     42    friend class CCThreadProxySchedulerClient;
    4043public:
    4144    static void setThread(CCThread*);
    … …  
    5457    virtual void loseCompositorContext(int numTimes);
    5558    virtual void setNeedsCommit();
    56     virtual void setNeedsCommitAndRedraw();
     59    virtual void setNeedsCommitThenRedraw();
    5760    virtual void setNeedsRedraw();
    5861    virtual void start();
    … …  
    7679    void initializeLayerRendererOnCCThread(GraphicsContext3D*, CCCompletionEvent*, bool* initializeSucceeded, LayerRendererCapabilities*);
    7780    void setNeedsCommitOnCCThread();
    78     void updateSchedulerStateOnCCThread(bool commitRequested, bool redrawRequested);
     81    void setNeedsRedrawOnCCThread();
     82    void setNeedsCommitThenRedrawOnCCThread();
    7983    void layerTreeHostClosedOnCCThread(CCCompletionEvent*);
    80     void scheduleDrawTaskOnCCThread();
    8184
    8285    // Accessed on main thread only.
    8386    bool m_commitRequested;
     87    bool m_redrawAfterCommit;
    8488    CCLayerTreeHost* m_layerTreeHost;
    8589    LayerRendererCapabilities m_layerRendererCapabilitiesMainThreadCopy;
    … …  
    9094    OwnPtr<CCLayerTreeHostImpl> m_layerTreeHostImpl;
    9195    int m_numBeginFrameAndCommitsIssuedOnCCThread;
    92     bool m_beginFrameAndCommitPendingOnCCThread;
    93     bool m_drawTaskPostedOnCCThread;
    94     bool m_redrawRequestedOnCCThread;
     96
     97    OwnPtr<CCScheduler> m_schedulerOnCCThread;
     98    OwnPtr<CCThreadProxySchedulerClient> m_schedulerClientOnCCThread;
    9599
    96100    static CCThread* s_ccThread;

  • trunk/Source/WebKit/chromium/ChangeLog

    r96654 r96655  
     12011-10-04  James Robinson  <jamesr@chromium.org>
     2
     3        [chromium] Extract scheduling logic from CCThreadProxy to its own class
     4        https://bugs.webkit.org/show_bug.cgi?id=69049
     5
     6        Reviewed by Kenneth Russell.
     7
     8        Adds some unit tests for the new CCScheduler class. Since the class is very simple today, the tests are
     9        similarly quite simple.
     10
     11        * WebKit.gypi:
     12        * src/WebViewImpl.cpp:
     13        (WebKit::WebViewImpl::setRootLayerNeedsDisplay):
     14        * tests/CCLayerTreeHostTest.cpp:
     15        (WTF::CCLayerTreeHostTest::postSetNeedsCommitThenRedrawToMainThread):
     16        (WTF::CCLayerTreeHostTest::dispatchSetNeedsCommitThenRedraw):
     17        (WTF::CCLayerTreeHostTestShortlived2::beginTest):
     18        (WTF::CCLayerTreeHostTestCommitingWithContinuousRedraw::beginTest):
     19        (WTF::CCLayerTreeHostTestCommitingWithContinuousRedraw::drawLayersOnCCThread):
     20        (WTF::CCLayerTreeHostTestSetNeedsCommit1::beginTest):
     21        (WTF::CCLayerTreeHostTestSetNeedsCommit2::beginTest):
     22        (WTF::CCLayerTreeHostTestSetNeedsCommit2::drawLayersOnCCThread):
     23        (WTF::CCLayerTreeHostTestSetNeedsRedraw::beginTest):
     24        * tests/CCSchedulerTest.cpp: Added.
     25
    1262011-10-04  Scott Graham  <scottmg@chromium.org>
    227

  • trunk/Source/WebKit/chromium/WebKit.gypi

    r96529 r96655  
    5656            'tests/AssociatedURLLoaderTest.cpp',
    5757            'tests/CCLayerSorterTest.cpp',
     58            'tests/CCLayerTreeHostImplTest.cpp',
    5859            'tests/CCLayerTreeHostTest.cpp',
    59             'tests/CCLayerTreeHostImplTest.cpp',
     60            'tests/CCSchedulerTest.cpp',
    6061            'tests/CCThreadTaskTest.cpp',
    6162            'tests/CCThreadTest.cpp',

  • trunk/Source/WebKit/chromium/src/WebViewImpl.cpp

    r96654 r96655  
    25752575#if USE(THREADED_COMPOSITING)
    25762576    if (m_layerTreeHost)
    2577         m_layerTreeHost->setNeedsCommitAndRedraw();
     2577        m_layerTreeHost->setNeedsCommitThenRedraw();
    25782578#else
    25792579    m_client->scheduleComposite();

  • trunk/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp

    r96529 r96655  
    198198    void endTest();
    199199
    200     void postSetNeedsCommitToMainThread()
    201     {
    202         callOnMainThread(CCLayerTreeHostTest::dispatchSetNeedsCommit, this);
     200    void postSetNeedsCommitThenRedrawToMainThread()
     201    {
     202        callOnMainThread(CCLayerTreeHostTest::dispatchSetNeedsCommitThenRedraw, this);
    203203    }
    204204
    … …  
    240240    }
    241241
    242     static void dispatchSetNeedsCommit(void* self)
     242    static void dispatchSetNeedsCommitThenRedraw(void* self)
    243243    {
    244244      ASSERT(isMainThread());
    … …  
    246246      ASSERT(test);
    247247      if (test->m_layerTreeHost)
    248           test->m_layerTreeHost->setNeedsCommitAndRedraw();
     248          test->m_layerTreeHost->setNeedsCommitThenRedraw();
    249249    }
    250250
    … …  
    365365    virtual void beginTest()
    366366    {
    367         postSetNeedsCommitToMainThread();
     367        postSetNeedsCommitThenRedrawToMainThread();
    368368        endTest();
    369369    }
    … …  
    409409    virtual void beginTest()
    410410    {
    411         postSetNeedsCommitToMainThread();
     411        postSetNeedsCommitThenRedrawToMainThread();
    412412        endTest();
    413413    }
    … …  
    423423    {
    424424        if (m_numDraws == 1)
    425           postSetNeedsCommitToMainThread();
     425          postSetNeedsCommitThenRedrawToMainThread();
    426426        m_numDraws++;
    427427        postSetNeedsRedrawToMainThread();
    … …  
    453453    virtual void beginTest()
    454454    {
    455         postSetNeedsCommitToMainThread();
    456         postSetNeedsCommitToMainThread();
     455        postSetNeedsCommitThenRedrawToMainThread();
     456        postSetNeedsCommitThenRedrawToMainThread();
    457457    }
    458458
    … …  
    496496    virtual void beginTest()
    497497    {
    498         postSetNeedsCommitToMainThread();
     498        postSetNeedsCommitThenRedrawToMainThread();
    499499    }
    500500
    … …  
    502502    {
    503503        if (!impl->sourceFrameNumber())
    504             postSetNeedsCommitToMainThread();
     504            postSetNeedsCommitThenRedrawToMainThread();
    505505        else if (impl->sourceFrameNumber() == 1)
    506506            endTest();
    … …  
    539539    virtual void beginTest()
    540540    {
    541         postSetNeedsCommitToMainThread();
     541        postSetNeedsCommitThenRedrawToMainThread();
    542542    }
    543543
    … …  
    587587        m_layerTreeHost->rootLayer()->setMaxScrollPosition(IntSize(100, 100));
    588588        m_layerTreeHost->rootLayer()->setScrollPosition(m_initialScroll);
    589         postSetNeedsCommitToMainThread();
     589        postSetNeedsCommitThenRedrawToMainThread();
    590590    }
    591591
    … …  
    613613            EXPECT_EQ(root->scrollPosition(), m_initialScroll);
    614614            EXPECT_EQ(root->scrollDelta(), m_scrollAmount);
    615             postSetNeedsCommitToMainThread();
     615            postSetNeedsCommitThenRedrawToMainThread();
    616616        } else if (impl->frameNumber() == 2) {
    617617            EXPECT_EQ(root->scrollPosition(), m_secondScroll);
    … …  
    656656        m_layerTreeHost->rootLayer()->setMaxScrollPosition(IntSize(100, 100));
    657657        m_layerTreeHost->rootLayer()->setScrollPosition(m_initialScroll);
    658         postSetNeedsCommitToMainThread();
     658        postSetNeedsCommitThenRedrawToMainThread();
    659659    }
    660660
    … …  
    687687
    688688            EXPECT_EQ(root->scrollPosition(), m_initialScroll);
    689             postSetNeedsCommitToMainThread();
     689            postSetNeedsCommitThenRedrawToMainThread();
    690690        } else if (impl->frameNumber() == 3) {
    691691            EXPECT_EQ(root->scrollDelta(), IntSize());
Note: See TracChangeset for help on using the changeset viewer.