1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "SMILInstanceTime.h"
#include "mozilla/AutoRestore.h"
#include "mozilla/SMILInterval.h"
#include "mozilla/SMILTimeValueSpec.h"
namespace mozilla {
//----------------------------------------------------------------------
// Implementation
SMILInstanceTime::SMILInstanceTime(const SMILTimeValue& aTime,
SMILInstanceTimeSource aSource,
SMILTimeValueSpec* aCreator,
SMILInterval* aBaseInterval)
: mTime(aTime),
mFlags(0),
mVisited(false),
mFixedEndpointRefCnt(0),
mSerial(0),
mCreator(aCreator),
mBaseInterval(nullptr) // This will get set to aBaseInterval in a call to
// SetBaseInterval() at end of constructor
{
switch (aSource) {
case SOURCE_NONE:
// No special flags
break;
case SOURCE_DOM:
mFlags = kDynamic | kFromDOM;
break;
case SOURCE_SYNCBASE:
mFlags = kMayUpdate;
break;
case SOURCE_EVENT:
mFlags = kDynamic;
break;
}
SetBaseInterval(aBaseInterval);
}
SMILInstanceTime::~SMILInstanceTime() {
MOZ_ASSERT(!mBaseInterval,
"Destroying instance time without first calling Unlink()");
MOZ_ASSERT(mFixedEndpointRefCnt == 0,
"Destroying instance time that is still used as the fixed "
"endpoint of an interval");
}
void SMILInstanceTime::Unlink() {
RefPtr<SMILInstanceTime> deathGrip(this);
if (mBaseInterval) {
mBaseInterval->RemoveDependentTime(*this);
mBaseInterval = nullptr;
}
mCreator = nullptr;
}
void SMILInstanceTime::HandleChangedInterval(
const SMILTimeContainer* aSrcContainer, bool aBeginObjectChanged,
bool aEndObjectChanged) {
// It's possible a sequence of notifications might cause our base interval to
// be updated and then deleted. Furthermore, the delete might happen whilst
// we're still in the queue to be notified of the change. In any case, if we
// don't have a base interval, just ignore the change.
if (!mBaseInterval) return;
MOZ_ASSERT(mCreator, "Base interval is set but creator is not.");
if (mVisited) {
// Break the cycle here
Unlink();
return;
}
bool objectChanged =
mCreator->DependsOnBegin() ? aBeginObjectChanged : aEndObjectChanged;
RefPtr<SMILInstanceTime> deathGrip(this);
mozilla::AutoRestore<bool> setVisited(mVisited);
mVisited = true;
mCreator->HandleChangedInstanceTime(*GetBaseTime(), aSrcContainer, *this,
objectChanged);
}
void SMILInstanceTime::HandleDeletedInterval() {
MOZ_ASSERT(mBaseInterval,
"Got call to HandleDeletedInterval on an independent instance "
"time");
MOZ_ASSERT(mCreator, "Base interval is set but creator is not");
mBaseInterval = nullptr;
mFlags &= ~kMayUpdate; // Can't update without a base interval
RefPtr<SMILInstanceTime> deathGrip(this);
mCreator->HandleDeletedInstanceTime(*this);
mCreator = nullptr;
}
void SMILInstanceTime::HandleFilteredInterval() {
MOZ_ASSERT(mBaseInterval,
"Got call to HandleFilteredInterval on an independent instance "
"time");
mBaseInterval = nullptr;
mFlags &= ~kMayUpdate; // Can't update without a base interval
mCreator = nullptr;
}
bool SMILInstanceTime::ShouldPreserve() const {
return mFixedEndpointRefCnt > 0 || (mFlags & kWasDynamicEndpoint);
}
void SMILInstanceTime::UnmarkShouldPreserve() {
mFlags &= ~kWasDynamicEndpoint;
}
void SMILInstanceTime::AddRefFixedEndpoint() {
MOZ_ASSERT(mFixedEndpointRefCnt < UINT16_MAX,
"Fixed endpoint reference count upper limit reached");
++mFixedEndpointRefCnt;
mFlags &= ~kMayUpdate; // Once fixed, always fixed
}
void SMILInstanceTime::ReleaseFixedEndpoint() {
MOZ_ASSERT(mFixedEndpointRefCnt > 0, "Duplicate release");
--mFixedEndpointRefCnt;
if (mFixedEndpointRefCnt == 0 && IsDynamic()) {
mFlags |= kWasDynamicEndpoint;
}
}
bool SMILInstanceTime::IsDependentOn(const SMILInstanceTime& aOther) const {
if (mVisited) return false;
const SMILInstanceTime* myBaseTime = GetBaseTime();
if (!myBaseTime) return false;
if (myBaseTime == &aOther) return true;
mozilla::AutoRestore<bool> setVisited(mVisited);
mVisited = true;
return myBaseTime->IsDependentOn(aOther);
}
const SMILInstanceTime* SMILInstanceTime::GetBaseTime() const {
if (!mBaseInterval) {
return nullptr;
}
MOZ_ASSERT(mCreator, "Base interval is set but there is no creator.");
if (!mCreator) {
return nullptr;
}
return mCreator->DependsOnBegin() ? mBaseInterval->Begin()
: mBaseInterval->End();
}
void SMILInstanceTime::SetBaseInterval(SMILInterval* aBaseInterval) {
MOZ_ASSERT(!mBaseInterval,
"Attempting to reassociate an instance time with a different "
"interval.");
if (aBaseInterval) {
MOZ_ASSERT(mCreator,
"Attempting to create a dependent instance time without "
"reference to the creating SMILTimeValueSpec object.");
if (!mCreator) return;
aBaseInterval->AddDependentTime(*this);
}
mBaseInterval = aBaseInterval;
}
} // namespace mozilla
|
