Add m-esr52 at 52.6.0

1 files changed, 170 insertions, 0 deletions

diff --git a/dom/smil/nsSMILInterval.cpp b/dom/smil/nsSMILInterval.cpp
new file mode 100644
index 000000000..956efd626
--- /dev/null
+++ b/dom/smil/nsSMILInterval.cpp
@@ -0,0 +1,170 @@
+/* -*- 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 "nsSMILInterval.h"
+
+nsSMILInterval::nsSMILInterval()
+:
+  mBeginFixed(false),
+  mEndFixed(false)
+{
+}
+
+nsSMILInterval::nsSMILInterval(const nsSMILInterval& aOther)
+:
+  mBegin(aOther.mBegin),
+  mEnd(aOther.mEnd),
+  mBeginFixed(false),
+  mEndFixed(false)
+{
+  MOZ_ASSERT(aOther.mDependentTimes.IsEmpty(),
+             "Attempt to copy-construct an interval with dependent times; this "
+             "will lead to instance times being shared between intervals.");
+
+  // For the time being we don't allow intervals with fixed endpoints to be
+  // copied since we only ever copy-construct to establish a new current
+  // interval. If we ever need to copy historical intervals we may need to move
+  // the ReleaseFixedEndpoint calls from Unlink to the dtor.
+  MOZ_ASSERT(!aOther.mBeginFixed && !aOther.mEndFixed,
+             "Attempt to copy-construct an interval with fixed endpoints");
+}
+
+nsSMILInterval::~nsSMILInterval()
+{
+  MOZ_ASSERT(mDependentTimes.IsEmpty(),
+             "Destroying interval without disassociating dependent instance "
+             "times. Unlink was not called");
+}
+
+void
+nsSMILInterval::Unlink(bool aFiltered)
+{
+  for (int32_t i = mDependentTimes.Length() - 1; i >= 0; --i) {
+    if (aFiltered) {
+      mDependentTimes[i]->HandleFilteredInterval();
+    } else {
+      mDependentTimes[i]->HandleDeletedInterval();
+    }
+  }
+  mDependentTimes.Clear();
+  if (mBegin && mBeginFixed) {
+    mBegin->ReleaseFixedEndpoint();
+  }
+  mBegin = nullptr;
+  if (mEnd && mEndFixed) {
+    mEnd->ReleaseFixedEndpoint();
+  }
+  mEnd = nullptr;
+}
+
+nsSMILInstanceTime*
+nsSMILInterval::Begin()
+{
+  MOZ_ASSERT(mBegin && mEnd,
+             "Requesting Begin() on un-initialized interval.");
+  return mBegin;
+}
+
+nsSMILInstanceTime*
+nsSMILInterval::End()
+{
+  MOZ_ASSERT(mBegin && mEnd,
+             "Requesting End() on un-initialized interval.");
+  return mEnd;
+}
+
+void
+nsSMILInterval::SetBegin(nsSMILInstanceTime& aBegin)
+{
+  MOZ_ASSERT(aBegin.Time().IsDefinite(),
+             "Attempt to set unresolved or indefinite begin time on interval");
+  MOZ_ASSERT(!mBeginFixed,
+             "Attempt to set begin time but the begin point is fixed");
+  // Check that we're not making an instance time dependent on itself. Such an
+  // arrangement does not make intuitive sense and should be detected when
+  // creating or updating intervals.
+  MOZ_ASSERT(!mBegin || aBegin.GetBaseTime() != mBegin,
+             "Attempt to make self-dependent instance time");
+
+  mBegin = &aBegin;
+}
+
+void
+nsSMILInterval::SetEnd(nsSMILInstanceTime& aEnd)
+{
+  MOZ_ASSERT(!mEndFixed,
+             "Attempt to set end time but the end point is fixed");
+  // As with SetBegin, check we're not making an instance time dependent on
+  // itself.
+  MOZ_ASSERT(!mEnd || aEnd.GetBaseTime() != mEnd,
+             "Attempting to make self-dependent instance time");
+
+  mEnd = &aEnd;
+}
+
+void
+nsSMILInterval::FixBegin()
+{
+  MOZ_ASSERT(mBegin && mEnd,
+             "Fixing begin point on un-initialized interval");
+  MOZ_ASSERT(!mBeginFixed, "Duplicate calls to FixBegin()");
+  mBeginFixed = true;
+  mBegin->AddRefFixedEndpoint();
+}
+
+void
+nsSMILInterval::FixEnd()
+{
+  MOZ_ASSERT(mBegin && mEnd,
+             "Fixing end point on un-initialized interval");
+  MOZ_ASSERT(mBeginFixed,
+             "Fixing the end of an interval without a fixed begin");
+  MOZ_ASSERT(!mEndFixed, "Duplicate calls to FixEnd()");
+  mEndFixed = true;
+  mEnd->AddRefFixedEndpoint();
+}
+
+void
+nsSMILInterval::AddDependentTime(nsSMILInstanceTime& aTime)
+{
+  RefPtr<nsSMILInstanceTime>* inserted =
+    mDependentTimes.InsertElementSorted(&aTime);
+  if (!inserted) {
+    NS_WARNING("Insufficient memory to insert instance time.");
+  }
+}
+
+void
+nsSMILInterval::RemoveDependentTime(const nsSMILInstanceTime& aTime)
+{
+#ifdef DEBUG
+  bool found =
+#endif
+    mDependentTimes.RemoveElementSorted(&aTime);
+  MOZ_ASSERT(found, "Couldn't find instance time to delete.");
+}
+
+void
+nsSMILInterval::GetDependentTimes(InstanceTimeList& aTimes)
+{
+  aTimes = mDependentTimes;
+}
+
+bool
+nsSMILInterval::IsDependencyChainLink() const
+{
+  if (!mBegin || !mEnd)
+    return false; // Not yet initialised so it can't be part of a chain
+
+  if (mDependentTimes.IsEmpty())
+    return false; // No dependents, chain end
+
+  // So we have dependents, but we're still only a link in the chain (as opposed
+  // to the end of the chain) if one of our endpoints is dependent on an
+  // interval other than ourselves.
+  return (mBegin->IsDependent() && mBegin->GetBaseInterval() != this) ||
+         (mEnd->IsDependent() && mEnd->GetBaseInterval() != this);
+}