Roll cc snapshot up to 127605

cc/CCSchedulerTest.cpp

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "CCScheduler.h"
 
 #include "CCSchedulerTestCommon.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <wtf/OwnPtr.h>
 
 using namespace WTF;
 using namespace WebCore;
 using namespace WebKitTests;
 
 namespace {
 
 class FakeCCSchedulerClient : public CCSchedulerClient {
 public:
     FakeCCSchedulerClient() { reset(); }
     void reset()
     {
         m_actions.clear();
         m_hasMoreResourceUpdates = false;
-        m_canDraw = 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() OVERRIDE { return m_canDraw; }
     virtual bool hasMoreResourceUpdates() const OVERRIDE { return m_hasMoreResourceUpdates; }
+
     virtual void scheduledActionBeginFrame() OVERRIDE { m_actions.push_back("scheduledActionBeginFrame"); }
     virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() OVERRIDE
     {
         m_actions.push_back("scheduledActionDrawAndSwapIfPossible");
         m_numDraws++;
         return CCScheduledActionDrawAndSwapResult(m_drawWillHappen, m_drawWillHappen && m_swapWillHappenIfDrawHappens);
     }
 
     virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced() OVERRIDE
     {
         m_actions.push_back("scheduledActionDrawAndSwapForced");
         return CCScheduledActionDrawAndSwapResult(true, m_swapWillHappenIfDrawHappens);
     }
 
     virtual void scheduledActionUpdateMoreResources(double) OVERRIDE { m_actions.push_back("scheduledActionUpdateMoreResources"); }
     virtual void scheduledActionCommit() OVERRIDE { m_actions.push_back("scheduledActionCommit"); }
     virtual void scheduledActionBeginContextRecreation() OVERRIDE { m_actions.push_back("scheduledActionBeginContextRecreation"); }
     virtual void scheduledActionAcquireLayerTexturesForMainThread() OVERRIDE { m_actions.push_back("scheduledActionAcquireLayerTexturesForMainThread"); }
 
     void setDrawWillHappen(bool drawWillHappen) { m_drawWillHappen = drawWillHappen; }
     void setSwapWillHappenIfDrawHappens(bool swapWillHappenIfDrawHappens) { m_swapWillHappenIfDrawHappens = swapWillHappenIfDrawHappens; }
 
 protected:
     bool m_hasMoreResourceUpdates;
-    bool m_canDraw;
     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->setCanBeginFrame(true);
     scheduler->setVisible(true);
+    scheduler->setCanDraw(true);
 
     // SetNeedsCommit should begin the frame.
     scheduler->setNeedsCommit();
     EXPECT_EQ(1, client.numActions());
     EXPECT_STREQ("scheduledActionBeginFrame", client.action(0));
     EXPECT_FALSE(timeSource->active());
     client.reset();
 
     // Since, hasMoreResourceUpdates is set to false,
     // beginFrameComplete should commit
@@ skipping 14 matching lines @@
     EXPECT_FALSE(timeSource->active());
 }
 
 TEST(CCSchedulerTest, RequestCommitAfterBeginFrame)
 {
     FakeCCSchedulerClient client;
     RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
     OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, adoptPtr(new CCFrameRateController(timeSource)));
     scheduler->setCanBeginFrame(true);
     scheduler->setVisible(true);
+    scheduler->setCanDraw(true);
 
     // SetNedsCommit should begin the frame.
     scheduler->setNeedsCommit();
     EXPECT_EQ(1, client.numActions());
     EXPECT_STREQ("scheduledActionBeginFrame", client.action(0));
     client.reset();
 
     // Now setNeedsCommit again. Calling here means we need a second frame.
     scheduler->setNeedsCommit();
 
@@ skipping 13 matching lines @@
     client.reset();
 }
 
 TEST(CCSchedulerTest, TextureAcquisitionCollision)
 {
     FakeCCSchedulerClient client;
     RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
     OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, adoptPtr(new CCFrameRateController(timeSource)));
     scheduler->setCanBeginFrame(true);
     scheduler->setVisible(true);
+    scheduler->setCanDraw(true);
 
     scheduler->setNeedsCommit();
     scheduler->setMainThreadNeedsLayerTextures();
     EXPECT_EQ(2, client.numActions());
     EXPECT_STREQ("scheduledActionBeginFrame", client.action(0));
     EXPECT_STREQ("scheduledActionAcquireLayerTexturesForMainThread", client.action(1));
     client.reset();
 
     // Compositor not scheduled to draw because textures are locked by main thread
     EXPECT_FALSE(timeSource->active());
@@ skipping 18 matching lines @@
     client.reset();
 }
 
 TEST(CCSchedulerTest, VisibilitySwitchWithTextureAcquisition)
 {
     FakeCCSchedulerClient client;
     RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
     OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, adoptPtr(new CCFrameRateController(timeSource)));
     scheduler->setCanBeginFrame(true);
     scheduler->setVisible(true);
+    scheduler->setCanDraw(true);
 
     scheduler->setNeedsCommit();
     scheduler->beginFrameComplete();
     scheduler->setMainThreadNeedsLayerTextures();
     client.reset();
     // Verify that pending texture acquisition fires when visibility
     // is lost in order to avoid a deadlock.
     scheduler->setVisible(false);
     EXPECT_EQ(1, client.numActions());
     EXPECT_STREQ("scheduledActionAcquireLayerTexturesForMainThread", client.action(0));
@@ skipping 43 matching lines @@
 //    a scheduledActionDrawAndSwap
 // 2. the scheduler drawing twice inside a single tick
 TEST(CCSchedulerTest, RequestRedrawInsideDraw)
 {
     SchedulerClientThatSetNeedsDrawInsideDraw client;
     RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
     OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, adoptPtr(new CCFrameRateController(timeSource)));
     client.setScheduler(scheduler.get());
     scheduler->setCanBeginFrame(true);
     scheduler->setVisible(true);
+    scheduler->setCanDraw(true);
 
     scheduler->setNeedsRedraw();
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_TRUE(timeSource->active());
     EXPECT_EQ(0, client.numDraws());
 
     timeSource->tick();
     EXPECT_EQ(1, client.numDraws());
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_TRUE(timeSource->active());
 
     timeSource->tick();
     EXPECT_EQ(2, client.numDraws());
     EXPECT_FALSE(scheduler->redrawPending());
     EXPECT_FALSE(timeSource->active());
 }
 
 // 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->setCanBeginFrame(true);
     scheduler->setVisible(true);
+    scheduler->setCanDraw(true);
     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());
@@ skipping 52 matching lines @@
 // Tests for the scheduler infinite-looping on setNeedsCommit requests that
 // happen inside a scheduledActionDrawAndSwap
 TEST(CCSchedulerTest, RequestCommitInsideDraw)
 {
     SchedulerClientThatSetNeedsCommitInsideDraw client;
     RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
     OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, adoptPtr(new CCFrameRateController(timeSource)));
     client.setScheduler(scheduler.get());
     scheduler->setCanBeginFrame(true);
     scheduler->setVisible(true);
+    scheduler->setCanDraw(true);
 
     scheduler->setNeedsRedraw();
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_EQ(0, client.numDraws());
     EXPECT_TRUE(timeSource->active());
 
     timeSource->tick();
     EXPECT_FALSE(timeSource->active());
     EXPECT_EQ(1, client.numDraws());
     EXPECT_TRUE(scheduler->commitPending());
     scheduler->beginFrameComplete();
 
     timeSource->tick();
     EXPECT_EQ(2, client.numDraws());
     EXPECT_FALSE(timeSource->active());
     EXPECT_FALSE(scheduler->redrawPending());
 }
 
 // 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->setCanBeginFrame(true);
     scheduler->setVisible(true);
+    scheduler->setCanDraw(true);
     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());
@@ skipping 22 matching lines @@
 TEST(CCSchedulerTest, NoBeginFrameWhenDrawFails)
 {
     RefPtr<FakeCCTimeSource> timeSource = adoptRef(new FakeCCTimeSource());
     SchedulerClientThatSetNeedsCommitInsideDraw client;
     OwnPtr<FakeCCFrameRateController> controller = adoptPtr(new FakeCCFrameRateController(timeSource));
     FakeCCFrameRateController* controllerPtr = controller.get();
     OwnPtr<CCScheduler> scheduler = CCScheduler::create(&client, controller.release());
     client.setScheduler(scheduler.get());
     scheduler->setCanBeginFrame(true);
     scheduler->setVisible(true);
+    scheduler->setCanDraw(true);
 
     EXPECT_EQ(0, controllerPtr->numFramesPending());
 
     scheduler->setNeedsRedraw();
     EXPECT_TRUE(scheduler->redrawPending());
     EXPECT_TRUE(timeSource->active());
     EXPECT_EQ(0, client.numDraws());
 
     // Draw successfully, this starts a new frame.
     timeSource->tick();
@@ skipping 30 matching lines @@
     // 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());
 }
 
 }