Changeset 95702 in webkit


Ignore:
Timestamp:
Sep 22, 2011 12:53:28 AM (13 years ago)
Author:
jamesr@google.com
Message:

Unreviewed, rolling out r95699.
​http://trac.webkit.org/changeset/95699
​https://bugs.webkit.org/show_bug.cgi?id=67417

Makes many chromium compositor tests crash

Source/WebCore:

  • platform/CrossThreadCopier.h:
  • platform/graphics/chromium/LayerRendererChromium.cpp:

(WebCore::LayerRendererChromium::~LayerRendererChromium):

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

(WebCore::CCHeadsUpDisplay::enabled):

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

(WebCore::CCLayerImpl::CCLayerImpl):
(WebCore::CCLayerImpl::~CCLayerImpl):

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

(WebCore::CCLayerTreeHost::CCLayerTreeHost):
(WebCore::CCLayerTreeHost::commitTo):
(WebCore::CCLayerTreeHost::setNeedsRedraw):

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

(WebCore::CCSettings::CCSettings):

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

(WebCore::CCLayerTreeHostImpl::CCLayerTreeHostImpl):
(WebCore::CCLayerTreeHostImpl::~CCLayerTreeHostImpl):

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

(WebCore::CCSingleThreadProxy::finishAllRendering):
(WebCore::CCSingleThreadProxy::setNeedsCommit):
(WebCore::CCSingleThreadProxy::commitIfNeeded):

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

(WebCore::CCThreadProxy::CCThreadProxy):
(WebCore::CCThreadProxy::~CCThreadProxy):
(WebCore::CCThreadProxy::compositeAndReadback):
(WebCore::CCThreadProxy::finishAllRendering):
(WebCore::CCThreadProxy::isStarted):
(WebCore::CCThreadProxy::initializeLayerRenderer):
(WebCore::CCThreadProxy::setNeedsCommit):
(WebCore::CCThreadProxy::setNeedsCommitAndRedraw):
(WebCore::CCThreadProxy::setNeedsRedraw):
(WebCore::CCThreadProxy::start):
(WebCore::CCThreadProxy::stop):
(WebCore::CCThreadProxy::beginFrameAndCommitOnCCThread):
(WebCore::CCThreadProxy::beginFrameAndCommit):
(WebCore::CCThreadProxy::commitOnCCThread):
(WebCore::CCThreadProxy::drawLayersOnCCThread):
(WebCore::CCThreadProxy::setNeedsCommitOnCCThread):
(WebCore::CCThreadProxy::setNeedsCommitAndRedrawOnCCThread):
(WebCore::CCThreadProxy::setNeedsRedrawOnCCThread):

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

Source/WebKit/chromium:

  • tests/CCLayerTreeHostTest.cpp:

(WTF::CCLayerTreeHostTest::doBeginTest):
(WTF::TEST_F):

  • tests/TreeSynchronizerTest.cpp:

(WebCore::TEST):

Location:
trunk/Source
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r95699 r95702  
     12011-09-22  James Robinson  <jamesr@chromium.org>
     2
     3        Unreviewed, rolling out r95699.
     4        http://trac.webkit.org/changeset/95699
     5        https://bugs.webkit.org/show_bug.cgi?id=67417
     6
     7        Makes many chromium compositor tests crash
     8
     9        * platform/CrossThreadCopier.h:
     10        * platform/graphics/chromium/LayerRendererChromium.cpp:
     11        (WebCore::LayerRendererChromium::~LayerRendererChromium):
     12        * platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:
     13        (WebCore::CCHeadsUpDisplay::enabled):
     14        * platform/graphics/chromium/cc/CCLayerImpl.cpp:
     15        (WebCore::CCLayerImpl::CCLayerImpl):
     16        (WebCore::CCLayerImpl::~CCLayerImpl):
     17        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
     18        (WebCore::CCLayerTreeHost::CCLayerTreeHost):
     19        (WebCore::CCLayerTreeHost::commitTo):
     20        (WebCore::CCLayerTreeHost::setNeedsRedraw):
     21        * platform/graphics/chromium/cc/CCLayerTreeHost.h:
     22        (WebCore::CCSettings::CCSettings):
     23        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
     24        (WebCore::CCLayerTreeHostImpl::CCLayerTreeHostImpl):
     25        (WebCore::CCLayerTreeHostImpl::~CCLayerTreeHostImpl):
     26        * platform/graphics/chromium/cc/CCProxy.h:
     27        * platform/graphics/chromium/cc/CCSingleThreadProxy.cpp:
     28        (WebCore::CCSingleThreadProxy::finishAllRendering):
     29        (WebCore::CCSingleThreadProxy::setNeedsCommit):
     30        (WebCore::CCSingleThreadProxy::commitIfNeeded):
     31        * platform/graphics/chromium/cc/CCThreadProxy.cpp:
     32        (WebCore::CCThreadProxy::CCThreadProxy):
     33        (WebCore::CCThreadProxy::~CCThreadProxy):
     34        (WebCore::CCThreadProxy::compositeAndReadback):
     35        (WebCore::CCThreadProxy::finishAllRendering):
     36        (WebCore::CCThreadProxy::isStarted):
     37        (WebCore::CCThreadProxy::initializeLayerRenderer):
     38        (WebCore::CCThreadProxy::setNeedsCommit):
     39        (WebCore::CCThreadProxy::setNeedsCommitAndRedraw):
     40        (WebCore::CCThreadProxy::setNeedsRedraw):
     41        (WebCore::CCThreadProxy::start):
     42        (WebCore::CCThreadProxy::stop):
     43        (WebCore::CCThreadProxy::beginFrameAndCommitOnCCThread):
     44        (WebCore::CCThreadProxy::beginFrameAndCommit):
     45        (WebCore::CCThreadProxy::commitOnCCThread):
     46        (WebCore::CCThreadProxy::drawLayersOnCCThread):
     47        (WebCore::CCThreadProxy::setNeedsCommitOnCCThread):
     48        (WebCore::CCThreadProxy::setNeedsCommitAndRedrawOnCCThread):
     49        (WebCore::CCThreadProxy::setNeedsRedrawOnCCThread):
     50        * platform/graphics/chromium/cc/CCThreadProxy.h:
     51
    1522011-09-22  Nat Duca  <nduca@chromium.org>
    253

  • trunk/Source/WebCore/platform/CrossThreadCopier.h

    r95699 r95702  
    4242namespace WebCore {
    4343
    44     class IntRect;
    4544    class KURL;
    4645    class ResourceError;
    … …  
    6564    };
    6665
    67     // To allow a type to be passed across threads using its copy constructor, add a forward declaration of the type and
    68     // a CopyThreadCopierBase<false, false, TypeName> : public CrossThreadCopierPassThrough<TypeName> { }; to this file.
    6966    template<> struct CrossThreadCopierBase<false, false, ThreadableLoaderOptions> : public CrossThreadCopierPassThrough<ThreadableLoaderOptions> {
    70     };
    71 
    72     template<> struct CrossThreadCopierBase<false, false, IntRect> : public CrossThreadCopierPassThrough<IntRect> {
    7367    };
    7468

  • trunk/Source/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp

    r95699 r95702  
    183183LayerRendererChromium::~LayerRendererChromium()
    184184{
    185     ASSERT(CCProxy::isMainThread());
    186185    m_headsUpDisplay.clear(); // Explicitly destroy the HUD before the TextureManager dies.
    187186    cleanupSharedObjects();

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

    r95699 r95702  
    9090bool CCHeadsUpDisplay::enabled() const
    9191{
    92     // FIXME: HUD does not work in compositor thread mode.
    93     if (settings().enableCompositorThread)
    94         return false;
    9592    return settings().showPlatformLayerTree || settings().showFPSCounter;
    9693}

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

    r95699 r95702  
    5656    , m_debugBorderWidth(0)
    5757{
    58     ASSERT(CCProxy::isImplThread());
    5958}
    6059
    6160CCLayerImpl::~CCLayerImpl()
    6261{
    63     ASSERT(CCProxy::isImplThread());
    6462}
    6563

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

    r95699 r95702  
    5757    , m_visible(true)
    5858{
    59     ASSERT(CCProxy::isMainThread());
    6059}
    6160
    … …  
    108107}
    109108
    110 // This function commits the CCLayerTreeHost to an impl tree. When modifying
    111 // this function, keep in mind that the function *runs* on the impl thread! Any
    112 // code that is logically a main thread operation, e.g. deletion of a LayerChromium,
    113 // should be delayed until the CCLayerTreeHost::commitComplete, which will run
    114 // after the commit, but on the main thread.
    115109void CCLayerTreeHost::commitTo(CCLayerTreeHostImpl* hostImpl)
    116110{
    … …  
    127121
    128122    updateCompositorResources(m_updateList, hostImpl->context());
     123    clearPendingUpdate();
    129124
    130125    hostImpl->setVisible(m_visible);
    … …  
    133128
    134129    hostImpl->layerRenderer()->setContentsTextureMemoryUseBytes(m_contentsTextureManager->currentMemoryUseBytes());
     130    m_contentsTextureManager->unprotectAllTextures();
    135131
    136132    // Synchronize trees, if one exists at all...
    … …  
    141137
    142138    m_frameNumber++;
    143 }
    144 
    145 void CCLayerTreeHost::commitComplete()
    146 {
    147     clearPendingUpdate();
    148     m_contentsTextureManager->unprotectAllTextures();
    149139}
    150140
    … …  
    225215{
    226216#if USE(THREADED_COMPOSITING)
     217    TRACE_EVENT("CCLayerTreeHost::setNeedsRedraw", this, 0);
    227218    m_proxy->setNeedsRedraw();
    228219#else

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

    r95699 r95702  
    6868            , showFPSCounter(false)
    6969            , showPlatformLayerTree(false) { }
    70     CCSettings(bool acceleratePainting, bool compositeOffscreen, bool enableCompositorThread, bool showFPSCounter, bool showPlatformLayerTree)
    71             : acceleratePainting(acceleratePainting)
    72             , compositeOffscreen(compositeOffscreen)
    73             , enableCompositorThread(enableCompositorThread)
    74             , showFPSCounter(showFPSCounter)
    75             , showPlatformLayerTree(showPlatformLayerTree) { }
    7670
    7771    bool acceleratePainting;
    … …  
    10397    // CCLayerTreeHost interface to CCProxy.
    10498    void animateAndLayout(double frameBeginTime);
    105     void commitComplete();
    10699    void commitTo(CCLayerTreeHostImpl*);
    107100    PassOwnPtr<CCThread> createCompositorThread();

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

    r95699 r95702  
    4949    , m_settings(settings)
    5050{
    51     ASSERT(CCProxy::isImplThread());
    5251}
    5352
    5453CCLayerTreeHostImpl::~CCLayerTreeHostImpl()
    5554{
    56     ASSERT(CCProxy::isImplThread());
    5755    TRACE_EVENT("CCLayerTreeHostImpl::~CCLayerTreeHostImpl()", this, 0);
    5856    if (m_layerRenderer)

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

    r95699 r95702  
    7676#endif
    7777
     78    // Testing hooks
     79    virtual void loseCompositorContext(int numTimes) = 0;
     80
    7881    // Temporary hack while render_widget still does scheduling for CCLayerTreeHostMainThreadI
    7982    virtual GraphicsContext3D* context() = 0;
    8083
    81     // Testing hooks
    82     virtual void loseCompositorContext(int numTimes) = 0;
    83 
     84protected:
     85    CCProxy() { }
     86    friend class ScopedSetImplThread;
    8487#ifndef NDEBUG
    8588    static void setImplThread(bool);
    8689    static void setImplThread(WTF::ThreadIdentifier);
    8790#endif
    88 
    89 protected:
    90     CCProxy() { }
    91     friend class ScopedSetImplThread;
    9291};
    9392

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

    r95699 r95702  
    112112{
    113113    ASSERT(isMainThread());
    114     if (!recreateContextIfNeeded())
    115         return;
    116 
    117     commitIfNeeded();
    118 
    119     {
    120         ScopedSetImplThread impl;
    121         m_layerTreeHostImpl->finishAllRendering();
    122     }
     114    ScopedSetImplThread impl;
     115    m_layerTreeHostImpl->finishAllRendering();
    123116}
    124117
    … …  
    165158        m_layerTreeHostImpl->commitComplete();
    166159    }
    167     m_layerTreeHost->commitComplete();
    168160}
    169161
    … …  
    259251        m_layerTreeHostImpl->commitComplete();
    260252    }
    261     m_layerTreeHost->commitComplete();
    262253}
    263254

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

    r95699 r95702  
    3232#include "cc/CCMainThreadTask.h"
    3333#include "cc/CCThreadTask.h"
    34 #include <wtf/CurrentTime.h>
    3534#include <wtf/MainThread.h>
    3635
    … …  
    5049
    5150CCThreadProxy::CCThreadProxy(CCLayerTreeHost* layerTreeHost)
    52     : m_commitRequested(false)
     51    : m_commitPending(false)
    5352    , m_layerTreeHost(layerTreeHost)
    54     , m_started(false)
    55     , m_lastExecutedBeginFrameAndCommitSequenceNumber(-1)
    56     , m_numBeginFrameAndCommitsIssuedOnCCThread(0)
    57     , m_beginFrameAndCommitPendingOnCCThread(false)
    58     , m_drawTaskPostedOnCCThread(false)
    59     , m_redrawRequestedOnCCThread(false)
    6053{
    6154    TRACE_EVENT("CCThreadProxy::CCThreadProxy", this, 0);
    … …  
    7467    TRACE_EVENT("CCThreadProxy::~CCThreadProxy", this, 0);
    7568    ASSERT(isMainThread());
    76     ASSERT(!m_started);
     69    ASSERT(!m_layerTreeHostImpl); // Make sure stop() got called.
     70    ASSERT(!m_layerTreeHost); // Make sure stop() got called.
    7771
    7872    numProxies--;
    … …  
    8579bool CCThreadProxy::compositeAndReadback(void *pixels, const IntRect& rect)
    8680{
    87     ASSERT(isMainThread());
    88     ASSERT(m_layerTreeHost);
    89 
    90     finishAllRendering();
    91     bool success = false;
    92     CCCompletionEvent completion;
    93     ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::drawLayersAndReadbackOnCCThread, AllowCrossThreadAccess(&completion), AllowCrossThreadAccess(&success), AllowCrossThreadAccess(pixels), rect));
    94     completion.wait();
    95     return success;
    96 }
    97 
    98 void CCThreadProxy::drawLayersAndReadbackOnCCThread(CCCompletionEvent* completion, bool* success, void* pixels, const IntRect& rect)
    99 {
    100     ASSERT(CCProxy::isImplThread());
    101     if (!m_layerTreeHostImpl) {
    102         *success = false;
    103         completion->signal();
    104         return;
    105     }
    106     drawLayersOnCCThread();
    107     m_layerTreeHostImpl->readback(pixels, rect);
    108     *success = m_layerTreeHostImpl->isContextLost();
    109     completion->signal();
     81    ASSERT_NOT_REACHED();
     82    return false;
    11083}
    11184
    … …  
    11790void CCThreadProxy::finishAllRendering()
    11891{
    119     ASSERT(CCProxy::isMainThread());
    120     // If a commit is pending, perform the commit first.
    121     if (m_commitRequested)  {
    122         // This bit of code is uglier than it should be because returning
    123         // pointers via the CCThread task model is really messy. Effectively, we
    124         // are making a blocking call to createBeginFrameAndCommitTaskOnCCThread,
    125         // and trying to get the CCMainThread::Task it returns so we can run it.
    126         OwnPtr<CCMainThread::Task> beginFrameAndCommitTask;
    127         {
    128             CCMainThread::Task* taskPtr = 0;
    129             CCCompletionEvent completion;
    130             ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::createBeginFrameAndCommitTaskOnCCThread, AllowCrossThreadAccess(&completion), AllowCrossThreadAccess(&taskPtr)));
    131             completion.wait();
    132             beginFrameAndCommitTask = adoptPtr(taskPtr);
    133         }
    134 
    135         beginFrameAndCommitTask->performTask();
    136     }
    137     // Make sure all GL drawing is finished on the impl thread.
    138     CCCompletionEvent completion;
    139     ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::finishAllRenderingOnCCThread, AllowCrossThreadAccess(&completion)));
    140     completion.wait();
     92    ASSERT_NOT_REACHED();
    14193}
    14294
    14395bool CCThreadProxy::isStarted() const
    14496{
    145     ASSERT(CCProxy::isMainThread());
    146     return m_started;
     97    return m_layerTreeHostImpl;
    14798}
    14899
    … …  
    161112    // are pushed into the initializeSucceeded and capabilities local variables.
    162113    CCCompletionEvent completion;
    163     bool initializeSucceeded = false;
     114    bool initializeSucceeded;
    164115    LayerRendererCapabilities capabilities;
    165116    ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::initializeLayerRendererOnCCThread,
    … …  
    185136{
    186137    ASSERT(isMainThread());
    187     if (m_commitRequested)
     138    if (m_commitPending)
    188139        return;
    189140
    190141    TRACE_EVENT("CCThreadProxy::setNeedsCommit", this, 0);
    191     m_commitRequested = true;
    192     ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::updateSchedulerStateOnCCThread, m_commitRequested, true));
     142    m_commitPending = true;
     143    ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::setNeedsCommitOnCCThread));
    193144}
    194145
    … …  
    196147{
    197148    ASSERT(isMainThread());
    198     if (m_commitRequested)
     149    if (m_commitPending)
    199150        return;
    200     m_commitRequested = true;
    201151
    202152    TRACE_EVENT("CCThreadProxy::setNeedsCommitAndRedraw", this, 0);
    203     ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::updateSchedulerStateOnCCThread, m_commitRequested, true));
     153    m_commitPending = true;
     154    ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::setNeedsCommitAndRedrawOnCCThread));
    204155}
    205156
    … …  
    207158{
    208159    ASSERT(isMainThread());
    209     if (m_commitRequested) // Implies that a commit is in flight.
    210         return;
    211     // Unlike setNeedsCommit that tracks whether a commit message has been sent,
    212     // setNeedsRedraw always sends a message to the compositor thread. This is
    213     // because the compositor thread can draw without telling the main
    214     // thread. This should not be much of a problem because calls to
    215     // setNeedsRedraw messages are uncommon (only triggered by WM_PAINT/etc),
    216     // compared to setNeedsCommitAndRedraw messages.
    217     TRACE_EVENT("CCThreadProxy::setNeedsRedraw", this, 0);
    218     ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::updateSchedulerStateOnCCThread, false, true));
     160    ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::setNeedsRedrawOnCCThread));
    219161}
    220162
    221163void CCThreadProxy::start()
    222164{
    223     ASSERT(isMainThread());
    224165    // Create LayerTreeHostImpl.
    225166    CCCompletionEvent completion;
    226167    ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::initializeImplOnCCThread, AllowCrossThreadAccess(&completion)));
    227168    completion.wait();
    228 
    229     m_started = true;
    230169}
    231170
    … …  
    234173    TRACE_EVENT("CCThreadProxy::stop", this, 0);
    235174    ASSERT(isMainThread());
    236     ASSERT(m_started);
    237 
    238175    // Synchronously deletes the impl.
    239176    CCCompletionEvent completion;
    … …  
    243180    ASSERT(!m_layerTreeHostImpl); // verify that the impl deleted.
    244181    m_layerTreeHost = 0;
    245     m_started = false;
    246 }
    247 
    248 void CCThreadProxy::finishAllRenderingOnCCThread(CCCompletionEvent* completion)
    249 {
    250     TRACE_EVENT("CCThreadProxy::finishAllRenderingOnCCThread", this, 0);
    251     ASSERT(isImplThread());
    252     ASSERT(!m_beginFrameAndCommitPendingOnCCThread);
    253     if (m_redrawRequestedOnCCThread) {
    254         drawLayersOnCCThread();
    255         m_layerTreeHostImpl->present();
    256         m_redrawRequestedOnCCThread = false;
    257     }
    258     m_layerTreeHostImpl->finishAllRendering();
    259     completion->signal();
    260 }
    261 
    262 void CCThreadProxy::createBeginFrameAndCommitTaskOnCCThread(CCCompletionEvent* completion, CCMainThread::Task** taskPtr)
    263 {
    264     OwnPtr<CCMainThread::Task> task = createBeginFrameAndCommitTaskOnCCThread();
    265     *taskPtr = task.leakPtr();
    266     completion->signal();
    267 }
    268 
    269 PassOwnPtr<CCMainThread::Task> CCThreadProxy::createBeginFrameAndCommitTaskOnCCThread()
    270 {
    271     TRACE_EVENT("CCThreadProxy::createBeginFrameAndCommitTaskOnCCThread", this, 0);
    272     ASSERT(isImplThread());
    273     double frameBeginTime = currentTime();
    274     m_beginFrameAndCommitPendingOnCCThread = true;
    275 
    276     // NOTE, it is possible to receieve a request for a
    277     // beginFrameAndCommitOnCCThread from finishAllRendering while a
    278     // beginFrameAndCommitOnCCThread is enqueued. Since it CCMainThread doesn't
    279     // provide a threadsafe way to cancel tasks, it is important that
    280     // beginFrameAndCommit be structured to understand that it may get called at
    281     // a point that it shouldn't. We do this by assigning a sequence number to
    282     // every new beginFrameAndCommit task. Then, beginFrameAndCommit tracks the
    283     // last executed sequence number, dropping beginFrameAndCommit with sequence
    284     // numbers below the last executed one.
    285     int thisTaskSequenceNumber = m_numBeginFrameAndCommitsIssuedOnCCThread;
    286     m_numBeginFrameAndCommitsIssuedOnCCThread++;
    287     return createMainThreadTask(this, &CCThreadProxy::beginFrameAndCommit, thisTaskSequenceNumber, frameBeginTime);
    288 }
    289 
    290 void CCThreadProxy::beginFrameAndCommit(int sequenceNumber, double frameBeginTime)
    291 {
    292     TRACE_EVENT("CCThreadProxy::beginFrameAndCommit", this, 0);
     182}
     183
     184void CCThreadProxy::beginFrameAndCommitOnCCThread()
     185{
     186    TRACE_EVENT("CCThreadProxy::beginFrameAndCommitOnCCThread", this, 0);
     187    ASSERT(isImplThread());
     188    // TEMP HACK so we can exercise this code in unit tests.
     189    CCMainThread::postTask(createMainThreadTask(this, &CCThreadProxy::beginFrameAndCommit, 0.0));
     190}
     191
     192void CCThreadProxy::beginFrameAndCommit(double frameBeginTime)
     193{
    293194    ASSERT(isMainThread());
    294195    if (!m_layerTreeHost)
    295196        return;
    296197
    297     // Drop beginFrameAndCommit calls that occur out of sequence. See createBeginFrameAndCommitTaskOnCCThread for
    298     // an explanation of how out-of-sequence beginFrameAndCommit tasks can occur.
    299     if (sequenceNumber < m_lastExecutedBeginFrameAndCommitSequenceNumber) {
    300         TRACE_EVENT("EarlyOut_StaleBeginFrameAndCommit", this, 0);
    301         return;
    302     }
    303     m_lastExecutedBeginFrameAndCommitSequenceNumber = sequenceNumber;
    304 
    305     ASSERT(m_commitRequested);
    306 
    307     // FIXME: recreate the context if it was requested by the impl thread
     198    TRACE_EVENT("CCThreadProxy::requestFrameAndCommit", this, 0);
    308199    {
    309200        TRACE_EVENT("CCLayerTreeHost::animateAndLayout", this, 0);
    … …  
    311202    }
    312203
    313     ASSERT(m_lastExecutedBeginFrameAndCommitSequenceNumber == sequenceNumber);
    314 
    315     // Clear the commit flag after animateAndLayout here --- objects that only
    316     // layout when painted will trigger another setNeedsCommit inside
    317     // updateLayers.
    318     m_commitRequested = false;
    319 
    320     m_layerTreeHost->updateLayers();
    321 
     204    m_commitPending = false;
     205
     206    // Blocking call to CCThreadProxy::performCommit
     207    CCCompletionEvent completion;
     208    ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::commitOnCCThread, AllowCrossThreadAccess(&completion)));
     209    completion.wait();
     210}
     211
     212void CCThreadProxy::commitOnCCThread(CCCompletionEvent* completion)
     213{
     214    ASSERT(isImplThread());
     215    TRACE_EVENT("CCThreadProxy::commitOnCCThread", this, 0);
     216    m_layerTreeHostImpl->beginCommit();
    322217    {
    323         // Blocking call to CCThreadProxy::commitOnCCThread
    324         TRACE_EVENT("commit", this, 0);
    325         CCCompletionEvent completion;
    326         ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::commitOnCCThread, AllowCrossThreadAccess(&completion)));
    327         completion.wait();
    328     }
    329 
    330     m_layerTreeHost->commitComplete();
    331 
    332     ASSERT(m_lastExecutedBeginFrameAndCommitSequenceNumber == sequenceNumber);
    333 }
    334 
    335 void CCThreadProxy::commitOnCCThread(CCCompletionEvent* completion)
    336 {
    337     TRACE_EVENT("CCThreadProxy::beginFrameAndCommitOnCCThread", this, 0);
    338     ASSERT(isImplThread());
    339     ASSERT(m_beginFrameAndCommitPendingOnCCThread);
    340     m_beginFrameAndCommitPendingOnCCThread = false;
    341     if (!m_layerTreeHostImpl) {
    342         completion->signal();
    343         return;
    344     }
    345     m_layerTreeHostImpl->beginCommit();
    346     m_layerTreeHost->commitTo(m_layerTreeHostImpl.get());
     218        TRACE_EVENT("CCLayerTreeHost::commit", this, 0);
     219        m_layerTreeHost->commitTo(m_layerTreeHostImpl.get());
     220    }
     221    completion->signal();
     222
    347223    m_layerTreeHostImpl->commitComplete();
    348 
    349     completion->signal();
    350 
    351     if (m_redrawRequestedOnCCThread)
    352         scheduleDrawTaskOnCCThread();
    353 }
    354 
    355 void CCThreadProxy::scheduleDrawTaskOnCCThread()
    356 {
    357     ASSERT(isImplThread());
    358     if (m_drawTaskPostedOnCCThread)
    359         return;
    360     TRACE_EVENT("CCThreadProxy::scheduleDrawTaskOnCCThread", this, 0);
     224    setNeedsRedrawOnCCThread();
     225}
     226
     227void CCThreadProxy::drawLayersOnCCThread()
     228{
     229    TRACE_EVENT("CCThreadProxy::drawLayersOnCCThread", this, 0);
     230    ASSERT(isImplThread());
     231    if (m_layerTreeHostImpl)
     232        m_layerTreeHostImpl->drawLayers();
     233}
     234
     235void CCThreadProxy::setNeedsCommitOnCCThread()
     236{
     237    TRACE_EVENT("CCThreadProxy::setNeedsCommitOnCCThread", this, 0);
     238    ASSERT(isImplThread());
    361239    ASSERT(m_layerTreeHostImpl);
    362     m_drawTaskPostedOnCCThread = true;
    363     ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::drawLayersAndPresentOnCCThread));
    364 }
    365 
    366 void CCThreadProxy::drawLayersAndPresentOnCCThread()
    367 {
    368     TRACE_EVENT("CCThreadProxy::drawLayersOnCCThread", this, 0);
    369     ASSERT(isImplThread());
    370     if (!m_layerTreeHostImpl)
    371         return;
    372 
     240    // FIXME: Not yet implemented, see https://bugs.webkit.org/show_bug.cgi?id=67417
     241    ASSERT_NOT_REACHED();
     242}
     243
     244void CCThreadProxy::setNeedsCommitAndRedrawOnCCThread()
     245{
     246    TRACE_EVENT("CCThreadProxy::setNeedsCommitAndRedrawOnCCThread", this, 0);
     247    ASSERT(isImplThread());
     248    ASSERT(m_layerTreeHostImpl);
     249    // TEMP HACK so we can exercise this code in unit tests.
     250    CCMainThread::postTask(createMainThreadTask(this, &CCThreadProxy::beginFrameAndCommit, 0.0));
     251}
     252
     253void CCThreadProxy::setNeedsRedrawOnCCThread()
     254{
     255    TRACE_EVENT("CCThreadProxy::setNeedsRedrawOnCCThread", this, 0);
     256    // TEMP HACK so we can exercise this code in unit tests.
    373257    drawLayersOnCCThread();
    374     m_layerTreeHostImpl->present();
    375     m_redrawRequestedOnCCThread = false;
    376     m_drawTaskPostedOnCCThread = false;
    377 }
    378 
    379 void CCThreadProxy::drawLayersOnCCThread()
    380 {
    381     TRACE_EVENT("CCThreadProxy::drawLayersOnCCThread", this, 0);
    382     ASSERT(isImplThread());
    383     ASSERT(m_layerTreeHostImpl);
    384 
    385     m_layerTreeHostImpl->drawLayers();
    386     ASSERT(!m_layerTreeHostImpl->isContextLost());
    387 }
    388 
    389 void CCThreadProxy::updateSchedulerStateOnCCThread(bool commitRequested, bool redrawRequested)
    390 {
    391     TRACE_EVENT("CCThreadProxy::updateSchedulerStateOnCCThread", this, 0);
    392     ASSERT(isImplThread());
    393     ASSERT(m_layerTreeHostImpl);
    394 
    395     // FIXME: use CCScheduler to decide when to manage the conversion of this
    396     // commit request into an actual createBeginFrameAndCommitTaskOnCCThread call.
    397     m_redrawRequestedOnCCThread |= redrawRequested;
    398     if (!m_beginFrameAndCommitPendingOnCCThread)
    399         CCMainThread::postTask(createBeginFrameAndCommitTaskOnCCThread());
    400 
    401     // If no commit is pending, but a redraw is requested, then post a redraw right away
    402     if (!m_beginFrameAndCommitPendingOnCCThread && m_redrawRequestedOnCCThread)
    403         scheduleDrawTaskOnCCThread();
    404 
    405258}
    406259

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

    r95699 r95702  
    2828#include "cc/CCCompletionEvent.h"
    2929#include "cc/CCLayerTreeHostImpl.h"
    30 #include "cc/CCMainThread.h"
    3130#include "cc/CCProxy.h"
    3231#include <wtf/OwnPtr.h>
    … …  
    6059
    6160    // Called on CCMainThread
    62     void beginFrameAndCommit(int sequenceNumber, double frameBeginTime);
     61    void beginFrameAndCommit(double frameBeginTime);
    6362
    6463    // Called on CCThread
    65     PassOwnPtr<CCMainThread::Task> createBeginFrameAndCommitTaskOnCCThread();
    66     void createBeginFrameAndCommitTaskOnCCThread(CCCompletionEvent*, CCMainThread::Task**);
     64    void beginFrameAndCommitOnCCThread();
    6765    void commitOnCCThread(CCCompletionEvent*);
    68     void drawLayersAndPresentOnCCThread();
    6966    void drawLayersOnCCThread();
    70     void drawLayersAndReadbackOnCCThread(CCCompletionEvent*, bool* success, void* pixels, const IntRect&);
    71     void finishAllRenderingOnCCThread(CCCompletionEvent*);
    7267    void initializeImplOnCCThread(CCCompletionEvent*);
    7368    void initializeLayerRendererOnCCThread(GraphicsContext3D*, CCCompletionEvent*, bool* initializeSucceeded, LayerRendererCapabilities*);
    7469    void setNeedsCommitOnCCThread();
    75     void updateSchedulerStateOnCCThread(bool commitRequested, bool redrawRequested);
     70    void setNeedsCommitAndRedrawOnCCThread();
     71    void setNeedsRedrawOnCCThread();
    7672    void layerTreeHostClosedOnCCThread(CCCompletionEvent*);
    77     void scheduleDrawTaskOnCCThread();
     73
     74    // Used on main-thread only.
     75    bool m_commitPending;
    7876
    7977    // Accessed on main thread only.
    80     bool m_commitRequested;
    8178    CCLayerTreeHost* m_layerTreeHost;
    8279    LayerRendererCapabilities m_layerRendererCapabilitiesMainThreadCopy;
    83     bool m_started;
    84     int m_lastExecutedBeginFrameAndCommitSequenceNumber;
    8580
    86     // Used on the CCThread only
     81    // Used on the CCThread, but checked on main thread during initialization/shutdown.
    8782    OwnPtr<CCLayerTreeHostImpl> m_layerTreeHostImpl;
    88     int m_numBeginFrameAndCommitsIssuedOnCCThread;
    89     bool m_beginFrameAndCommitPendingOnCCThread;
    90     bool m_drawTaskPostedOnCCThread;
    91     bool m_redrawRequestedOnCCThread;
    9283};
    9384

  • trunk/Source/WebKit/chromium/ChangeLog

    r95699 r95702  
     12011-09-22  James Robinson  <jamesr@chromium.org>
     2
     3        Unreviewed, rolling out r95699.
     4        http://trac.webkit.org/changeset/95699
     5        https://bugs.webkit.org/show_bug.cgi?id=67417
     6
     7        Makes many chromium compositor tests crash
     8
     9        * tests/CCLayerTreeHostTest.cpp:
     10        (WTF::CCLayerTreeHostTest::doBeginTest):
     11        (WTF::TEST_F):
     12        * tests/TreeSynchronizerTest.cpp:
     13        (WebCore::TEST):
     14
    1152011-09-22  Nat Duca  <nduca@chromium.org>
    216

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

    r95699 r95702  
    171171    }
    172172
    173 #if !USE(THREADED_COMPOSITING)
    174     virtual void scheduleComposite() { }
    175 #endif
    176 
    177173private:
    178174    explicit MockLayerTreeHostClient(TestHooks* testHooks) : m_testHooks(testHooks) { }
    … …  
    191187// The test continues until someone calls endTest. endTest can be called on any thread, but be aware that
    192188// ending the test is an asynchronous process.
    193 class CCLayerTreeHostTest : public testing::TestWithParam<CCSettings>, TestHooks {
    194 public:
    195     virtual void SetUp()
    196     {
    197     }
     189class CCLayerTreeHostTest : public testing::Test, TestHooks {
     190public:
    198191    virtual void afterTest() = 0;
    199192    virtual void beginTest() = 0;
    … …  
    295288    m_client = MockLayerTreeHostClient::create(this);
    296289
     290    CCSettings settings;
     291    settings.enableCompositorThread = true;
    297292    RefPtr<LayerChromium> rootLayer;
    298     m_layerTreeHost = MockLayerTreeHost::create(this, m_client.get(), rootLayer, GetParam());
     293    m_layerTreeHost = MockLayerTreeHost::create(this, m_client.get(), rootLayer, settings);
    299294    ASSERT(m_layerTreeHost);
    300295
    … …  
    305300        onEndTest(static_cast<void*>(this));
    306301}
    307 INSTANTIATE_TEST_CASE_P(
    308     ProxyTests, CCLayerTreeHostTest,
    309     testing::Values(
    310         CCSettings(false, false, false, false, false),
    311         CCSettings(false, false, true, false, false)));
    312302
    313303void CCLayerTreeHostTest::endTest()
    … …  
    556546TEST_F(CCLayerTreeHostTestSetNeedsRedraw, run)
    557547{
    558     CCSettings setings;
    559548    runTest();
    560549}
    … …  
    562551} // namespace
    563552
    564 #endif
     553#endif // USE(THREADED_COMPOSITING)

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

    r95699 r95702  
    2929#include "LayerChromium.h"
    3030#include "cc/CCLayerImpl.h"
    31 #include "cc/CCProxy.h"
    3231#include <gtest/gtest.h>
    3332
    … …  
    3534
    3635namespace {
    37 
    38 class ScopedSetImplThread {
    39 public:
    40     ScopedSetImplThread()
    41     {
    42 #ifndef NDEBUG
    43         CCProxy::setImplThread(true);
    44 #endif
    45     }
    46     ~ScopedSetImplThread()
    47     {
    48 #ifndef NDEBUG
    49         CCProxy::setImplThread(false);
    50 #endif
    51     }
    52 };
    5336
    5437class MockCCLayerImpl : public CCLayerImpl {
    … …  
    134117TEST(TreeSynchronizerTest, syncSimpleTreeFromEmpty)
    135118{
    136     ScopedSetImplThread impl;
    137119    RefPtr<LayerChromium> layerTreeRoot = LayerChromium::create(0);
    138120    layerTreeRoot->addChild(LayerChromium::create(0));
    … …  
    147129TEST(TreeSynchronizerTest, syncSimpleTreeReusingLayers)
    148130{
    149     ScopedSetImplThread impl;
    150131    Vector<int> ccLayerDestructionList;
    151132
    … …  
    173154TEST(TreeSynchronizerTest, syncSimpleTreeAndProperties)
    174155{
    175     ScopedSetImplThread impl;
    176156    RefPtr<LayerChromium> layerTreeRoot = LayerChromium::create(0);
    177157    layerTreeRoot->addChild(LayerChromium::create(0));
    … …  
    205185TEST(TreeSynchronizerTest, reuseCCLayersAfterStructuralChange)
    206186{
    207     ScopedSetImplThread impl;
    208187    Vector<int> ccLayerDestructionList;
    209188
    … …  
    252231TEST(TreeSynchronizerTest, syncSimpleTreeThenDestroy)
    253232{
    254     ScopedSetImplThread impl;
    255233    Vector<int> ccLayerDestructionList;
    256234
    … …  
    283261TEST(TreeSynchronizerTest, syncMaskReplicaAndReplicaMaskLayers)
    284262{
    285     ScopedSetImplThread impl;
    286263    RefPtr<LayerChromium> layerTreeRoot = LayerChromium::create(0);
    287264    layerTreeRoot->addChild(LayerChromium::create(0));
Note: See TracChangeset for help on using the changeset viewer.