The Tor Browser / file comparison
comparison: dom/smil/nsSMILInterval.cpp
dom/smil/nsSMILInterval.cpp
- branch
- TOR_BUG_9701
- changeset 8
- 97036ab72558
equal
deleted
inserted
replaced
| -1:000000000000 | 0:24309514580a |
|---|---|
| 1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ | |
| 2 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 3 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 5 | |
| 6 #include "nsSMILInterval.h" | |
| 7 | |
| 8 nsSMILInterval::nsSMILInterval() | |
| 9 : | |
| 10 mBeginFixed(false), | |
| 11 mEndFixed(false) | |
| 12 { | |
| 13 } | |
| 14 | |
| 15 nsSMILInterval::nsSMILInterval(const nsSMILInterval& aOther) | |
| 16 : | |
| 17 mBegin(aOther.mBegin), | |
| 18 mEnd(aOther.mEnd), | |
| 19 mBeginFixed(false), | |
| 20 mEndFixed(false) | |
| 21 { | |
| 22 NS_ABORT_IF_FALSE(aOther.mDependentTimes.IsEmpty(), | |
| 23 "Attempting to copy-construct an interval with dependent times, " | |
| 24 "this will lead to instance times being shared between intervals."); | |
| 25 | |
| 26 // For the time being we don't allow intervals with fixed endpoints to be | |
| 27 // copied since we only ever copy-construct to establish a new current | |
| 28 // interval. If we ever need to copy historical intervals we may need to move | |
| 29 // the ReleaseFixedEndpoint calls from Unlink to the dtor. | |
| 30 NS_ABORT_IF_FALSE(!aOther.mBeginFixed && !aOther.mEndFixed, | |
| 31 "Attempting to copy-construct an interval with fixed endpoints"); | |
| 32 } | |
| 33 | |
| 34 nsSMILInterval::~nsSMILInterval() | |
| 35 { | |
| 36 NS_ABORT_IF_FALSE(mDependentTimes.IsEmpty(), | |
| 37 "Destroying interval without disassociating dependent instance times. " | |
| 38 "Unlink was not called"); | |
| 39 } | |
| 40 | |
| 41 void | |
| 42 nsSMILInterval::Unlink(bool aFiltered) | |
| 43 { | |
| 44 for (int32_t i = mDependentTimes.Length() - 1; i >= 0; --i) { | |
| 45 if (aFiltered) { | |
| 46 mDependentTimes[i]->HandleFilteredInterval(); | |
| 47 } else { | |
| 48 mDependentTimes[i]->HandleDeletedInterval(); | |
| 49 } | |
| 50 } | |
| 51 mDependentTimes.Clear(); | |
| 52 if (mBegin && mBeginFixed) { | |
| 53 mBegin->ReleaseFixedEndpoint(); | |
| 54 } | |
| 55 mBegin = nullptr; | |
| 56 if (mEnd && mEndFixed) { | |
| 57 mEnd->ReleaseFixedEndpoint(); | |
| 58 } | |
| 59 mEnd = nullptr; | |
| 60 } | |
| 61 | |
| 62 nsSMILInstanceTime* | |
| 63 nsSMILInterval::Begin() | |
| 64 { | |
| 65 NS_ABORT_IF_FALSE(mBegin && mEnd, | |
| 66 "Requesting Begin() on un-initialized interval."); | |
| 67 return mBegin; | |
| 68 } | |
| 69 | |
| 70 nsSMILInstanceTime* | |
| 71 nsSMILInterval::End() | |
| 72 { | |
| 73 NS_ABORT_IF_FALSE(mBegin && mEnd, | |
| 74 "Requesting End() on un-initialized interval."); | |
| 75 return mEnd; | |
| 76 } | |
| 77 | |
| 78 void | |
| 79 nsSMILInterval::SetBegin(nsSMILInstanceTime& aBegin) | |
| 80 { | |
| 81 NS_ABORT_IF_FALSE(aBegin.Time().IsDefinite(), | |
| 82 "Attempting to set unresolved or indefinite begin time on interval"); | |
| 83 NS_ABORT_IF_FALSE(!mBeginFixed, | |
| 84 "Attempting to set begin time but the begin point is fixed"); | |
| 85 // Check that we're not making an instance time dependent on itself. Such an | |
| 86 // arrangement does not make intuitive sense and should be detected when | |
| 87 // creating or updating intervals. | |
| 88 NS_ABORT_IF_FALSE(!mBegin || aBegin.GetBaseTime() != mBegin, | |
| 89 "Attempting to make self-dependent instance time"); | |
| 90 | |
| 91 mBegin = &aBegin; | |
| 92 } | |
| 93 | |
| 94 void | |
| 95 nsSMILInterval::SetEnd(nsSMILInstanceTime& aEnd) | |
| 96 { | |
| 97 NS_ABORT_IF_FALSE(!mEndFixed, | |
| 98 "Attempting to set end time but the end point is fixed"); | |
| 99 // As with SetBegin, check we're not making an instance time dependent on | |
| 100 // itself. | |
| 101 NS_ABORT_IF_FALSE(!mEnd || aEnd.GetBaseTime() != mEnd, | |
| 102 "Attempting to make self-dependent instance time"); | |
| 103 | |
| 104 mEnd = &aEnd; | |
| 105 } | |
| 106 | |
| 107 void | |
| 108 nsSMILInterval::FixBegin() | |
| 109 { | |
| 110 NS_ABORT_IF_FALSE(mBegin && mEnd, | |
| 111 "Fixing begin point on un-initialized interval"); | |
| 112 NS_ABORT_IF_FALSE(!mBeginFixed, "Duplicate calls to FixBegin()"); | |
| 113 mBeginFixed = true; | |
| 114 mBegin->AddRefFixedEndpoint(); | |
| 115 } | |
| 116 | |
| 117 void | |
| 118 nsSMILInterval::FixEnd() | |
| 119 { | |
| 120 NS_ABORT_IF_FALSE(mBegin && mEnd, | |
| 121 "Fixing end point on un-initialized interval"); | |
| 122 NS_ABORT_IF_FALSE(mBeginFixed, | |
| 123 "Fixing the end of an interval without a fixed begin"); | |
| 124 NS_ABORT_IF_FALSE(!mEndFixed, "Duplicate calls to FixEnd()"); | |
| 125 mEndFixed = true; | |
| 126 mEnd->AddRefFixedEndpoint(); | |
| 127 } | |
| 128 | |
| 129 void | |
| 130 nsSMILInterval::AddDependentTime(nsSMILInstanceTime& aTime) | |
| 131 { | |
| 132 nsRefPtr<nsSMILInstanceTime>* inserted = | |
| 133 mDependentTimes.InsertElementSorted(&aTime); | |
| 134 if (!inserted) { | |
| 135 NS_WARNING("Insufficient memory to insert instance time."); | |
| 136 } | |
| 137 } | |
| 138 | |
| 139 void | |
| 140 nsSMILInterval::RemoveDependentTime(const nsSMILInstanceTime& aTime) | |
| 141 { | |
| 142 #ifdef DEBUG | |
| 143 bool found = | |
| 144 #endif | |
| 145 mDependentTimes.RemoveElementSorted(&aTime); | |
| 146 NS_ABORT_IF_FALSE(found, "Couldn't find instance time to delete."); | |
| 147 } | |
| 148 | |
| 149 void | |
| 150 nsSMILInterval::GetDependentTimes(InstanceTimeList& aTimes) | |
| 151 { | |
| 152 aTimes = mDependentTimes; | |
| 153 } | |
| 154 | |
| 155 bool | |
| 156 nsSMILInterval::IsDependencyChainLink() const | |
| 157 { | |
| 158 if (!mBegin || !mEnd) | |
| 159 return false; // Not yet initialised so it can't be part of a chain | |
| 160 | |
| 161 if (mDependentTimes.IsEmpty()) | |
| 162 return false; // No dependents, chain end | |
| 163 | |
| 164 // So we have dependents, but we're still only a link in the chain (as opposed | |
| 165 // to the end of the chain) if one of our endpoints is dependent on an | |
| 166 // interval other than ourselves. | |
| 167 return (mBegin->IsDependent() && mBegin->GetBaseInterval() != this) || | |
| 168 (mEnd->IsDependent() && mEnd->GetBaseInterval() != this); | |
| 169 } |
