cc/frame_rate_controller_unittest.cc

   1 // Copyright 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/frame_rate_controller.h"
   6
   7 #include "cc/test/scheduler_test_common.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace cc {
  11 namespace {
  12
  13 class FakeFrameRateControllerClient : public cc::FrameRateControllerClient {
  14 public:
  15     FakeFrameRateControllerClient() { reset(); }
  16
  17     void reset() { m_vsyncTicked = false; }
  18     bool vsyncTicked() const { return m_vsyncTicked; }
  19
  20     virtual void vsyncTick(bool throttled) { m_vsyncTicked = !throttled; }
  21
  22 protected:
  23     bool m_vsyncTicked;
  24 };
  25
  26
  27 TEST(FrameRateControllerTest, TestFrameThrottling_ImmediateAck)
  28 {
  29     FakeThread thread;
  30     FakeFrameRateControllerClient client;
  31     base::TimeDelta interval = base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond / 60);
  32     scoped_refptr<FakeDelayBasedTimeSource> timeSource = FakeDelayBasedTimeSource::create(interval, &thread);
  33     FrameRateController controller(timeSource);
  34
  35     controller.setClient(&client);
  36     controller.setActive(true);
  37
  38     base::TimeTicks elapsed; // Muck around with time a bit
  39
  40     // Trigger one frame, make sure the vsync callback is called
  41     elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
  42     timeSource->setNow(elapsed);
  43     thread.runPendingTask();
  44     EXPECT_TRUE(client.vsyncTicked());
  45     client.reset();
  46
  47     // Tell the controller we drew
  48     controller.didBeginFrame();
  49
  50     // Tell the controller the frame ended 5ms later
  51     timeSource->setNow(timeSource->now() + base::TimeDelta::FromMilliseconds(5));
  52     controller.didFinishFrame();
  53
  54     // Trigger another frame, make sure vsync runs again
  55     elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
  56     EXPECT_TRUE(elapsed >= timeSource->now()); // Sanity check that previous code didn't move time backward.
  57     timeSource->setNow(elapsed);
  58     thread.runPendingTask();
  59     EXPECT_TRUE(client.vsyncTicked());
  60 }
  61
  62 TEST(FrameRateControllerTest, TestFrameThrottling_TwoFramesInFlight)
  63 {
  64     FakeThread thread;
  65     FakeFrameRateControllerClient client;
  66     base::TimeDelta interval = base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond / 60);
  67     scoped_refptr<FakeDelayBasedTimeSource> timeSource = FakeDelayBasedTimeSource::create(interval, &thread);
  68     FrameRateController controller(timeSource);
  69
  70     controller.setClient(&client);
  71     controller.setActive(true);
  72     controller.setMaxFramesPending(2);
  73
  74     base::TimeTicks elapsed; // Muck around with time a bit
  75
  76     // Trigger one frame, make sure the vsync callback is called
  77     elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
  78     timeSource->setNow(elapsed);
  79     thread.runPendingTask();
  80     EXPECT_TRUE(client.vsyncTicked());
  81     client.reset();
  82
  83     // Tell the controller we drew
  84     controller.didBeginFrame();
  85
  86     // Trigger another frame, make sure vsync callback runs again
  87     elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
  88     EXPECT_TRUE(elapsed >= timeSource->now()); // Sanity check that previous code didn't move time backward.
  89     timeSource->setNow(elapsed);
  90     thread.runPendingTask();
  91     EXPECT_TRUE(client.vsyncTicked());
  92     client.reset();
  93
  94     // Tell the controller we drew, again.
  95     controller.didBeginFrame();
  96
  97     // Trigger another frame. Since two frames are pending, we should not draw.
  98     elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
  99     EXPECT_TRUE(elapsed >= timeSource->now()); // Sanity check that previous code didn't move time backward.
 100     timeSource->setNow(elapsed);
 101     thread.runPendingTask();
 102     EXPECT_FALSE(client.vsyncTicked());
 103
 104     // Tell the controller the first frame ended 5ms later
 105     timeSource->setNow(timeSource->now() + base::TimeDelta::FromMilliseconds(5));
 106     controller.didFinishFrame();
 107
 108     // Tick should not have been called
 109     EXPECT_FALSE(client.vsyncTicked());
 110
 111     // Trigger yet another frame. Since one frames is pending, another vsync callback should run.
 112     elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
 113     EXPECT_TRUE(elapsed >= timeSource->now()); // Sanity check that previous code didn't move time backward.
 114     timeSource->setNow(elapsed);
 115     thread.runPendingTask();
 116     EXPECT_TRUE(client.vsyncTicked());
 117 }
 118
 119 TEST(FrameRateControllerTest, TestFrameThrottling_Unthrottled)
 120 {
 121     FakeThread thread;
 122     FakeFrameRateControllerClient client;
 123     FrameRateController controller(&thread);
 124
 125     controller.setClient(&client);
 126     controller.setMaxFramesPending(2);
 127
 128     // setActive triggers 1st frame, make sure the vsync callback is called
 129     controller.setActive(true);
 130     thread.runPendingTask();
 131     EXPECT_TRUE(client.vsyncTicked());
 132     client.reset();
 133
 134     // Even if we don't call didBeginFrame, FrameRateController should
 135     // still attempt to vsync tick multiple times until it does result in
 136     // a didBeginFrame.
 137     thread.runPendingTask();
 138     EXPECT_TRUE(client.vsyncTicked());
 139     client.reset();
 140
 141     thread.runPendingTask();
 142     EXPECT_TRUE(client.vsyncTicked());
 143     client.reset();
 144
 145     // didBeginFrame triggers 2nd frame, make sure the vsync callback is called
 146     controller.didBeginFrame();
 147     thread.runPendingTask();
 148     EXPECT_TRUE(client.vsyncTicked());
 149     client.reset();
 150
 151     // didBeginFrame triggers 3rd frame (> maxFramesPending), make sure the vsync callback is NOT called
 152     controller.didBeginFrame();
 153     thread.runPendingTask();
 154     EXPECT_FALSE(client.vsyncTicked());
 155     client.reset();
 156
 157     // Make sure there is no pending task since we can't do anything until we receive a didFinishFrame anyway.
 158     EXPECT_FALSE(thread.hasPendingTask());
 159
 160     // didFinishFrame triggers a frame, make sure the vsync callback is called
 161     controller.didFinishFrame();
 162     thread.runPendingTask();
 163     EXPECT_TRUE(client.vsyncTicked());
 164 }
 165
 166 }  // namespace
 167 }  // namespace cc