Changeset 112446 in webkit


Ignore:
Timestamp:
Mar 28, 2012 2:45:07 PM (12 years ago)
Author:
nduca@chromium.org
Message:

[chromium] Scheduler should not tell FrameRateController to begin a frame when we dont swap
https://bugs.webkit.org/show_bug.cgi?id=82516

Reviewed by James Robinson.

Source/WebCore:

  • platform/graphics/chromium/LayerRendererChromium.cpp:

(WebCore::LayerRendererChromium::swapBuffers):

  • platform/graphics/chromium/LayerRendererChromium.h:

(LayerRendererChromium):

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

(WebCore::CCLayerTreeHostImpl::swapBuffers):

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

(CCLayerTreeHostImpl):

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

(WebCore::CCScheduler::processScheduledActions):

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

(WebCore::CCScheduledActionDrawAndSwapResult::CCScheduledActionDrawAndSwapResult):
(CCScheduledActionDrawAndSwapResult):
(WebCore):
(CCSchedulerClient):

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

(WebCore::CCThreadProxy::scheduledActionDrawAndSwapInternal):
(WebCore::CCThreadProxy::scheduledActionDrawAndSwapIfPossible):
(WebCore::CCThreadProxy::scheduledActionDrawAndSwapForced):

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

(CCThreadProxy):

Source/WebKit/chromium:

  • tests/CCSchedulerTest.cpp:

(WebKitTests::FakeCCSchedulerClient::reset):
(WebKitTests::FakeCCSchedulerClient::hasAction):
(FakeCCSchedulerClient):
(WebKitTests::FakeCCSchedulerClient::scheduledActionDrawAndSwapIfPossible):
(WebKitTests::FakeCCSchedulerClient::scheduledActionDrawAndSwapForced):
(WebKitTests::FakeCCSchedulerClient::setDrawWillHappen):
(WebKitTests::FakeCCSchedulerClient::setSwapWillHappenIfDrawHappens):
(WebKitTests::SchedulerClientThatSetNeedsDrawInsideDraw::scheduledActionDrawAndSwapIfPossible):
(WebKitTests::SchedulerClientThatSetNeedsDrawInsideDraw::scheduledActionDrawAndSwapForced):
(SchedulerClientThatSetNeedsDrawInsideDraw):
(WebKitTests::TEST):
(WebKitTests::SchedulerClientThatSetNeedsCommitInsideDraw::scheduledActionDrawAndSwapIfPossible):
(WebKitTests::SchedulerClientThatSetNeedsCommitInsideDraw::scheduledActionDrawAndSwapForced):
(SchedulerClientThatSetNeedsCommitInsideDraw):
(WebKitTests):

Location:
trunk/Source
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r112445 r112446  
     12012-03-28  Nat Duca  <nduca@chromium.org>
     2
     3        [chromium] Scheduler should not tell FrameRateController to begin a frame when we dont swap
     4        https://bugs.webkit.org/show_bug.cgi?id=82516
     5
     6        Reviewed by James Robinson.
     7
     8        * platform/graphics/chromium/LayerRendererChromium.cpp:
     9        (WebCore::LayerRendererChromium::swapBuffers):
     10        * platform/graphics/chromium/LayerRendererChromium.h:
     11        (LayerRendererChromium):
     12        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
     13        (WebCore::CCLayerTreeHostImpl::swapBuffers):
     14        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:
     15        (CCLayerTreeHostImpl):
     16        * platform/graphics/chromium/cc/CCScheduler.cpp:
     17        (WebCore::CCScheduler::processScheduledActions):
     18        * platform/graphics/chromium/cc/CCScheduler.h:
     19        (WebCore::CCScheduledActionDrawAndSwapResult::CCScheduledActionDrawAndSwapResult):
     20        (CCScheduledActionDrawAndSwapResult):
     21        (WebCore):
     22        (CCSchedulerClient):
     23        * platform/graphics/chromium/cc/CCThreadProxy.cpp:
     24        (WebCore::CCThreadProxy::scheduledActionDrawAndSwapInternal):
     25        (WebCore::CCThreadProxy::scheduledActionDrawAndSwapIfPossible):
     26        (WebCore::CCThreadProxy::scheduledActionDrawAndSwapForced):
     27        * platform/graphics/chromium/cc/CCThreadProxy.h:
     28        (CCThreadProxy):
     29
    1302012-03-26  Eric Uhrhane  <ericu@chromium.org>
    231
  • trunk/Source/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp

    r112286 r112446  
    10741074}
    10751075
    1076 void LayerRendererChromium::swapBuffers(const IntRect& subBuffer)
     1076bool LayerRendererChromium::swapBuffers(const IntRect& subBuffer)
    10771077{
    10781078    // FIXME: Remove this once gpu process supports ignoring swap buffers command while framebuffer is discarded.
     
    10801080    if (m_isFramebufferDiscarded) {
    10811081        m_client->setFullRootLayerDamage();
    1082         return;
     1082        return false;
    10831083    }
    10841084
     
    10991099
    11001100    m_headsUpDisplay->onSwapBuffers();
     1101    return true;
    11011102}
    11021103
  • trunk/Source/WebCore/platform/graphics/chromium/LayerRendererChromium.h

    r112286 r112446  
    109109
    110110    // puts backbuffer onscreen
    111     void swapBuffers(const IntRect& subBuffer);
     111    bool swapBuffers(const IntRect& subBuffer);
    112112
    113113    static void debugGLCall(GraphicsContext3D*, const char* command, const char* file, int line);
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp

    r112439 r112446  
    435435}
    436436
    437 void CCLayerTreeHostImpl::swapBuffers()
     437bool CCLayerTreeHostImpl::swapBuffers()
    438438{
    439439    ASSERT(m_layerRenderer);
    440     m_layerRenderer->swapBuffers(enclosingIntRect(m_rootDamageRect));
     440    return m_layerRenderer->swapBuffers(enclosingIntRect(m_rootDamageRect));
    441441}
    442442
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h

    r111805 r112446  
    115115    TextureAllocator* contentsTextureAllocator() const;
    116116
    117     void swapBuffers();
     117    bool swapBuffers();
    118118
    119119    void readback(void* pixels, const IntRect&);
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCScheduler.cpp

    r111805 r112446  
    164164            break;
    165165        case CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE: {
    166             bool drawSuccess = m_client->scheduledActionDrawAndSwapIfPossible();
    167             m_stateMachine.didDrawIfPossibleCompleted(drawSuccess);
    168             if (drawSuccess)
     166            CCScheduledActionDrawAndSwapResult result = m_client->scheduledActionDrawAndSwapIfPossible();
     167            m_stateMachine.didDrawIfPossibleCompleted(result.didDraw);
     168            if (result.didSwap)
    169169                m_frameRateController->didBeginFrame();
    170170            break;
    171171        }
    172         case CCSchedulerStateMachine::ACTION_DRAW_FORCED:
    173             m_client->scheduledActionDrawAndSwapForced();
    174             m_frameRateController->didBeginFrame();
     172        case CCSchedulerStateMachine::ACTION_DRAW_FORCED: {
     173            CCScheduledActionDrawAndSwapResult result = m_client->scheduledActionDrawAndSwapForced();
     174            if (result.didSwap)
     175                m_frameRateController->didBeginFrame();
    175176            break;
    176         case CCSchedulerStateMachine::ACTION_BEGIN_CONTEXT_RECREATION:
     177        } case CCSchedulerStateMachine::ACTION_BEGIN_CONTEXT_RECREATION:
    177178            m_client->scheduledActionBeginContextRecreation();
    178179            break;
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCScheduler.h

    r111805 r112446  
    3636class CCThread;
    3737
     38struct CCScheduledActionDrawAndSwapResult {
     39    CCScheduledActionDrawAndSwapResult()
     40            : didDraw(false)
     41            , didSwap(false)
     42    {
     43    }
     44    CCScheduledActionDrawAndSwapResult(bool didDraw, bool didSwap)
     45            : didDraw(didDraw)
     46            , didSwap(didSwap)
     47    {
     48    }
     49    bool didDraw;
     50    bool didSwap;
     51};
     52
    3853class CCSchedulerClient {
    3954public:
     
    4257
    4358    virtual void scheduledActionBeginFrame() = 0;
    44     virtual bool scheduledActionDrawAndSwapIfPossible() = 0;
    45     virtual void scheduledActionDrawAndSwapForced() = 0;
     59    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() = 0;
     60    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced() = 0;
    4661    virtual void scheduledActionUpdateMoreResources() = 0;
    4762    virtual void scheduledActionCommit() = 0;
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp

    r112360 r112446  
    562562}
    563563
    564 bool CCThreadProxy::scheduledActionDrawAndSwapInternal(bool forcedDraw)
     564CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapInternal(bool forcedDraw)
    565565{
    566566    TRACE_EVENT("CCThreadProxy::scheduledActionDrawAndSwap", this, 0);
     567    CCScheduledActionDrawAndSwapResult result;
     568    result.didDraw = false;
     569    result.didSwap = false;
    567570    ASSERT(isImplThread());
    568571    ASSERT(m_layerTreeHostImpl);
    569572    if (!m_layerTreeHostImpl)
    570         return false;
     573        return result;
    571574
    572575    // FIXME: compute the frame display time more intelligently
     
    578581    CCLayerTreeHostImpl::FrameData frame;
    579582    bool drawFrame = m_layerTreeHostImpl->prepareToDraw(frame) || forcedDraw;
    580     if (drawFrame)
     583    if (drawFrame) {
    581584        m_layerTreeHostImpl->drawLayers(frame);
     585        result.didDraw = true;
     586    }
    582587
    583588    // Check for a pending compositeAndReadback.
     
    591596
    592597    if (drawFrame)
    593         m_layerTreeHostImpl->swapBuffers();
     598        result.didSwap = m_layerTreeHostImpl->swapBuffers();
    594599
    595600    // Process any finish request
     
    608613
    609614    ASSERT(drawFrame || (!drawFrame && !forcedDraw));
    610     return drawFrame;
    611 }
    612 
    613 bool CCThreadProxy::scheduledActionDrawAndSwapIfPossible()
     615    return result;
     616}
     617
     618CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapIfPossible()
    614619{
    615620    return scheduledActionDrawAndSwapInternal(false);
    616621}
    617622
    618 void CCThreadProxy::scheduledActionDrawAndSwapForced()
    619 {
    620     scheduledActionDrawAndSwapInternal(true);
     623CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapForced()
     624{
     625    return scheduledActionDrawAndSwapInternal(true);
    621626}
    622627
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.h

    r112360 r112446  
    8383    virtual bool hasMoreResourceUpdates() const;
    8484    virtual void scheduledActionBeginFrame();
    85     virtual bool scheduledActionDrawAndSwapIfPossible();
    86     virtual void scheduledActionDrawAndSwapForced();
     85    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible();
     86    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced();
    8787    virtual void scheduledActionUpdateMoreResources();
    8888    virtual void scheduledActionCommit();
     
    128128    void setFullRootLayerDamageOnImplThread();
    129129    void recreateContextOnImplThread(CCCompletionEvent*, GraphicsContext3D*, bool* recreateSucceeded, LayerRendererCapabilities*);
    130     bool scheduledActionDrawAndSwapInternal(bool forcedDraw);
     130    CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapInternal(bool forcedDraw);
    131131
    132132    // Accessed on main thread only.
  • trunk/Source/WebKit/chromium/ChangeLog

    r112436 r112446  
     12012-03-28  Nat Duca  <nduca@chromium.org>
     2
     3        [chromium] Scheduler should not tell FrameRateController to begin a frame when we dont swap
     4        https://bugs.webkit.org/show_bug.cgi?id=82516
     5
     6        Reviewed by James Robinson.
     7
     8        * tests/CCSchedulerTest.cpp:
     9        (WebKitTests::FakeCCSchedulerClient::reset):
     10        (WebKitTests::FakeCCSchedulerClient::hasAction):
     11        (FakeCCSchedulerClient):
     12        (WebKitTests::FakeCCSchedulerClient::scheduledActionDrawAndSwapIfPossible):
     13        (WebKitTests::FakeCCSchedulerClient::scheduledActionDrawAndSwapForced):
     14        (WebKitTests::FakeCCSchedulerClient::setDrawWillHappen):
     15        (WebKitTests::FakeCCSchedulerClient::setSwapWillHappenIfDrawHappens):
     16        (WebKitTests::SchedulerClientThatSetNeedsDrawInsideDraw::scheduledActionDrawAndSwapIfPossible):
     17        (WebKitTests::SchedulerClientThatSetNeedsDrawInsideDraw::scheduledActionDrawAndSwapForced):
     18        (SchedulerClientThatSetNeedsDrawInsideDraw):
     19        (WebKitTests::TEST):
     20        (WebKitTests::SchedulerClientThatSetNeedsCommitInsideDraw::scheduledActionDrawAndSwapIfPossible):
     21        (WebKitTests::SchedulerClientThatSetNeedsCommitInsideDraw::scheduledActionDrawAndSwapForced):
     22        (SchedulerClientThatSetNeedsCommitInsideDraw):
     23        (WebKitTests):
     24
    1252012-03-26  Shawn Singh  <shawnsingh@chromium.org>
    226
  • trunk/Source/WebKit/chromium/tests/CCSchedulerTest.cpp

    r111805 r112446  
    4646        m_hasMoreResourceUpdates = false;
    4747        m_canDraw = true;
    48         m_drawSuccess = true;
     48        m_drawWillHappen = true;
     49        m_swapWillHappenIfDrawHappens = true;
    4950        m_numDraws = 0;
    5051    }
     
    5758    const char* action(int i) const { return m_actions[i]; }
    5859
     60    bool hasAction(const char* action) const
     61    {
     62        for (size_t i = 0; i < m_actions.size(); i++)
     63            if (!strcmp(m_actions[i], action))
     64                return true;
     65        return false;
     66    }
     67
    5968    virtual bool canDraw() { return m_canDraw; }
    6069    virtual bool hasMoreResourceUpdates() const { return m_hasMoreResourceUpdates; }
    6170    virtual void scheduledActionBeginFrame() { m_actions.push_back("scheduledActionBeginFrame"); }
    62     virtual bool scheduledActionDrawAndSwapIfPossible()
     71    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible()
    6372    {
    6473        m_actions.push_back("scheduledActionDrawAndSwapIfPossible");
    6574        m_numDraws++;
    66         return m_drawSuccess;
    67     }
    68 
    69     virtual void scheduledActionDrawAndSwapForced()
     75        return CCScheduledActionDrawAndSwapResult(m_drawWillHappen, m_drawWillHappen && m_swapWillHappenIfDrawHappens);
     76    }
     77
     78    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced()
    7079    {
    7180        m_actions.push_back("scheduledActionDrawAndSwapForced");
    72         m_numDraws++;
     81        return CCScheduledActionDrawAndSwapResult(true, m_swapWillHappenIfDrawHappens);
    7382    }
    7483
     
    7786    virtual void scheduledActionBeginContextRecreation() { m_actions.push_back("scheduledActionBeginContextRecreation"); }
    7887
    79     void setDrawSuccess(bool drawSuccess) { m_drawSuccess = drawSuccess; }
     88    void setDrawWillHappen(bool drawWillHappen) { m_drawWillHappen = drawWillHappen; }
     89    void setSwapWillHappenIfDrawHappens(bool swapWillHappenIfDrawHappens) { m_swapWillHappenIfDrawHappens = swapWillHappenIfDrawHappens; }
    8090
    8191protected:
    8292    bool m_hasMoreResourceUpdates;
    8393    bool m_canDraw;
    84     bool m_drawSuccess;
     94    bool m_drawWillHappen;
     95    bool m_swapWillHappenIfDrawHappens;
    8596    int m_numDraws;
    8697    std::vector<const char*> m_actions;
     
    164175
    165176    virtual void scheduledActionBeginFrame() { }
    166     virtual bool scheduledActionDrawAndSwapIfPossible()
     177    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible()
    167178    {
    168179        // Only setNeedsRedraw the first time this is called
     
    172183    }
    173184
    174     virtual void scheduledActionDrawAndSwapForced() { }
     185    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced()
     186    {
     187        ASSERT_NOT_REACHED();
     188        return CCScheduledActionDrawAndSwapResult(true, true);
     189    }
     190
    175191    virtual void scheduledActionUpdateMoreResources() { }
    176192    virtual void scheduledActionCommit() { }
     
    217233    client.setScheduler(scheduler.get());
    218234    scheduler->setVisible(true);
    219     client.setDrawSuccess(false);
     235    client.setDrawWillHappen(false);
    220236
    221237    scheduler->setNeedsRedraw();
     
    241257
    242258    // Draw successfully.
    243     client.setDrawSuccess(true);
     259    client.setDrawWillHappen(true);
    244260    timeSource->tick();
    245261    EXPECT_EQ(3, client.numDraws());
     
    257273
    258274    virtual void scheduledActionBeginFrame() { }
    259     virtual bool scheduledActionDrawAndSwapIfPossible()
     275    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible()
    260276    {
    261277        // Only setNeedsCommit the first time this is called
     
    265281    }
    266282
    267     virtual void scheduledActionDrawAndSwapForced() { }
     283    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced()
     284    {
     285        ASSERT_NOT_REACHED();
     286        return CCScheduledActionDrawAndSwapResult(true, true);
     287    }
     288
    268289    virtual void scheduledActionUpdateMoreResources() { }
    269290    virtual void scheduledActionCommit() { }
     
    309330    client.setScheduler(scheduler.get());
    310331    scheduler->setVisible(true);
    311     client.setDrawSuccess(false);
     332    client.setDrawWillHappen(false);
    312333
    313334    scheduler->setNeedsRedraw();
     
    333354
    334355    // Draw successfully.
    335     client.setDrawSuccess(true);
     356    client.setDrawWillHappen(true);
    336357    timeSource->tick();
    337358    EXPECT_EQ(3, client.numDraws());
     
    381402
    382403    // Fail to draw, this should not start a frame.
    383     client.setDrawSuccess(false);
     404    client.setDrawWillHappen(false);
    384405    timeSource->tick();
    385406    EXPECT_EQ(3, client.numDraws());
     
    387408}
    388409
    389 }
     410TEST(CCSchedulerTest, NoBeginFrameWhenSwapFailsDuringForcedCommit)
     411{
     412    RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
     413    FakeCCSchedulerClient client;
     414    OwnPtr<FakeCCFrameRateController> controller = adoptPtr(new FakeCCFrameRateController(timeSource));
     415    FakeCCFrameRateController* controllerPtr = controller.get();
     416    OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, controller.release());
     417
     418    EXPECT_EQ(0, controllerPtr->numFramesPending());
     419
     420    // Tell the client that it will fail to swap.
     421    client.setDrawWillHappen(true);
     422    client.setSwapWillHappenIfDrawHappens(false);
     423
     424    // Get the compositor to do a scheduledActionDrawAndSwapForced.
     425    scheduler->setNeedsRedraw();
     426    scheduler->setNeedsForcedRedraw();
     427    EXPECT_TRUE(client.hasAction("scheduledActionDrawAndSwapForced"));
     428
     429    // We should not have told the frame rate controller that we began a frame.
     430    EXPECT_EQ(0, controllerPtr->numFramesPending());
     431}
     432
     433}
Note: See TracChangeset for help on using the changeset viewer.