Merge 112446 - [chromium] Scheduler should not tell FrameRateController to begin a frame when we do…

Source/WebKit/chromium/tests/CCSchedulerTest.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 27 matching lines @@
 namespace {
 
 class FakeCCSchedulerClient : public CCSchedulerClient {
 public:
     FakeCCSchedulerClient() { reset(); }
     void reset()
     {
         m_actions.clear();
         m_hasMoreResourceUpdates = false;
         m_canDraw = true;
-        m_drawSuccess = true;
+        m_drawWillHappen = true;
+        m_swapWillHappenIfDrawHappens = true;
         m_numDraws = 0;
     }
 
     void setHasMoreResourceUpdates(bool b) { m_hasMoreResourceUpdates = b; }
     void setCanDraw(bool b) { m_canDraw = b; }
 
     int numDraws() const { return m_numDraws; }
     int numActions() const { return static_cast<int>(m_actions.size()); }
     const char* action(int i) const { return m_actions[i]; }
 
+    bool hasAction(const char* action) const
+    {
+        for (size_t i = 0; i < m_actions.size(); i++)
+            if (!strcmp(m_actions[i], action))
+                return true;
+        return false;
+    }
+
     virtual bool canDraw() { return m_canDraw; }
     virtual bool hasMoreResourceUpdates() const { return m_hasMoreResourceUpdates; }
     virtual void scheduledActionBeginFrame() { m_actions.push_back("scheduledActionBeginFrame"); }
-    virtual bool scheduledActionDrawAndSwapIfPossible()
+    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible()
     {
         m_actions.push_back("scheduledActionDrawAndSwapIfPossible");
         m_numDraws++;
-        return m_drawSuccess;
+        return CCScheduledActionDrawAndSwapResult(m_drawWillHappen, m_drawWillHappen && m_swapWillHappenIfDrawHappens);
     }
 
-    virtual void scheduledActionDrawAndSwapForced()
+    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced()
     {
         m_actions.push_back("scheduledActionDrawAndSwapForced");
-        m_numDraws++;
+        return CCScheduledActionDrawAndSwapResult(true, m_swapWillHappenIfDrawHappens);
     }
 
     virtual void scheduledActionUpdateMoreResources() { m_actions.push_back("scheduledActionUpdateMoreResources"); }
     virtual void scheduledActionCommit() { m_actions.push_back("scheduledActionCommit"); }
     virtual void scheduledActionBeginContextRecreation() { m_actions.push_back("scheduledActionBeginContextRecreation"); }
 
-    void setDrawSuccess(bool drawSuccess) { m_drawSuccess = drawSuccess; }
+    void setDrawWillHappen(bool drawWillHappen) { m_drawWillHappen = drawWillHappen; }
+    void setSwapWillHappenIfDrawHappens(bool swapWillHappenIfDrawHappens) { m_swapWillHappenIfDrawHappens = swapWillHappenIfDrawHappens; }
 
 protected:
     bool m_hasMoreResourceUpdates;
     bool m_canDraw;
-    bool m_drawSuccess;
+    bool m_drawWillHappen;
+    bool m_swapWillHappenIfDrawHappens;
     int m_numDraws;
     std::vector<const char*> m_actions;
 };
 
 TEST(CCSchedulerTest, RequestCommit)
 {
     FakeCCSchedulerClient client;
     RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
     OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, adoptPtr(new CCFrameRateController(timeSource)));
     scheduler->setVisible(true);
@@ skipping 61 matching lines @@
 }
 
 class SchedulerClientThatSetNeedsDrawInsideDraw : public FakeCCSchedulerClient {
 public:
     SchedulerClientThatSetNeedsDrawInsideDraw()
         : m_scheduler(0) { }
 
     void setScheduler(CCScheduler* scheduler) { m_scheduler = scheduler; }
 
     virtual void scheduledActionBeginFrame() { }
-    virtual bool scheduledActionDrawAndSwapIfPossible()
+    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible()
     {
         // Only setNeedsRedraw the first time this is called
         if (!m_numDraws)
             m_scheduler->setNeedsRedraw();
         return FakeCCSchedulerClient::scheduledActionDrawAndSwapIfPossible();
     }
 
-    virtual void scheduledActionDrawAndSwapForced() { }
+    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced()
+    {
+        ASSERT_NOT_REACHED();
+        return CCScheduledActionDrawAndSwapResult(true, true);
+    }
+
     virtual void scheduledActionUpdateMoreResources() { }
     virtual void scheduledActionCommit() { }
     virtual void scheduledActionBeginContextRecreation() { }
 
 protected:
     CCScheduler* m_scheduler;
 };
 
 // Tests for two different situations:
 // 1. the scheduler dropping setNeedsRedraw requests that happen inside
@@ skipping 24 matching lines @@
 }
 
 // Test that requesting redraw inside a failed draw doesn't lose the request.
 TEST(CCSchedulerTest, RequestRedrawInsideFailedDraw)
 {
     SchedulerClientThatSetNeedsDrawInsideDraw client;
     RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
     OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, adoptPtr(new CCFrameRateController(timeSource)));
     client.setScheduler(scheduler.get());
     scheduler->setVisible(true);
-    client.setDrawSuccess(false);
+    client.setDrawWillHappen(false);
 
     scheduler->setNeedsRedraw();
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_TRUE(timeSource->active());
     EXPECT_EQ(0, client.numDraws());
 
     // Fail the draw.
     timeSource->tick();
     EXPECT_EQ(1, client.numDraws());
 
     // We have a commit pending and the draw failed, and we didn't lose the redraw request.
     EXPECT_TRUE(scheduler->commitPending());
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_TRUE(timeSource->active());
 
     // Fail the draw again.
     timeSource->tick();
     EXPECT_EQ(2, client.numDraws());
     EXPECT_TRUE(scheduler->commitPending());
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_TRUE(timeSource->active());
 
     // Draw successfully.
-    client.setDrawSuccess(true);
+    client.setDrawWillHappen(true);
     timeSource->tick();
     EXPECT_EQ(3, client.numDraws());
     EXPECT_TRUE(scheduler->commitPending());
     EXPECT_FALSE(scheduler->redrawPending());
     EXPECT_FALSE(timeSource->active());
 }
 
 class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeCCSchedulerClient {
 public:
     SchedulerClientThatSetNeedsCommitInsideDraw()
         : m_scheduler(0) { }
 
     void setScheduler(CCScheduler* scheduler) { m_scheduler = scheduler; }
 
     virtual void scheduledActionBeginFrame() { }
-    virtual bool scheduledActionDrawAndSwapIfPossible()
+    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible()
     {
         // Only setNeedsCommit the first time this is called
         if (!m_numDraws)
             m_scheduler->setNeedsCommit();
         return FakeCCSchedulerClient::scheduledActionDrawAndSwapIfPossible();
     }
 
-    virtual void scheduledActionDrawAndSwapForced() { }
+    virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced()
+    {
+        ASSERT_NOT_REACHED();
+        return CCScheduledActionDrawAndSwapResult(true, true);
+    }
+
     virtual void scheduledActionUpdateMoreResources() { }
     virtual void scheduledActionCommit() { }
     virtual void scheduledActionBeginContextRecreation() { }
 
 protected:
     CCScheduler* m_scheduler;
 };
 
 // Tests for the scheduler infinite-looping on setNeedsCommit requests that
 // happen inside a scheduledActionDrawAndSwap
@@ skipping 23 matching lines @@
 }
 
 // Tests that when a draw fails then the pending commit should not be dropped.
 TEST(CCSchedulerTest, RequestCommitInsideFailedDraw)
 {
     SchedulerClientThatSetNeedsDrawInsideDraw client;
     RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
     OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, adoptPtr(new CCFrameRateController(timeSource)));
     client.setScheduler(scheduler.get());
     scheduler->setVisible(true);
-    client.setDrawSuccess(false);
+    client.setDrawWillHappen(false);
 
     scheduler->setNeedsRedraw();
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_TRUE(timeSource->active());
     EXPECT_EQ(0, client.numDraws());
 
     // Fail the draw.
     timeSource->tick();
     EXPECT_EQ(1, client.numDraws());
 
     // We have a commit pending and the draw failed, and we didn't lose the commit request.
     EXPECT_TRUE(scheduler->commitPending());
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_TRUE(timeSource->active());
 
     // Fail the draw again.
     timeSource->tick();
     EXPECT_EQ(2, client.numDraws());
     EXPECT_TRUE(scheduler->commitPending());
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_TRUE(timeSource->active());
 
     // Draw successfully.
-    client.setDrawSuccess(true);
+    client.setDrawWillHappen(true);
     timeSource->tick();
     EXPECT_EQ(3, client.numDraws());
     EXPECT_TRUE(scheduler->commitPending());
     EXPECT_FALSE(scheduler->redrawPending());
     EXPECT_FALSE(timeSource->active());
 }
 
 TEST(CCSchedulerTest, NoBeginFrameWhenDrawFails)
 {
     RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
@@ skipping 27 matching lines @@
     EXPECT_EQ(2, client.numDraws());
     EXPECT_EQ(1, controllerPtr->numFramesPending());
     scheduler->didSwapBuffersComplete();
     EXPECT_EQ(0, controllerPtr->numFramesPending());
 
     scheduler->setNeedsRedraw();
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_TRUE(timeSource->active());
 
     // Fail to draw, this should not start a frame.
-    client.setDrawSuccess(false);
+    client.setDrawWillHappen(false);
     timeSource->tick();
     EXPECT_EQ(3, client.numDraws());
     EXPECT_EQ(0, controllerPtr->numFramesPending());
 }
 
+TEST(CCSchedulerTest, NoBeginFrameWhenSwapFailsDuringForcedCommit)
+{
+    RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
+    FakeCCSchedulerClient client;
+    OwnPtr<FakeCCFrameRateController> controller = adoptPtr(new FakeCCFrameRateController(timeSource));
+    FakeCCFrameRateController* controllerPtr = controller.get();
+    OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, controller.release());
+
+    EXPECT_EQ(0, controllerPtr->numFramesPending());
+
+    // Tell the client that it will fail to swap.
+    client.setDrawWillHappen(true);
+    client.setSwapWillHappenIfDrawHappens(false);
+
+    // Get the compositor to do a scheduledActionDrawAndSwapForced.
+    scheduler->setNeedsRedraw();
+    scheduler->setNeedsForcedRedraw();
+    EXPECT_TRUE(client.hasAction("scheduledActionDrawAndSwapForced"));
+
+    // We should not have told the frame rate controller that we began a frame.
+    EXPECT_EQ(0, controllerPtr->numFramesPending());
 }
+
+}