e7b19a760504ef74c843406053af40c933340354
[WebKit-https.git] / Source / WebCore / platform / graphics / chromium / cc / CCDelayBasedTimeSource.cpp
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1.  Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  * 2.  Redistributions in binary form must reproduce the above copyright
10  *     notice, this list of conditions and the following disclaimer in the
11  *     documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #include "config.h"
26
27 #include "cc/CCDelayBasedTimeSource.h"
28
29 #include "cc/CCThread.h"
30 #include "cc/CCThreadTask.h"
31 #include <wtf/CurrentTime.h>
32 #include <wtf/MathExtras.h>
33
34 namespace WebCore {
35
36 PassRefPtr<CCDelayBasedTimeSource> CCDelayBasedTimeSource::create(double intervalMs, CCThread* thread)
37 {
38     return adoptRef(new CCDelayBasedTimeSource(intervalMs, thread));
39 }
40
41 CCDelayBasedTimeSource::CCDelayBasedTimeSource(double intervalMs, CCThread* thread)
42     : m_client(0)
43     , m_hasTickTarget(false)
44     , m_intervalMs(intervalMs)
45     , m_tickTarget(0)
46     , m_state(STATE_INACTIVE)
47     , m_timer(thread, this)
48 {
49 }
50
51 void CCDelayBasedTimeSource::setActive(bool active)
52 {
53     if (!active) {
54         m_state = STATE_INACTIVE;
55         m_timer.stop();
56         return;
57     }
58
59     if (m_state == STATE_STARTING || m_state == STATE_ACTIVE)
60         return;
61
62     if (!m_hasTickTarget) {
63         // Becoming active the first time is deferred: we post a 0-delay task. When
64         // it runs, we use that to establish the timebase, become truly active, and
65         // fire the first tick.
66         m_state = STATE_STARTING;
67         m_timer.startOneShot(0);
68         return;
69     }
70
71     m_state = STATE_ACTIVE;
72
73     double nowMs = monotonicallyIncreasingTimeMs();
74     postNextTickTask(nowMs);
75 }
76
77 void CCDelayBasedTimeSource::onTimerFired()
78 {
79     ASSERT(m_state != STATE_INACTIVE);
80
81     double nowMs = monotonicallyIncreasingTimeMs();
82
83     if (m_state == STATE_STARTING) {
84         m_hasTickTarget = true;
85         m_tickTarget = nowMs;
86         m_state = STATE_ACTIVE;
87     }
88
89     postNextTickTask(nowMs);
90
91     // Fire the tick
92     if (m_client)
93         m_client->onTimerTick();
94 }
95
96 double CCDelayBasedTimeSource::monotonicallyIncreasingTimeMs() const
97 {
98     return WTF::monotonicallyIncreasingTime() * 1000.0;
99 }
100
101 // This code tries to achieve an average tick rate as close to m_intervalMs as possible.
102 // To do this, it has to deal with a few basic issues:
103 //   1. postDelayedTask can delay only at a millisecond granularity. So, 16.666 has to
104 //      posted as 16 or 17.
105 //   2. A delayed task may come back a bit late (a few ms), or really late (frames later)
106 //
107 // The basic idea with this scheduler here is to keep track of where we *want* to run in
108 // m_tickTarget. We update this with the exact interval.
109 //
110 // Then, when we post our task, we take the floor of (m_tickTarget and now()). If we
111 // started at now=0, and 60FPs:
112 //      now=0    target=16.667   postDelayedTask(16)
113 //
114 // When our callback runs, we figure out how far off we were from that goal. Because of the flooring
115 // operation, and assuming our timer runs exactly when it should, this yields:
116 //      now=16   target=16.667
117 //
118 // Since we can't post a 0.667 ms task to get to now=16, we just treat this as a tick. Then,
119 // we update target to be 33.333. We now post another task based on the difference between our target
120 // and now:
121 //      now=16   tickTarget=16.667  newTarget=33.333   --> postDelayedTask(floor(33.333 - 16)) --> postDelayedTask(17)
122 //
123 // Over time, with no late tasks, this leads to us posting tasks like this:
124 //      now=0    tickTarget=0       newTarget=16.667   --> tick(), postDelayedTask(16)
125 //      now=16   tickTarget=16.667  newTarget=33.333   --> tick(), postDelayedTask(17)
126 //      now=33   tickTarget=33.333  newTarget=50.000   --> tick(), postDelayedTask(17)
127 //      now=50   tickTarget=50.000  newTarget=66.667   --> tick(), postDelayedTask(16)
128 //
129 // We treat delays in tasks differently depending on the amount of delay we encounter. Suppose we
130 // posted a task with a target=16.667:
131 //   Case 1: late but not unrecoverably-so
132 //      now=18 tickTarget=16.667
133 //
134 //   Case 2: so late we obviously missed the tick
135 //      now=25.0 tickTarget=16.667
136 //
137 // We treat the first case as a tick anyway, and assume the delay was
138 // unusual. Thus, we compute the newTarget based on the old timebase:
139 //      now=18   tickTarget=16.667  newTarget=33.333   --> tick(), postDelayedTask(floor(33.333-18)) --> postDelayedTask(15)
140 // This brings us back to 18+15 = 33, which was where we would have been if the task hadn't been late.
141 //
142 // For the really late delay, we we move to the next logical tick. The timebase is not reset.
143 //      now=37   tickTarget=16.667  newTarget=50.000  --> tick(), postDelayedTask(floor(50.000-37)) --> postDelayedTask(13)
144 void CCDelayBasedTimeSource::postNextTickTask(double nowMs)
145 {
146     int numIntervalsElapsed = static_cast<int>(floor((nowMs - m_tickTarget) / m_intervalMs));
147     double lastEffectiveTick = m_tickTarget + m_intervalMs * numIntervalsElapsed;
148     double newTickTarget = lastEffectiveTick + m_intervalMs;
149
150     long long delay = static_cast<long long>(newTickTarget - nowMs);
151     if (!delay) {
152         newTickTarget = newTickTarget + m_intervalMs;
153         delay = static_cast<long long>(newTickTarget - nowMs);
154     }
155
156     // Post another task *before* the tick and update state
157     ASSERT(newTickTarget > nowMs);
158     m_timer.startOneShot(delay);
159     m_tickTarget = newTickTarget;
160 }
161
162 }