cc: Do not request redraw on commit when impl-side painting

cc/scheduler_unittest.cc

 // 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 "cc/scheduler.h"
 
 #include "base/logging.h"
+#include "cc/layer_tree_settings.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 class FakeSchedulerClient : public SchedulerClient {
 public:
     FakeSchedulerClient() { reset(); }
@@ skipping 44 matching lines @@
     bool m_drawWillHappen;
     bool m_swapWillHappenIfDrawHappens;
     int m_numDraws;
     std::vector<const char*> m_actions;
 };
 
 TEST(SchedulerTest, RequestCommit)
 {
     FakeSchedulerClient client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
-    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)));
+    LayerTreeSettings defaultLayerTreeSettings;
+    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultLayerTreeSettings);
     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();
@@ skipping 13 matching lines @@
     client.reset();
 
     // Timer should be off.
     EXPECT_FALSE(timeSource->active());
 }
 
 TEST(SchedulerTest, RequestCommitAfterBeginFrame)
 {
     FakeSchedulerClient client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
-    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)));
+    LayerTreeSettings defaultLayerTreeSettings;
+    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultLayerTreeSettings);
     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();
 
@@ skipping 13 matching lines @@
     EXPECT_EQ(2, client.numActions());
     EXPECT_STREQ("scheduledActionDrawAndSwapIfPossible", client.action(0));
     EXPECT_STREQ("scheduledActionBeginFrame", client.action(1));
     client.reset();
 }
 
 TEST(SchedulerTest, TextureAcquisitionCollision)
 {
     FakeSchedulerClient client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
-    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)));
+    LayerTreeSettings defaultLayerTreeSettings;
+    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultLayerTreeSettings);
     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();
@@ skipping 18 matching lines @@
     EXPECT_STREQ("scheduledActionDrawAndSwapIfPossible", client.action(0));
     EXPECT_STREQ("scheduledActionAcquireLayerTexturesForMainThread", client.action(1));
     EXPECT_STREQ("scheduledActionBeginFrame", client.action(2));
     client.reset();
 }
 
 TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition)
 {
     FakeSchedulerClient client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
-    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)));
+    LayerTreeSettings defaultLayerTreeSettings;
+    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultLayerTreeSettings);
     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.
@@ skipping 42 matching lines @@
 };
 
 // Tests for two different situations:
 // 1. the scheduler dropping setNeedsRedraw requests that happen inside
 //    a scheduledActionDrawAndSwap
 // 2. the scheduler drawing twice inside a single tick
 TEST(SchedulerTest, RequestRedrawInsideDraw)
 {
     SchedulerClientThatSetNeedsDrawInsideDraw client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
-    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)));
+    LayerTreeSettings defaultLayerTreeSettings;
+    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultLayerTreeSettings);
     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(SchedulerTest, RequestRedrawInsideFailedDraw)
 {
     SchedulerClientThatSetNeedsDrawInsideDraw client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
-    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)));
+    LayerTreeSettings defaultLayerTreeSettings;
+    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultLayerTreeSettings);
     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());
@@ skipping 52 matching lines @@
 protected:
     Scheduler* m_scheduler;
 };
 
 // Tests for the scheduler infinite-looping on setNeedsCommit requests that
 // happen inside a scheduledActionDrawAndSwap
 TEST(SchedulerTest, RequestCommitInsideDraw)
 {
     SchedulerClientThatSetNeedsCommitInsideDraw client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
-    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)));
+    LayerTreeSettings defaultLayerTreeSettings;
+    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultLayerTreeSettings);
     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(SchedulerTest, RequestCommitInsideFailedDraw)
 {
     SchedulerClientThatSetNeedsDrawInsideDraw client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
-    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)));
+    LayerTreeSettings defaultLayerTreeSettings;
+    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultLayerTreeSettings);
     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());
@@ skipping 22 matching lines @@
     EXPECT_FALSE(scheduler->redrawPending());
     EXPECT_FALSE(timeSource->active());
 }
 
 TEST(SchedulerTest, NoBeginFrameWhenDrawFails)
 {
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
     SchedulerClientThatSetNeedsCommitInsideDraw client;
     scoped_ptr<FakeFrameRateController> controller(new FakeFrameRateController(timeSource));
     FakeFrameRateController* controllerPtr = controller.get();
-    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, controller.PassAs<FrameRateController>());
+    LayerTreeSettings defaultLayerTreeSettings;
+    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, controller.PassAs<FrameRateController>(), defaultLayerTreeSettings);
     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());
@@ skipping 16 matching lines @@
     EXPECT_EQ(2, client.numDraws());
     EXPECT_EQ(0, controllerPtr->numFramesPending());
 }
 
 TEST(SchedulerTest, NoBeginFrameWhenSwapFailsDuringForcedCommit)
 {
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
     FakeSchedulerClient client;
     scoped_ptr<FakeFrameRateController> controller(new FakeFrameRateController(timeSource));
     FakeFrameRateController* controllerPtr = controller.get();
-    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, controller.PassAs<FrameRateController>());
+    LayerTreeSettings defaultLayerTreeSettings;
+    scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, controller.PassAs<FrameRateController>(), defaultLayerTreeSettings);
 
     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());
 }
 
 }  // namespace
 }  // namespace cc