gecko-dev/dom/media/TextTrackList.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/TextTrackList.h"

#include "mozilla/DebugOnly.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/TextTrackListBinding.h"
#include "mozilla/dom/TrackEvent.h"
#include "nsThreadUtils.h"
#include "nsGlobalWindow.h"
#include "mozilla/dom/TextTrackCue.h"
#include "mozilla/dom/TextTrackManager.h"

namespace mozilla {
namespace dom {

NS_IMPL_CYCLE_COLLECTION_INHERITED(TextTrackList,
                                   DOMEventTargetHelper,
                                   mTextTracks,
                                   mTextTrackManager)

NS_IMPL_ADDREF_INHERITED(TextTrackList, DOMEventTargetHelper)
NS_IMPL_RELEASE_INHERITED(TextTrackList, DOMEventTargetHelper)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TextTrackList)
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)

TextTrackList::TextTrackList(nsPIDOMWindowInner* aOwnerWindow)
  : DOMEventTargetHelper(aOwnerWindow)
{
}

TextTrackList::TextTrackList(nsPIDOMWindowInner* aOwnerWindow,
                             TextTrackManager* aTextTrackManager)
  : DOMEventTargetHelper(aOwnerWindow)
  , mTextTrackManager(aTextTrackManager)
{
}

TextTrackList::~TextTrackList()
{
}

void
TextTrackList::GetShowingCues(nsTArray<RefPtr<TextTrackCue> >& aCues)
{
  // Only Subtitles and Captions can show on the screen.
  nsTArray< RefPtr<TextTrackCue> > cues;
  for (uint32_t i = 0; i < Length(); i++) {
    if (mTextTracks[i]->Mode() == TextTrackMode::Showing &&
        (mTextTracks[i]->Kind() == TextTrackKind::Subtitles ||
         mTextTracks[i]->Kind() == TextTrackKind::Captions)) {
      mTextTracks[i]->GetActiveCueArray(cues);
      aCues.AppendElements(cues);
    }
  }
}

JSObject*
TextTrackList::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
  return TextTrackList_Binding::Wrap(aCx, this, aGivenProto);
}

TextTrack*
TextTrackList::IndexedGetter(uint32_t aIndex, bool& aFound)
{
  aFound = aIndex < mTextTracks.Length();
  if (!aFound) {
    return nullptr;
  }
  return mTextTracks[aIndex];
}

TextTrack*
TextTrackList::operator[](uint32_t aIndex)
{
  return mTextTracks.SafeElementAt(aIndex, nullptr);
}

already_AddRefed<TextTrack>
TextTrackList::AddTextTrack(TextTrackKind aKind,
                            const nsAString& aLabel,
                            const nsAString& aLanguage,
                            TextTrackMode aMode,
                            TextTrackReadyState aReadyState,
                            TextTrackSource aTextTrackSource,
                            const CompareTextTracks& aCompareTT)
{
  RefPtr<TextTrack> track = new TextTrack(GetOwner(), this, aKind, aLabel,
                                            aLanguage, aMode, aReadyState,
                                            aTextTrackSource);
  AddTextTrack(track, aCompareTT);
  return track.forget();
}

void
TextTrackList::AddTextTrack(TextTrack* aTextTrack,
                            const CompareTextTracks& aCompareTT)
{
  if (mTextTracks.Contains(aTextTrack)) {
    return;
  }
  if (mTextTracks.InsertElementSorted(aTextTrack, aCompareTT)) {
    aTextTrack->SetTextTrackList(this);
    CreateAndDispatchTrackEventRunner(aTextTrack, NS_LITERAL_STRING("addtrack"));
  }
}

TextTrack*
TextTrackList::GetTrackById(const nsAString& aId)
{
  nsAutoString id;
  for (uint32_t i = 0; i < Length(); i++) {
    mTextTracks[i]->GetId(id);
    if (aId.Equals(id)) {
      return mTextTracks[i];
    }
  }
  return nullptr;
}

void
TextTrackList::RemoveTextTrack(TextTrack* aTrack)
{
  if (mTextTracks.RemoveElement(aTrack)) {
    CreateAndDispatchTrackEventRunner(aTrack, NS_LITERAL_STRING("removetrack"));
  }
}

void
TextTrackList::DidSeek()
{
  for (uint32_t i = 0; i < mTextTracks.Length(); i++) {
    mTextTracks[i]->SetDirty();
  }
}

class TrackEventRunner : public Runnable
{
public:
  TrackEventRunner(TextTrackList* aList, Event* aEvent)
    : Runnable("dom::TrackEventRunner")
    , mList(aList)
    , mEvent(aEvent)
  {}

  NS_IMETHOD Run() override
  {
    return mList->DispatchTrackEvent(mEvent);
  }

  RefPtr<TextTrackList> mList;
private:
  RefPtr<Event> mEvent;
};

class ChangeEventRunner final : public TrackEventRunner
{
public:
  ChangeEventRunner(TextTrackList* aList, Event* aEvent)
    : TrackEventRunner(aList, aEvent)
  {}

  NS_IMETHOD Run() override
  {
    mList->mPendingTextTrackChange = false;
    return TrackEventRunner::Run();
  }
};

nsresult
TextTrackList::DispatchTrackEvent(Event* aEvent)
{
  return DispatchTrustedEvent(aEvent);
}

void
TextTrackList::CreateAndDispatchChangeEvent()
{
  MOZ_ASSERT(NS_IsMainThread());
  if (!mPendingTextTrackChange) {
    nsPIDOMWindowInner* win = GetOwner();
    if (!win) {
      return;
    }

    mPendingTextTrackChange = true;
    RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);

    event->InitEvent(NS_LITERAL_STRING("change"), false, false);
    event->SetTrusted(true);

    nsCOMPtr<nsIRunnable> eventRunner = new ChangeEventRunner(this, event);
    nsGlobalWindowInner::Cast(win)->Dispatch(TaskCategory::Other, eventRunner.forget());
  }
}

void
TextTrackList::CreateAndDispatchTrackEventRunner(TextTrack* aTrack,
                                                 const nsAString& aEventName)
{
  DebugOnly<nsresult> rv;
  nsCOMPtr<nsIEventTarget> target = GetMainThreadEventTarget();
  if (!target) {
    // If we are not able to get the main-thread object we are shutting down.
    return;
  }

  TrackEventInit eventInit;
  eventInit.mTrack.SetValue().SetAsTextTrack() = aTrack;
  RefPtr<TrackEvent> event =
    TrackEvent::Constructor(this, aEventName, eventInit);

  // Dispatch the TrackEvent asynchronously.
  rv = target->Dispatch(do_AddRef(new TrackEventRunner(this, event)),
                        NS_DISPATCH_NORMAL);

  // If we are shutting down this can file but it's still ok.
  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Dispatch failed");
}

HTMLMediaElement*
TextTrackList::GetMediaElement()
{
  if (mTextTrackManager) {
    return mTextTrackManager->mMediaElement;
  }
  return nullptr;
}

void
TextTrackList::SetTextTrackManager(TextTrackManager* aTextTrackManager)
{
  mTextTrackManager = aTextTrackManager;
}

void
TextTrackList::SetCuesInactive()
{
  for (uint32_t i = 0; i < Length(); i++) {
    mTextTracks[i]->SetCuesInactive();
  }
}


bool TextTrackList::AreTextTracksLoaded()
{
  // Return false if any texttrack is not loaded.
  for (uint32_t i = 0; i < Length(); i++) {
    if (!mTextTracks[i]->IsLoaded()) {
      return false;
    }
  }
  return true;
}

nsTArray<RefPtr<TextTrack>>&
TextTrackList::GetTextTrackArray()
{
  return mTextTracks;
}

} // namespace dom
} // namespace mozilla