cc: Chromify Layer and LayerImpl classes.

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/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 188 matching lines @@
 
     // Regaining visibility with textures acquired by main thread while
     // compositor is waiting for first draw should result in a request
     // for a new frame in order to escape a deadlock.
     scheduler->setVisible(true);
     EXPECT_EQ(1, client.numActions());
     EXPECT_STREQ("scheduledActionBeginFrame", client.action(0));
     client.reset();
 }
 
-class SchedulerClientThatSetNeedsDrawInsideDraw : public FakeSchedulerClient {
+class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
 public:
-    SchedulerClientThatSetNeedsDrawInsideDraw()
+    SchedulerClientThatsetNeedsDrawInsideDraw()
         : m_scheduler(0) { }
 
     void setScheduler(Scheduler* scheduler) { m_scheduler = scheduler; }
 
     virtual void scheduledActionBeginFrame() OVERRIDE { }
     virtual ScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() OVERRIDE
     {
         // Only setNeedsRedraw the first time this is called
         if (!m_numDraws)
             m_scheduler->setNeedsRedraw();
@@ skipping 13 matching lines @@
 protected:
     Scheduler* m_scheduler;
 };
 
 // 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;
+    SchedulerClientThatsetNeedsDrawInsideDraw client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
     SchedulerSettings defaultSchedulerSettings;
     scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultSchedulerSettings);
     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;
+    SchedulerClientThatsetNeedsDrawInsideDraw client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
     SchedulerSettings defaultSchedulerSettings;
     scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultSchedulerSettings);
     client.setScheduler(scheduler.get());
     scheduler->setCanBeginFrame(true);
     scheduler->setVisible(true);
     scheduler->setCanDraw(true);
     client.setDrawWillHappen(false);
 
     scheduler->setNeedsRedraw();
@@ skipping 19 matching lines @@
 
     // Draw successfully.
     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 FakeSchedulerClient {
+class SchedulerClientThatsetNeedsCommitInsideDraw : public FakeSchedulerClient {
 public:
-    SchedulerClientThatSetNeedsCommitInsideDraw()
+    SchedulerClientThatsetNeedsCommitInsideDraw()
         : m_scheduler(0) { }
 
     void setScheduler(Scheduler* scheduler) { m_scheduler = scheduler; }
 
     virtual void scheduledActionBeginFrame() OVERRIDE { }
     virtual ScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() OVERRIDE
     {
         // Only setNeedsCommit the first time this is called
         if (!m_numDraws)
             m_scheduler->setNeedsCommit();
@@ skipping 11 matching lines @@
     virtual void didAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE { }
 
 protected:
     Scheduler* m_scheduler;
 };
 
 // Tests for the scheduler infinite-looping on setNeedsCommit requests that
 // happen inside a scheduledActionDrawAndSwap
 TEST(SchedulerTest, RequestCommitInsideDraw)
 {
-    SchedulerClientThatSetNeedsCommitInsideDraw client;
+    SchedulerClientThatsetNeedsCommitInsideDraw client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
     SchedulerSettings defaultSchedulerSettings;
     scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultSchedulerSettings);
     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;
+    SchedulerClientThatsetNeedsDrawInsideDraw client;
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
     SchedulerSettings defaultSchedulerSettings;
     scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, make_scoped_ptr(new FrameRateController(timeSource)), defaultSchedulerSettings);
     client.setScheduler(scheduler.get());
     scheduler->setCanBeginFrame(true);
     scheduler->setVisible(true);
     scheduler->setCanDraw(true);
     client.setDrawWillHappen(false);
 
     scheduler->setNeedsRedraw();
@@ skipping 22 matching lines @@
     timeSource->tick();
     EXPECT_EQ(3, client.numDraws());
     EXPECT_TRUE(scheduler->commitPending());
     EXPECT_FALSE(scheduler->redrawPending());
     EXPECT_FALSE(timeSource->active());
 }
 
 TEST(SchedulerTest, NoBeginFrameWhenDrawFails)
 {
     scoped_refptr<FakeTimeSource> timeSource(new FakeTimeSource());
-    SchedulerClientThatSetNeedsCommitInsideDraw client;
+    SchedulerClientThatsetNeedsCommitInsideDraw client;
     scoped_ptr<FakeFrameRateController> controller(new FakeFrameRateController(timeSource));
     FakeFrameRateController* controllerPtr = controller.get();
     SchedulerSettings defaultSchedulerSettings;
     scoped_ptr<Scheduler> scheduler = Scheduler::create(&client, controller.PassAs<FrameRateController>(), defaultSchedulerSettings);
     client.setScheduler(scheduler.get());
     scheduler->setCanBeginFrame(true);
     scheduler->setVisible(true);
     scheduler->setCanDraw(true);
 
     EXPECT_EQ(0, controllerPtr->numFramesPending());
@@ skipping 40 matching lines @@
     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