Add m-esr52 at 52.6.0

1 files changed, 848 insertions, 0 deletions

diff --git a/dom/html/TextTrackManager.cpp b/dom/html/TextTrackManager.cpp
new file mode 100644
index 000000000..8110dab29
--- /dev/null
+++ b/dom/html/TextTrackManager.cpp
@@ -0,0 +1,848 @@
+/* -*- 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 "mozilla/dom/TextTrackManager.h"
+#include "mozilla/dom/HTMLMediaElement.h"
+#include "mozilla/dom/HTMLTrackElement.h"
+#include "mozilla/dom/HTMLVideoElement.h"
+#include "mozilla/dom/TextTrack.h"
+#include "mozilla/dom/TextTrackCue.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/Telemetry.h"
+#include "nsComponentManagerUtils.h"
+#include "nsVariant.h"
+#include "nsVideoFrame.h"
+#include "nsIFrame.h"
+#include "nsTArrayHelpers.h"
+#include "nsIWebVTTParserWrapper.h"
+
+
+static mozilla::LazyLogModule gTextTrackLog("TextTrackManager");
+#define WEBVTT_LOG(...)  MOZ_LOG(gTextTrackLog, LogLevel::Debug, (__VA_ARGS__))
+#define WEBVTT_LOGV(...) MOZ_LOG(gTextTrackLog, LogLevel::Verbose, (__VA_ARGS__))
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ISUPPORTS(TextTrackManager::ShutdownObserverProxy, nsIObserver);
+
+CompareTextTracks::CompareTextTracks(HTMLMediaElement* aMediaElement)
+{
+  mMediaElement = aMediaElement;
+}
+
+int32_t
+CompareTextTracks::TrackChildPosition(TextTrack* aTextTrack) const {
+  MOZ_DIAGNOSTIC_ASSERT(aTextTrack);
+  HTMLTrackElement* trackElement = aTextTrack->GetTrackElement();
+  if (!trackElement) {
+    return -1;
+  }
+  return mMediaElement->IndexOf(trackElement);
+}
+
+bool
+CompareTextTracks::Equals(TextTrack* aOne, TextTrack* aTwo) const {
+  // Two tracks can never be equal. If they have corresponding TrackElements
+  // they would need to occupy the same tree position (impossible) and in the
+  // case of tracks coming from AddTextTrack source we put the newest at the
+  // last position, so they won't be equal as well.
+  return false;
+}
+
+bool
+CompareTextTracks::LessThan(TextTrack* aOne, TextTrack* aTwo) const
+{
+  // Protect against nullptr TextTrack objects; treat them as
+  // sorting toward the end.
+  if (!aOne) {
+    return false;
+  }
+  if (!aTwo) {
+    return true;
+  }
+  TextTrackSource sourceOne = aOne->GetTextTrackSource();
+  TextTrackSource sourceTwo = aTwo->GetTextTrackSource();
+  if (sourceOne != sourceTwo) {
+    return sourceOne == TextTrackSource::Track ||
+           (sourceOne == AddTextTrack && sourceTwo == MediaResourceSpecific);
+  }
+  switch (sourceOne) {
+    case Track: {
+      int32_t positionOne = TrackChildPosition(aOne);
+      int32_t positionTwo = TrackChildPosition(aTwo);
+      // If either position one or positiontwo are -1 then something has gone
+      // wrong. In this case we should just put them at the back of the list.
+      return positionOne != -1 && positionTwo != -1 &&
+             positionOne < positionTwo;
+    }
+    case AddTextTrack:
+      // For AddTextTrack sources the tracks will already be in the correct relative
+      // order in the source array. Assume we're called in iteration order and can
+      // therefore always report aOne < aTwo to maintain the original temporal ordering.
+      return true;
+    case MediaResourceSpecific:
+      // No rules for Media Resource Specific tracks yet.
+      break;
+  }
+  return true;
+}
+
+NS_IMPL_CYCLE_COLLECTION(TextTrackManager, mMediaElement, mTextTracks,
+                         mPendingTextTracks, mNewCues,
+                         mLastActiveCues)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TextTrackManager)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(TextTrackManager)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(TextTrackManager)
+
+StaticRefPtr<nsIWebVTTParserWrapper> TextTrackManager::sParserWrapper;
+
+TextTrackManager::TextTrackManager(HTMLMediaElement *aMediaElement)
+  : mMediaElement(aMediaElement)
+  , mHasSeeked(false)
+  , mLastTimeMarchesOnCalled(0.0)
+  , mTimeMarchesOnDispatched(false)
+  , mUpdateCueDisplayDispatched(false)
+  , performedTrackSelection(false)
+  , mCueTelemetryReported(false)
+  , mShutdown(false)
+{
+  nsISupports* parentObject =
+    mMediaElement->OwnerDoc()->GetParentObject();
+
+  NS_ENSURE_TRUE_VOID(parentObject);
+  WEBVTT_LOG("%p Create TextTrackManager",this);
+  nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(parentObject);
+  mNewCues = new TextTrackCueList(window);
+  mLastActiveCues = new TextTrackCueList(window);
+  mTextTracks = new TextTrackList(window, this);
+  mPendingTextTracks = new TextTrackList(window, this);
+
+  if (!sParserWrapper) {
+    nsCOMPtr<nsIWebVTTParserWrapper> parserWrapper =
+      do_CreateInstance(NS_WEBVTTPARSERWRAPPER_CONTRACTID);
+    sParserWrapper = parserWrapper;
+    ClearOnShutdown(&sParserWrapper);
+  }
+  mShutdownProxy = new ShutdownObserverProxy(this);
+}
+
+TextTrackManager::~TextTrackManager()
+{
+  WEBVTT_LOG("%p ~TextTrackManager",this);
+  nsContentUtils::UnregisterShutdownObserver(mShutdownProxy);
+}
+
+TextTrackList*
+TextTrackManager::GetTextTracks() const
+{
+  return mTextTracks;
+}
+
+already_AddRefed<TextTrack>
+TextTrackManager::AddTextTrack(TextTrackKind aKind, const nsAString& aLabel,
+                               const nsAString& aLanguage,
+                               TextTrackMode aMode,
+                               TextTrackReadyState aReadyState,
+                               TextTrackSource aTextTrackSource)
+{
+  if (!mMediaElement || !mTextTracks) {
+    return nullptr;
+  }
+  WEBVTT_LOG("%p AddTextTrack",this);
+  WEBVTT_LOGV("AddTextTrack kind %d Label %s Language %s",aKind,
+    NS_ConvertUTF16toUTF8(aLabel).get(), NS_ConvertUTF16toUTF8(aLanguage).get());
+  RefPtr<TextTrack> track =
+    mTextTracks->AddTextTrack(aKind, aLabel, aLanguage, aMode, aReadyState,
+                              aTextTrackSource, CompareTextTracks(mMediaElement));
+  AddCues(track);
+  ReportTelemetryForTrack(track);
+
+  if (aTextTrackSource == TextTrackSource::Track) {
+    RefPtr<nsIRunnable> task =
+      NewRunnableMethod(this, &TextTrackManager::HonorUserPreferencesForTrackSelection);
+    nsContentUtils::RunInStableState(task.forget());
+  }
+
+  return track.forget();
+}
+
+void
+TextTrackManager::AddTextTrack(TextTrack* aTextTrack)
+{
+  if (!mMediaElement || !mTextTracks) {
+    return;
+  }
+  WEBVTT_LOG("%p AddTextTrack TextTrack %p",this, aTextTrack);
+  mTextTracks->AddTextTrack(aTextTrack, CompareTextTracks(mMediaElement));
+  AddCues(aTextTrack);
+  ReportTelemetryForTrack(aTextTrack);
+
+  if (aTextTrack->GetTextTrackSource() == TextTrackSource::Track) {
+    RefPtr<nsIRunnable> task =
+      NewRunnableMethod(this, &TextTrackManager::HonorUserPreferencesForTrackSelection);
+    nsContentUtils::RunInStableState(task.forget());
+  }
+}
+
+void
+TextTrackManager::AddCues(TextTrack* aTextTrack)
+{
+  if (!mNewCues) {
+    WEBVTT_LOG("AddCues mNewCues is null");
+    return;
+  }
+
+  TextTrackCueList* cueList = aTextTrack->GetCues();
+  if (cueList) {
+    bool dummy;
+    WEBVTT_LOGV("AddCues cueList->Length() %d",cueList->Length());
+    for (uint32_t i = 0; i < cueList->Length(); ++i) {
+      mNewCues->AddCue(*cueList->IndexedGetter(i, dummy));
+    }
+    DispatchTimeMarchesOn();
+  }
+}
+
+void
+TextTrackManager::RemoveTextTrack(TextTrack* aTextTrack, bool aPendingListOnly)
+{
+  if (!mPendingTextTracks || !mTextTracks) {
+    return;
+  }
+
+  WEBVTT_LOG("%p RemoveTextTrack TextTrack %p", this, aTextTrack);
+  mPendingTextTracks->RemoveTextTrack(aTextTrack);
+  if (aPendingListOnly) {
+    return;
+  }
+
+  mTextTracks->RemoveTextTrack(aTextTrack);
+  // Remove the cues in mNewCues belong to aTextTrack.
+  TextTrackCueList* removeCueList = aTextTrack->GetCues();
+  if (removeCueList) {
+    WEBVTT_LOGV("RemoveTextTrack removeCueList->Length() %d", removeCueList->Length());
+    for (uint32_t i = 0; i < removeCueList->Length(); ++i) {
+      mNewCues->RemoveCue(*((*removeCueList)[i]));
+    }
+    DispatchTimeMarchesOn();
+  }
+}
+
+void
+TextTrackManager::DidSeek()
+{
+  WEBVTT_LOG("%p DidSeek",this);
+  if (mTextTracks) {
+    mTextTracks->DidSeek();
+  }
+  if (mMediaElement) {
+    mLastTimeMarchesOnCalled = mMediaElement->CurrentTime();
+    WEBVTT_LOGV("DidSeek set mLastTimeMarchesOnCalled %lf",mLastTimeMarchesOnCalled);
+  }
+  mHasSeeked = true;
+}
+
+void
+TextTrackManager::UpdateCueDisplay()
+{
+  WEBVTT_LOG("UpdateCueDisplay");
+  mUpdateCueDisplayDispatched = false;
+
+  if (!mMediaElement || !mTextTracks) {
+    return;
+  }
+
+  nsIFrame* frame = mMediaElement->GetPrimaryFrame();
+  nsVideoFrame* videoFrame = do_QueryFrame(frame);
+  if (!videoFrame) {
+    return;
+  }
+
+  nsCOMPtr<nsIContent> overlay = videoFrame->GetCaptionOverlay();
+  nsCOMPtr<nsIContent> controls = videoFrame->GetVideoControls();
+  if (!overlay) {
+    return;
+  }
+
+  nsTArray<RefPtr<TextTrackCue> > activeCues;
+  mTextTracks->GetShowingCues(activeCues);
+
+  if (activeCues.Length() > 0) {
+    WEBVTT_LOG("UpdateCueDisplay ProcessCues");
+    WEBVTT_LOGV("UpdateCueDisplay activeCues.Length() %d",activeCues.Length());
+    RefPtr<nsVariantCC> jsCues = new nsVariantCC();
+
+    jsCues->SetAsArray(nsIDataType::VTYPE_INTERFACE,
+                       &NS_GET_IID(nsIDOMEventTarget),
+                       activeCues.Length(),
+                       static_cast<void*>(activeCues.Elements()));
+    nsPIDOMWindowInner* window = mMediaElement->OwnerDoc()->GetInnerWindow();
+    if (window) {
+      sParserWrapper->ProcessCues(window, jsCues, overlay, controls);
+    }
+  } else if (overlay->Length() > 0) {
+    WEBVTT_LOG("UpdateCueDisplay EmptyString");
+    nsContentUtils::SetNodeTextContent(overlay, EmptyString(), true);
+  }
+}
+
+void
+TextTrackManager::NotifyCueAdded(TextTrackCue& aCue)
+{
+  WEBVTT_LOG("NotifyCueAdded");
+  if (mNewCues) {
+    mNewCues->AddCue(aCue);
+  }
+  DispatchTimeMarchesOn();
+  ReportTelemetryForCue();
+}
+
+void
+TextTrackManager::NotifyCueRemoved(TextTrackCue& aCue)
+{
+  WEBVTT_LOG("NotifyCueRemoved");
+  if (mNewCues) {
+    mNewCues->RemoveCue(aCue);
+  }
+  DispatchTimeMarchesOn();
+  if (aCue.GetActive()) {
+    // We remove an active cue, need to update the display.
+    DispatchUpdateCueDisplay();
+  }
+}
+
+void
+TextTrackManager::PopulatePendingList()
+{
+  if (!mTextTracks || !mPendingTextTracks || !mMediaElement) {
+    return;
+  }
+  uint32_t len = mTextTracks->Length();
+  bool dummy;
+  for (uint32_t index = 0; index < len; ++index) {
+    TextTrack* ttrack = mTextTracks->IndexedGetter(index, dummy);
+    if (ttrack && ttrack->Mode() != TextTrackMode::Disabled &&
+        ttrack->ReadyState() == TextTrackReadyState::Loading) {
+      mPendingTextTracks->AddTextTrack(ttrack,
+                                       CompareTextTracks(mMediaElement));
+    }
+  }
+}
+
+void
+TextTrackManager::AddListeners()
+{
+  if (mMediaElement) {
+    mMediaElement->AddEventListener(NS_LITERAL_STRING("resizevideocontrols"),
+                                    this, false, false);
+    mMediaElement->AddEventListener(NS_LITERAL_STRING("seeked"),
+                                    this, false, false);
+    mMediaElement->AddEventListener(NS_LITERAL_STRING("controlbarchange"),
+                                    this, false, true);
+  }
+}
+
+void
+TextTrackManager::HonorUserPreferencesForTrackSelection()
+{
+  if (performedTrackSelection || !mTextTracks) {
+    return;
+  }
+  WEBVTT_LOG("HonorUserPreferencesForTrackSelection");
+  TextTrackKind ttKinds[] = { TextTrackKind::Captions,
+                              TextTrackKind::Subtitles };
+
+  // Steps 1 - 3: Perform automatic track selection for different TextTrack
+  // Kinds.
+  PerformTrackSelection(ttKinds, ArrayLength(ttKinds));
+  PerformTrackSelection(TextTrackKind::Descriptions);
+  PerformTrackSelection(TextTrackKind::Chapters);
+
+  // Step 4: Set all TextTracks with a kind of metadata that are disabled
+  // to hidden.
+  for (uint32_t i = 0; i < mTextTracks->Length(); i++) {
+    TextTrack* track = (*mTextTracks)[i];
+    if (track->Kind() == TextTrackKind::Metadata && TrackIsDefault(track) &&
+        track->Mode() == TextTrackMode::Disabled) {
+      track->SetMode(TextTrackMode::Hidden);
+    }
+  }
+
+  performedTrackSelection = true;
+}
+
+bool
+TextTrackManager::TrackIsDefault(TextTrack* aTextTrack)
+{
+  HTMLTrackElement* trackElement = aTextTrack->GetTrackElement();
+  if (!trackElement) {
+    return false;
+  }
+  return trackElement->Default();
+}
+
+void
+TextTrackManager::PerformTrackSelection(TextTrackKind aTextTrackKind)
+{
+  TextTrackKind ttKinds[] = { aTextTrackKind };
+  PerformTrackSelection(ttKinds, ArrayLength(ttKinds));
+}
+
+void
+TextTrackManager::PerformTrackSelection(TextTrackKind aTextTrackKinds[],
+                                        uint32_t size)
+{
+  nsTArray<TextTrack*> candidates;
+  GetTextTracksOfKinds(aTextTrackKinds, size, candidates);
+
+  // Step 3: If any TextTracks in candidates are showing then abort these steps.
+  for (uint32_t i = 0; i < candidates.Length(); i++) {
+    if (candidates[i]->Mode() == TextTrackMode::Showing) {
+      WEBVTT_LOGV("PerformTrackSelection Showing return kind %d",candidates[i]->Kind());
+      return;
+    }
+  }
+
+  // Step 4: Honor user preferences for track selection, otherwise, set the
+  // first TextTrack in candidates with a default attribute to showing.
+  // TODO: Bug 981691 - Honor user preferences for text track selection.
+  for (uint32_t i = 0; i < candidates.Length(); i++) {
+    if (TrackIsDefault(candidates[i]) &&
+        candidates[i]->Mode() == TextTrackMode::Disabled) {
+      candidates[i]->SetMode(TextTrackMode::Showing);
+      WEBVTT_LOGV("PerformTrackSelection set Showing kind %d", candidates[i]->Kind());
+      return;
+    }
+  }
+}
+
+void
+TextTrackManager::GetTextTracksOfKinds(TextTrackKind aTextTrackKinds[],
+                                       uint32_t size,
+                                       nsTArray<TextTrack*>& aTextTracks)
+{
+  for (uint32_t i = 0; i < size; i++) {
+    GetTextTracksOfKind(aTextTrackKinds[i], aTextTracks);
+  }
+}
+
+void
+TextTrackManager::GetTextTracksOfKind(TextTrackKind aTextTrackKind,
+                                      nsTArray<TextTrack*>& aTextTracks)
+{
+  if (!mTextTracks) {
+    return;
+  }
+  for (uint32_t i = 0; i < mTextTracks->Length(); i++) {
+    TextTrack* textTrack = (*mTextTracks)[i];
+    if (textTrack->Kind() == aTextTrackKind) {
+      aTextTracks.AppendElement(textTrack);
+    }
+  }
+}
+
+NS_IMETHODIMP
+TextTrackManager::HandleEvent(nsIDOMEvent* aEvent)
+{
+  if (!mTextTracks) {
+    return NS_OK;
+  }
+
+  nsAutoString type;
+  aEvent->GetType(type);
+  if (type.EqualsLiteral("resizevideocontrols") ||
+      type.EqualsLiteral("seeked")) {
+    for (uint32_t i = 0; i< mTextTracks->Length(); i++) {
+      ((*mTextTracks)[i])->SetCuesDirty();
+    }
+  }
+
+  if (type.EqualsLiteral("controlbarchange")) {
+    UpdateCueDisplay();
+  }
+
+  return NS_OK;
+}
+
+
+class SimpleTextTrackEvent : public Runnable
+{
+public:
+  friend class CompareSimpleTextTrackEvents;
+  SimpleTextTrackEvent(const nsAString& aEventName, double aTime,
+                       TextTrack* aTrack, TextTrackCue* aCue)
+  : mName(aEventName),
+    mTime(aTime),
+    mTrack(aTrack),
+    mCue(aCue)
+  {}
+
+  NS_IMETHOD Run() {
+    WEBVTT_LOGV("SimpleTextTrackEvent cue %p mName %s mTime %lf",
+      mCue.get(), NS_ConvertUTF16toUTF8(mName).get(), mTime);
+    mCue->DispatchTrustedEvent(mName);
+    return NS_OK;
+  }
+
+private:
+  nsString mName;
+  double mTime;
+  TextTrack* mTrack;
+  RefPtr<TextTrackCue> mCue;
+};
+
+class CompareSimpleTextTrackEvents {
+private:
+  int32_t TrackChildPosition(SimpleTextTrackEvent* aEvent) const
+  {
+    if (aEvent->mTrack) {
+      HTMLTrackElement* trackElement = aEvent->mTrack->GetTrackElement();
+      if (trackElement) {
+        return mMediaElement->IndexOf(trackElement);
+      }
+    }
+    return -1;
+  }
+  HTMLMediaElement* mMediaElement;
+public:
+  explicit CompareSimpleTextTrackEvents(HTMLMediaElement* aMediaElement)
+  {
+    mMediaElement = aMediaElement;
+  }
+
+  bool Equals(SimpleTextTrackEvent* aOne, SimpleTextTrackEvent* aTwo) const
+  {
+    return false;
+  }
+
+  bool LessThan(SimpleTextTrackEvent* aOne, SimpleTextTrackEvent* aTwo) const
+  {
+    if (aOne->mTime < aTwo->mTime) {
+      return true;
+    } else if (aOne->mTime > aTwo->mTime) {
+      return false;
+    }
+
+    int32_t positionOne = TrackChildPosition(aOne);
+    int32_t positionTwo = TrackChildPosition(aTwo);
+    if (positionOne < positionTwo) {
+      return true;
+    } else if (positionOne > positionTwo) {
+      return false;
+    }
+
+    if (aOne->mName.EqualsLiteral("enter") ||
+        aTwo->mName.EqualsLiteral("exit")) {
+      return true;
+    }
+    return false;
+  }
+};
+
+class TextTrackListInternal
+{
+public:
+  void AddTextTrack(TextTrack* aTextTrack,
+                    const CompareTextTracks& aCompareTT)
+  {
+    if (!mTextTracks.Contains(aTextTrack)) {
+      mTextTracks.InsertElementSorted(aTextTrack, aCompareTT);
+    }
+  }
+  uint32_t Length() const
+  {
+    return mTextTracks.Length();
+  }
+  TextTrack* operator[](uint32_t aIndex)
+  {
+    return mTextTracks.SafeElementAt(aIndex, nullptr);
+  }
+private:
+  nsTArray<RefPtr<TextTrack>> mTextTracks;
+};
+
+void
+TextTrackManager::DispatchUpdateCueDisplay()
+{
+  if (!mUpdateCueDisplayDispatched && !mShutdown &&
+      (mMediaElement->GetHasUserInteraction() || mMediaElement->IsCurrentlyPlaying())) {
+    WEBVTT_LOG("DispatchUpdateCueDisplay");
+    NS_DispatchToMainThread(NewRunnableMethod(this, &TextTrackManager::UpdateCueDisplay));
+    mUpdateCueDisplayDispatched = true;
+  }
+}
+
+void
+TextTrackManager::DispatchTimeMarchesOn()
+{
+  // Run the algorithm if no previous instance is still running, otherwise
+  // enqueue the current playback position and whether only that changed
+  // through its usual monotonic increase during normal playback; current
+  // executing call upon completion will check queue for further 'work'.
+  if (!mTimeMarchesOnDispatched && !mShutdown &&
+      (mMediaElement->GetHasUserInteraction() || mMediaElement->IsCurrentlyPlaying())) {
+    WEBVTT_LOG("DispatchTimeMarchesOn");
+    NS_DispatchToMainThread(NewRunnableMethod(this, &TextTrackManager::TimeMarchesOn));
+    mTimeMarchesOnDispatched = true;
+  }
+}
+
+// https://html.spec.whatwg.org/multipage/embedded-content.html#time-marches-on
+void
+TextTrackManager::TimeMarchesOn()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+  WEBVTT_LOG("TimeMarchesOn");
+  mTimeMarchesOnDispatched = false;
+
+  // Early return if we don't have any TextTracks or shutting down.
+  if (!mTextTracks || mTextTracks->Length() == 0 || mShutdown) {
+    return;
+  }
+
+  nsISupports* parentObject =
+    mMediaElement->OwnerDoc()->GetParentObject();
+  if (NS_WARN_IF(!parentObject)) {
+    return;
+  }
+  nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(parentObject);
+
+  if (mMediaElement &&
+      (!(mMediaElement->GetPlayedOrSeeked()) || mMediaElement->Seeking())) {
+    WEBVTT_LOG("TimeMarchesOn seeking or post return");
+    return;
+  }
+
+  // Step 3.
+  double currentPlaybackTime = mMediaElement->CurrentTime();
+  bool hasNormalPlayback = !mHasSeeked;
+  mHasSeeked = false;
+  WEBVTT_LOG("TimeMarchesOn mLastTimeMarchesOnCalled %lf currentPlaybackTime %lf hasNormalPlayback %d"
+      , mLastTimeMarchesOnCalled, currentPlaybackTime, hasNormalPlayback);
+
+  // Step 1, 2.
+  RefPtr<TextTrackCueList> currentCues =
+    new TextTrackCueList(window);
+  RefPtr<TextTrackCueList> otherCues =
+    new TextTrackCueList(window);
+  bool dummy;
+  for (uint32_t index = 0; index < mTextTracks->Length(); ++index) {
+    TextTrack* ttrack = mTextTracks->IndexedGetter(index, dummy);
+    if (ttrack && dummy) {
+      // TODO: call GetCueListByTimeInterval on mNewCues?
+      ttrack->UpdateActiveCueList();
+      TextTrackCueList* activeCueList = ttrack->GetActiveCues();
+      if (activeCueList) {
+        for (uint32_t i = 0; i < activeCueList->Length(); ++i) {
+          currentCues->AddCue(*((*activeCueList)[i]));
+        }
+      }
+    }
+  }
+  WEBVTT_LOGV("TimeMarchesOn currentCues %d", currentCues->Length());
+  // Populate otherCues with 'non-active" cues.
+  if (hasNormalPlayback) {
+    if (currentPlaybackTime < mLastTimeMarchesOnCalled) {
+      // TODO: Add log and find the root cause why the
+      // playback position goes backward.
+      mLastTimeMarchesOnCalled = currentPlaybackTime;
+    }
+    media::Interval<double> interval(mLastTimeMarchesOnCalled,
+                                     currentPlaybackTime);
+    otherCues = mNewCues->GetCueListByTimeInterval(interval);;
+  } else {
+    // Seek case. Put the mLastActiveCues into otherCues.
+    otherCues = mLastActiveCues;
+  }
+  for (uint32_t i = 0; i < currentCues->Length(); ++i) {
+    TextTrackCue* cue = (*currentCues)[i];
+    otherCues->RemoveCue(*cue);
+  }
+  WEBVTT_LOGV("TimeMarchesOn otherCues %d", otherCues->Length());
+  // Step 4.
+  RefPtr<TextTrackCueList> missedCues = new TextTrackCueList(window);
+  if (hasNormalPlayback) {
+    for (uint32_t i = 0; i < otherCues->Length(); ++i) {
+      TextTrackCue* cue = (*otherCues)[i];
+      if (cue->StartTime() >= mLastTimeMarchesOnCalled &&
+          cue->EndTime() <= currentPlaybackTime) {
+        missedCues->AddCue(*cue);
+      }
+    }
+  }
+  WEBVTT_LOGV("TimeMarchesOn missedCues %d", missedCues->Length());
+  // Step 5. Empty now.
+  // TODO: Step 6: fire timeupdate?
+
+  // Step 7. Abort steps if condition 1, 2, 3 are satisfied.
+  // 1. All of the cues in current cues have their active flag set.
+  // 2. None of the cues in other cues have their active flag set.
+  // 3. Missed cues is empty.
+  bool c1 = true;
+  for (uint32_t i = 0; i < currentCues->Length(); ++i) {
+    if (!(*currentCues)[i]->GetActive()) {
+      c1 = false;
+      break;
+    }
+  }
+  bool c2 = true;
+  for (uint32_t i = 0; i < otherCues->Length(); ++i) {
+    if ((*otherCues)[i]->GetActive()) {
+      c2 = false;
+      break;
+    }
+  }
+  bool c3 = (missedCues->Length() == 0);
+  if (c1 && c2 && c3) {
+    mLastTimeMarchesOnCalled = currentPlaybackTime;
+    WEBVTT_LOG("TimeMarchesOn step 7 return, mLastTimeMarchesOnCalled %lf", mLastTimeMarchesOnCalled);
+    return;
+  }
+
+  // Step 8. Respect PauseOnExit flag if not seek.
+  if (hasNormalPlayback) {
+    for (uint32_t i = 0; i < otherCues->Length(); ++i) {
+      TextTrackCue* cue = (*otherCues)[i];
+      if (cue && cue->PauseOnExit() && cue->GetActive()) {
+        WEBVTT_LOG("TimeMarchesOn pause the MediaElement");
+        mMediaElement->Pause();
+        break;
+      }
+    }
+    for (uint32_t i = 0; i < missedCues->Length(); ++i) {
+      TextTrackCue* cue = (*missedCues)[i];
+      if (cue && cue->PauseOnExit()) {
+        WEBVTT_LOG("TimeMarchesOn pause the MediaElement");
+        mMediaElement->Pause();
+        break;
+      }
+    }
+  }
+
+  // Step 15.
+  // Sort text tracks in the same order as the text tracks appear
+  // in the media element's list of text tracks, and remove
+  // duplicates.
+  TextTrackListInternal affectedTracks;
+  // Step 13, 14.
+  nsTArray<RefPtr<SimpleTextTrackEvent>> eventList;
+  // Step 9, 10.
+  // For each text track cue in missed cues, prepare an event named
+  // enter for the TextTrackCue object with the cue start time.
+  for (uint32_t i = 0; i < missedCues->Length(); ++i) {
+    TextTrackCue* cue = (*missedCues)[i];
+    if (cue) {
+      SimpleTextTrackEvent* event =
+        new SimpleTextTrackEvent(NS_LITERAL_STRING("enter"),
+                                 cue->StartTime(), cue->GetTrack(),
+                                 cue);
+      eventList.InsertElementSorted(event,
+        CompareSimpleTextTrackEvents(mMediaElement));
+      affectedTracks.AddTextTrack(cue->GetTrack(), CompareTextTracks(mMediaElement));
+    }
+  }
+
+  // Step 11, 17.
+  for (uint32_t i = 0; i < otherCues->Length(); ++i) {
+    TextTrackCue* cue = (*otherCues)[i];
+    if (cue->GetActive() || missedCues->IsCueExist(cue)) {
+      double time = cue->StartTime() > cue->EndTime() ? cue->StartTime()
+                                                      : cue->EndTime();
+      SimpleTextTrackEvent* event =
+        new SimpleTextTrackEvent(NS_LITERAL_STRING("exit"), time,
+                                 cue->GetTrack(), cue);
+      eventList.InsertElementSorted(event,
+        CompareSimpleTextTrackEvents(mMediaElement));
+      affectedTracks.AddTextTrack(cue->GetTrack(), CompareTextTracks(mMediaElement));
+    }
+    cue->SetActive(false);
+  }
+
+  // Step 12, 17.
+  for (uint32_t i = 0; i < currentCues->Length(); ++i) {
+    TextTrackCue* cue = (*currentCues)[i];
+    if (!cue->GetActive()) {
+      SimpleTextTrackEvent* event =
+        new SimpleTextTrackEvent(NS_LITERAL_STRING("enter"),
+                                 cue->StartTime(), cue->GetTrack(),
+                                 cue);
+      eventList.InsertElementSorted(event,
+        CompareSimpleTextTrackEvents(mMediaElement));
+      affectedTracks.AddTextTrack(cue->GetTrack(), CompareTextTracks(mMediaElement));
+    }
+    cue->SetActive(true);
+  }
+
+  // Fire the eventList
+  for (uint32_t i = 0; i < eventList.Length(); ++i) {
+    NS_DispatchToMainThread(eventList[i].forget());
+  }
+
+  // Step 16.
+  for (uint32_t i = 0; i < affectedTracks.Length(); ++i) {
+    TextTrack* ttrack = affectedTracks[i];
+    if (ttrack) {
+      ttrack->DispatchAsyncTrustedEvent(NS_LITERAL_STRING("cuechange"));
+      HTMLTrackElement* trackElement = ttrack->GetTrackElement();
+      if (trackElement) {
+        trackElement->DispatchTrackRunnable(NS_LITERAL_STRING("cuechange"));
+      }
+    }
+  }
+
+  mLastTimeMarchesOnCalled = currentPlaybackTime;
+  mLastActiveCues = currentCues;
+
+  // Step 18.
+  UpdateCueDisplay();
+}
+
+void
+TextTrackManager::NotifyCueUpdated(TextTrackCue *aCue)
+{
+  // TODO: Add/Reorder the cue to mNewCues if we have some optimization?
+  WEBVTT_LOG("NotifyCueUpdated");
+  DispatchTimeMarchesOn();
+}
+
+void
+TextTrackManager::NotifyReset()
+{
+  WEBVTT_LOG("NotifyReset");
+  mLastTimeMarchesOnCalled = 0.0;
+}
+
+void
+TextTrackManager::ReportTelemetryForTrack(TextTrack* aTextTrack) const
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aTextTrack);
+  MOZ_ASSERT(mTextTracks->Length() > 0);
+
+  TextTrackKind kind = aTextTrack->Kind();
+  Telemetry::Accumulate(Telemetry::WEBVTT_TRACK_KINDS, uint32_t(kind));
+}
+
+void
+TextTrackManager::ReportTelemetryForCue()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!mNewCues->IsEmpty() || !mLastActiveCues->IsEmpty());
+
+  if (!mCueTelemetryReported) {
+    Telemetry::Accumulate(Telemetry::WEBVTT_USED_VTT_CUES, 1);
+    mCueTelemetryReported = true;
+  }
+}
+
+} // namespace dom
+} // namespace mozilla