/* -*- 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 "MediaDecoder.h"

#include "ImageContainer.h"

#include "Layers.h"

#include "MediaDecoderStateMachine.h"

#include "MediaFormatReader.h"

#include "MediaResource.h"

#include "MediaShutdownManager.h"

#include "VideoFrameContainer.h"

#include "VideoUtils.h"

#include "mozilla/AbstractThread.h"

#include "mozilla/FloatingPoint.h"

#include "mozilla/MathAlgorithms.h"

#include "mozilla/Preferences.h"

#include "mozilla/StaticPrefs.h"

#include "mozilla/StaticPtr.h"

#include "mozilla/Telemetry.h"

#include "Visibility.h"

#include "mozilla/Unused.h"

#include "nsComponentManagerUtils.h"

#include "nsContentUtils.h"

#include "nsError.h"

#include "nsIMemoryReporter.h"

#include "nsIObserver.h"

#include "nsPrintfCString.h"

#include "nsTArray.h"

#include <algorithm>

#include <limits>

using namespace mozilla::dom;

using namespace mozilla::layers;

using namespace mozilla::media;

namespace mozilla {

// GetCurrentTime is defined in winbase.h as zero argument macro forwarding to

// GetTickCount() and conflicts with MediaDecoder::GetCurrentTime implementation.

#ifdef GetCurrentTime

#undef GetCurrentTime

#endif

// avoid redefined macro in unified build

#undef LOG

#undef DUMP

LazyLogModule gMediaDecoderLog("MediaDecoder");

#define LOG(x, ...)                                                            \

  DDMOZ_LOG(gMediaDecoderLog, LogLevel::Debug, x, ##__VA_ARGS__)

#define DUMP(x, ...) printf_stderr(x "\n", ##__VA_ARGS__)

#define NS_DispatchToMainThread(...) CompileError_UseAbstractMainThreadInstead

static const char*

ToPlayStateStr(MediaDecoder::PlayState aState)

{

  switch (aState) {

    case MediaDecoder::PLAY_STATE_START:    return "START";

    case MediaDecoder::PLAY_STATE_LOADING:  return "LOADING";

    case MediaDecoder::PLAY_STATE_PAUSED:   return "PAUSED";

    case MediaDecoder::PLAY_STATE_PLAYING:  return "PLAYING";

    case MediaDecoder::PLAY_STATE_ENDED:    return "ENDED";

    case MediaDecoder::PLAY_STATE_SHUTDOWN: return "SHUTDOWN";

    default: MOZ_ASSERT_UNREACHABLE("Invalid playState.");

  }

  return "UNKNOWN";

}

class MediaMemoryTracker : public nsIMemoryReporter

{

  virtual ~MediaMemoryTracker();

  NS_DECL_THREADSAFE_ISUPPORTS

  NS_DECL_NSIMEMORYREPORTER

  MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf);

  MediaMemoryTracker();

  void InitMemoryReporter();

  static StaticRefPtr<MediaMemoryTracker> sUniqueInstance;

  static MediaMemoryTracker* UniqueInstance()

  {

    if (!sUniqueInstance) {

      sUniqueInstance = new MediaMemoryTracker();

      sUniqueInstance->InitMemoryReporter();

    }

    return sUniqueInstance;

  }

  typedef nsTArray<MediaDecoder*> DecodersArray;

  static DecodersArray& Decoders()

  {

    return UniqueInstance()->mDecoders;

  }

  DecodersArray mDecoders;

public:

  static void AddMediaDecoder(MediaDecoder* aDecoder)

  {

    Decoders().AppendElement(aDecoder);

  }

  static void RemoveMediaDecoder(MediaDecoder* aDecoder)

  {

    DecodersArray& decoders = Decoders();

    decoders.RemoveElement(aDecoder);

    if (decoders.IsEmpty()) {

      sUniqueInstance = nullptr;

    }

  }

};

StaticRefPtr<MediaMemoryTracker> MediaMemoryTracker::sUniqueInstance;

LazyLogModule gMediaTimerLog("MediaTimer");

constexpr TimeUnit MediaDecoder::DEFAULT_NEXT_FRAME_AVAILABLE_BUFFERED;

void

MediaDecoder::InitStatics()

{

  MOZ_ASSERT(NS_IsMainThread());

  // Eagerly init gMediaDecoderLog to work around bug 1415441.

  MOZ_LOG(gMediaDecoderLog, LogLevel::Info, ("MediaDecoder::InitStatics"));

}

NS_IMPL_ISUPPORTS(MediaMemoryTracker, nsIMemoryReporter)

void

MediaDecoder::NotifyOwnerActivityChanged(bool aIsDocumentVisible,

                                         Visibility aElementVisibility,

                                         bool aIsElementInTree)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  AbstractThread::AutoEnter context(AbstractMainThread());

  SetElementVisibility(aIsDocumentVisible, aElementVisibility, aIsElementInTree);

  NotifyCompositor();

}

void

MediaDecoder::Pause()

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  AbstractThread::AutoEnter context(AbstractMainThread());

  if (mPlayState == PLAY_STATE_LOADING || IsEnded()) {

    mNextState = PLAY_STATE_PAUSED;

    return;

  }

  ChangeState(PLAY_STATE_PAUSED);

}

void

MediaDecoder::SetVolume(double aVolume)

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  mVolume = aVolume;

}

void

MediaDecoder::AddOutputStream(ProcessedMediaStream* aStream,

                              TrackID aNextAvailableTrackID,

                              bool aFinishWhenEnded)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_ASSERT(mDecoderStateMachine, "Must be called after Load().");

  AbstractThread::AutoEnter context(AbstractMainThread());

  mDecoderStateMachine->AddOutputStream(

    aStream, aNextAvailableTrackID, aFinishWhenEnded);

}

void

MediaDecoder::RemoveOutputStream(MediaStream* aStream)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_ASSERT(mDecoderStateMachine, "Must be called after Load().");

  AbstractThread::AutoEnter context(AbstractMainThread());

  mDecoderStateMachine->RemoveOutputStream(aStream);

}

TrackID

MediaDecoder::NextAvailableTrackIDFor(MediaStream* aOutputStream) const

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_ASSERT(mDecoderStateMachine, "Must be called after Load().");

  AbstractThread::AutoEnter context(AbstractMainThread());

  return mDecoderStateMachine->NextAvailableTrackIDFor(aOutputStream);

}

double

MediaDecoder::GetDuration()

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  return mDuration;

}

bool

MediaDecoder::IsInfinite() const

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  return mozilla::IsInfinite<double>(mDuration);

}

#define INIT_MIRROR(name, val) \

  name(mOwner->AbstractMainThread(), val, "MediaDecoder::" #name " (Mirror)")

#define INIT_CANONICAL(name, val) \

  name(mOwner->AbstractMainThread(), val, "MediaDecoder::" #name " (Canonical)")

MediaDecoder::MediaDecoder(MediaDecoderInit& aInit)

  : mWatchManager(this, aInit.mOwner->AbstractMainThread())

  , mLogicalPosition(0.0)

  , mDuration(std::numeric_limits<double>::quiet_NaN())

  , mOwner(aInit.mOwner)

  , mAbstractMainThread(aInit.mOwner->AbstractMainThread())

  , mFrameStats(new FrameStatistics())

  , mVideoFrameContainer(aInit.mOwner->GetVideoFrameContainer())

  , mMinimizePreroll(aInit.mMinimizePreroll)

  , mFiredMetadataLoaded(false)

  , mIsDocumentVisible(false)

  , mElementVisibility(Visibility::UNTRACKED)

  , mIsElementInTree(false)

  , mForcedHidden(false)

  , mHasSuspendTaint(aInit.mHasSuspendTaint)

  , mPlaybackRate(aInit.mPlaybackRate)

  , INIT_MIRROR(mBuffered, TimeIntervals())

  , INIT_MIRROR(mCurrentPosition, TimeUnit::Zero())

  , INIT_MIRROR(mStateMachineDuration, NullableTimeUnit())

  , INIT_MIRROR(mIsAudioDataAudible, false)

  , INIT_CANONICAL(mVolume, aInit.mVolume)

  , INIT_CANONICAL(mPreservesPitch, aInit.mPreservesPitch)

  , INIT_CANONICAL(mLooping, aInit.mLooping)

  , INIT_CANONICAL(mPlayState, PLAY_STATE_LOADING)

  , INIT_CANONICAL(mLogicallySeeking, false)

  , INIT_CANONICAL(mSameOriginMedia, false)

  , INIT_CANONICAL(mMediaPrincipalHandle, PRINCIPAL_HANDLE_NONE)

  , mVideoDecodingOberver(new BackgroundVideoDecodingPermissionObserver(this))

  , mIsBackgroundVideoDecodingAllowed(false)

  , mTelemetryReported(false)

  , mContainerType(aInit.mContainerType)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_ASSERT(mAbstractMainThread);

  MediaMemoryTracker::AddMediaDecoder(this);

  //

  // Initialize watchers.

  //

  // mDuration

  mWatchManager.Watch(mStateMachineDuration, &MediaDecoder::DurationChanged);

  // readyState

  mWatchManager.Watch(mPlayState, &MediaDecoder::UpdateReadyState);

  // ReadyState computation depends on MediaDecoder::CanPlayThrough, which

  // depends on the download rate.

  mWatchManager.Watch(mBuffered, &MediaDecoder::UpdateReadyState);

  // mLogicalPosition

  mWatchManager.Watch(mCurrentPosition, &MediaDecoder::UpdateLogicalPosition);

  mWatchManager.Watch(mPlayState, &MediaDecoder::UpdateLogicalPosition);

  mWatchManager.Watch(mLogicallySeeking, &MediaDecoder::UpdateLogicalPosition);

  mWatchManager.Watch(mIsAudioDataAudible,

                      &MediaDecoder::NotifyAudibleStateChanged);

  MediaShutdownManager::InitStatics();

  mVideoDecodingOberver->RegisterEvent();

}

#undef INIT_MIRROR

#undef INIT_CANONICAL

void

MediaDecoder::Shutdown()

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  AbstractThread::AutoEnter context(AbstractMainThread());

  // Unwatch all watch targets to prevent further notifications.

  mWatchManager.Shutdown();

  DiscardOngoingSeekIfExists();

  // This changes the decoder state to SHUTDOWN and does other things

  // necessary to unblock the state machine thread if it's blocked, so

  // the asynchronous shutdown in nsDestroyStateMachine won't deadlock.

  if (mDecoderStateMachine) {

    mTimedMetadataListener.Disconnect();

    mMetadataLoadedListener.Disconnect();

    mFirstFrameLoadedListener.Disconnect();

    mOnPlaybackEvent.Disconnect();

    mOnPlaybackErrorEvent.Disconnect();

    mOnDecoderDoctorEvent.Disconnect();

    mOnMediaNotSeekable.Disconnect();

    mOnEncrypted.Disconnect();

    mOnWaitingForKey.Disconnect();

    mOnDecodeWarning.Disconnect();

    mOnNextFrameStatus.Disconnect();

    mDecoderStateMachine->BeginShutdown()

      ->Then(mAbstractMainThread, __func__, this,

             &MediaDecoder::FinishShutdown,

             &MediaDecoder::FinishShutdown);

  } else {

    // Ensure we always unregister asynchronously in order not to disrupt

    // the hashtable iterating in MediaShutdownManager::Shutdown().

    RefPtr<MediaDecoder> self = this;

    nsCOMPtr<nsIRunnable> r =

      NS_NewRunnableFunction("MediaDecoder::Shutdown", [self]() {

        self->mVideoFrameContainer = nullptr;

        MediaShutdownManager::Instance().Unregister(self);

      });

    mAbstractMainThread->Dispatch(r.forget());

  }

  // Ask the owner to remove its audio/video tracks.

  GetOwner()->RemoveMediaTracks();

  ChangeState(PLAY_STATE_SHUTDOWN);

  mVideoDecodingOberver->UnregisterEvent();

  mVideoDecodingOberver = nullptr;

  mOwner = nullptr;

}

void

MediaDecoder::NotifyXPCOMShutdown()

{

  MOZ_ASSERT(NS_IsMainThread());

  if (auto owner = GetOwner()) {

    owner->NotifyXPCOMShutdown();

  }

  MOZ_DIAGNOSTIC_ASSERT(IsShutdown());

  // Don't cause grief to release builds by ensuring Shutdown()

  // is always called during shutdown phase.

  if (!IsShutdown()) {

    Shutdown();

  }

}

MediaDecoder::~MediaDecoder()

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(IsShutdown());

  MediaMemoryTracker::RemoveMediaDecoder(this);

}

void

MediaDecoder::OnPlaybackEvent(MediaPlaybackEvent&& aEvent)

{

  switch (aEvent.mType) {

    case MediaPlaybackEvent::PlaybackEnded:

      PlaybackEnded();

      break;

    case MediaPlaybackEvent::SeekStarted:

      SeekingStarted();

      break;

    case MediaPlaybackEvent::Loop:

      GetOwner()->DispatchAsyncEvent(NS_LITERAL_STRING("seeking"));

      GetOwner()->DispatchAsyncEvent(NS_LITERAL_STRING("seeked"));

      break;

    case MediaPlaybackEvent::Invalidate:

      Invalidate();

      break;

    case MediaPlaybackEvent::EnterVideoSuspend:

      GetOwner()->DispatchAsyncEvent(NS_LITERAL_STRING("mozentervideosuspend"));

      break;

    case MediaPlaybackEvent::ExitVideoSuspend:

      GetOwner()->DispatchAsyncEvent(NS_LITERAL_STRING("mozexitvideosuspend"));

      break;

    case MediaPlaybackEvent::StartVideoSuspendTimer:

      GetOwner()->DispatchAsyncEvent(NS_LITERAL_STRING("mozstartvideosuspendtimer"));

      break;

    case MediaPlaybackEvent::CancelVideoSuspendTimer:

      GetOwner()->DispatchAsyncEvent(NS_LITERAL_STRING("mozcancelvideosuspendtimer"));

      break;

    case MediaPlaybackEvent::VideoOnlySeekBegin:

      GetOwner()->DispatchAsyncEvent(NS_LITERAL_STRING("mozvideoonlyseekbegin"));

      break;

    case MediaPlaybackEvent::VideoOnlySeekCompleted:

      GetOwner()->DispatchAsyncEvent(NS_LITERAL_STRING("mozvideoonlyseekcompleted"));

      break;

    default:

      break;

  }

}

void

MediaDecoder::OnPlaybackErrorEvent(const MediaResult& aError)

{

  DecodeError(aError);

}

void

MediaDecoder::OnDecoderDoctorEvent(DecoderDoctorEvent aEvent)

{

  MOZ_ASSERT(NS_IsMainThread());

  // OnDecoderDoctorEvent is disconnected at shutdown time.

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  nsIDocument* doc = GetOwner()->GetDocument();

  if (!doc) {

    return;

  }

  DecoderDoctorDiagnostics diags;

  diags.StoreEvent(doc, aEvent, __func__);

}

static const char*

NextFrameStatusToStr(MediaDecoderOwner::NextFrameStatus aStatus)

{

  switch (aStatus) {

    case MediaDecoderOwner::NEXT_FRAME_AVAILABLE:

      return "NEXT_FRAME_AVAILABLE";

    case MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE:

      return "NEXT_FRAME_UNAVAILABLE";

    case MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_BUFFERING:

      return "NEXT_FRAME_UNAVAILABLE_BUFFERING";

    case MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_SEEKING:

      return "NEXT_FRAME_UNAVAILABLE_SEEKING";

    case MediaDecoderOwner::NEXT_FRAME_UNINITIALIZED:

      return "NEXT_FRAME_UNINITIALIZED";

  }

  return "UNKNOWN";

}

void

MediaDecoder::OnNextFrameStatus(MediaDecoderOwner::NextFrameStatus aStatus)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  if (mNextFrameStatus != aStatus) {

    LOG("Changed mNextFrameStatus to %s", NextFrameStatusToStr(aStatus));

    mNextFrameStatus = aStatus;

    UpdateReadyState();

  }

}

void

MediaDecoder::FinishShutdown()

{

  MOZ_ASSERT(NS_IsMainThread());

  SetStateMachine(nullptr);

  mVideoFrameContainer = nullptr;

  MediaShutdownManager::Instance().Unregister(this);

}

nsresult

MediaDecoder::InitializeStateMachine()

{

  MOZ_ASSERT(NS_IsMainThread());

  NS_ASSERTION(mDecoderStateMachine, "Cannot initialize null state machine!");

  AbstractThread::AutoEnter context(AbstractMainThread());

  nsresult rv = mDecoderStateMachine->Init(this);

  NS_ENSURE_SUCCESS(rv, rv);

  // If some parameters got set before the state machine got created,

  // set them now

  SetStateMachineParameters();

  return NS_OK;

}

void

MediaDecoder::SetStateMachineParameters()

{

  MOZ_ASSERT(NS_IsMainThread());

  if (mPlaybackRate != 1 && mPlaybackRate != 0) {

    mDecoderStateMachine->DispatchSetPlaybackRate(mPlaybackRate);

  }

  mTimedMetadataListener = mDecoderStateMachine->TimedMetadataEvent().Connect(

    mAbstractMainThread, this, &MediaDecoder::OnMetadataUpdate);

  mMetadataLoadedListener = mDecoderStateMachine->MetadataLoadedEvent().Connect(

    mAbstractMainThread, this, &MediaDecoder::MetadataLoaded);

  mFirstFrameLoadedListener =

    mDecoderStateMachine->FirstFrameLoadedEvent().Connect(

      mAbstractMainThread, this, &MediaDecoder::FirstFrameLoaded);

  mOnPlaybackEvent = mDecoderStateMachine->OnPlaybackEvent().Connect(

    mAbstractMainThread, this, &MediaDecoder::OnPlaybackEvent);

  mOnPlaybackErrorEvent = mDecoderStateMachine->OnPlaybackErrorEvent().Connect(

    mAbstractMainThread, this, &MediaDecoder::OnPlaybackErrorEvent);

  mOnDecoderDoctorEvent = mDecoderStateMachine->OnDecoderDoctorEvent().Connect(

    mAbstractMainThread, this, &MediaDecoder::OnDecoderDoctorEvent);

  mOnMediaNotSeekable = mDecoderStateMachine->OnMediaNotSeekable().Connect(

    mAbstractMainThread, this, &MediaDecoder::OnMediaNotSeekable);

  mOnNextFrameStatus = mDecoderStateMachine->OnNextFrameStatus().Connect(

    mAbstractMainThread, this, &MediaDecoder::OnNextFrameStatus);

  mOnEncrypted = mReader->OnEncrypted().Connect(

    mAbstractMainThread, GetOwner(), &MediaDecoderOwner::DispatchEncrypted);

  mOnWaitingForKey = mReader->OnWaitingForKey().Connect(

    mAbstractMainThread, GetOwner(), &MediaDecoderOwner::NotifyWaitingForKey);

  mOnDecodeWarning = mReader->OnDecodeWarning().Connect(

    mAbstractMainThread, GetOwner(), &MediaDecoderOwner::DecodeWarning);

}

void

MediaDecoder::Play()

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  NS_ASSERTION(mDecoderStateMachine != nullptr, "Should have state machine.");

  if (mPlaybackRate == 0) {

    return;

  }

  if (IsEnded()) {

    Seek(0, SeekTarget::PrevSyncPoint);

    return;

  } else if (mPlayState == PLAY_STATE_LOADING) {

    mNextState = PLAY_STATE_PLAYING;

    return;

  }

  ChangeState(PLAY_STATE_PLAYING);

}

void

MediaDecoder::Seek(double aTime, SeekTarget::Type aSeekType)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  AbstractThread::AutoEnter context(AbstractMainThread());

  MOZ_ASSERT(aTime >= 0.0, "Cannot seek to a negative value.");

  int64_t timeUsecs = TimeUnit::FromSeconds(aTime).ToMicroseconds();

  mLogicalPosition = aTime;

  mLogicallySeeking = true;

  SeekTarget target = SeekTarget(timeUsecs, aSeekType);

  CallSeek(target);

  if (mPlayState == PLAY_STATE_ENDED) {

    ChangeState(GetOwner()->GetPaused() ? PLAY_STATE_PAUSED : PLAY_STATE_PLAYING);

  }

}

void

MediaDecoder::DiscardOngoingSeekIfExists()

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  mSeekRequest.DisconnectIfExists();

  GetOwner()->AsyncRejectSeekDOMPromiseIfExists();

}

void

MediaDecoder::CallSeek(const SeekTarget& aTarget)

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  DiscardOngoingSeekIfExists();

  mDecoderStateMachine->InvokeSeek(aTarget)

  ->Then(mAbstractMainThread, __func__, this,

         &MediaDecoder::OnSeekResolved, &MediaDecoder::OnSeekRejected)

  ->Track(mSeekRequest);

}

double

MediaDecoder::GetCurrentTime()

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  return mLogicalPosition;

}

void

MediaDecoder::OnMetadataUpdate(TimedMetadata&& aMetadata)

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  GetOwner()->RemoveMediaTracks();

  MetadataLoaded(MakeUnique<MediaInfo>(*aMetadata.mInfo),

                 UniquePtr<MetadataTags>(aMetadata.mTags.forget()),

                 MediaDecoderEventVisibility::Observable);

  FirstFrameLoaded(std::move(aMetadata.mInfo),

                   MediaDecoderEventVisibility::Observable);

}

void

MediaDecoder::MetadataLoaded(UniquePtr<MediaInfo> aInfo,

                             UniquePtr<MetadataTags> aTags,

                             MediaDecoderEventVisibility aEventVisibility)

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  LOG("MetadataLoaded, channels=%u rate=%u hasAudio=%d hasVideo=%d",

      aInfo->mAudio.mChannels, aInfo->mAudio.mRate,

      aInfo->HasAudio(), aInfo->HasVideo());

  mMediaSeekable = aInfo->mMediaSeekable;

  mMediaSeekableOnlyInBufferedRanges = aInfo->mMediaSeekableOnlyInBufferedRanges;

  mInfo = aInfo.release();

  GetOwner()->ConstructMediaTracks(mInfo);

  // Make sure the element and the frame (if any) are told about

  // our new size.

  if (aEventVisibility != MediaDecoderEventVisibility::Suppressed) {

    mFiredMetadataLoaded = true;

    GetOwner()->MetadataLoaded(mInfo, std::move(aTags));

  }

  // Invalidate() will end up calling GetOwner()->UpdateMediaSize with the last

  // dimensions retrieved from the video frame container. The video frame

  // container contains more up to date dimensions than aInfo.

  // So we call Invalidate() after calling GetOwner()->MetadataLoaded to ensure

  // the media element has the latest dimensions.

  Invalidate();

  EnsureTelemetryReported();

}

void

MediaDecoder::EnsureTelemetryReported()

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  if (mTelemetryReported || !mInfo) {

    // Note: sometimes we get multiple MetadataLoaded calls (for example

    // for chained ogg). So we ensure we don't report duplicate results for

    // these resources.

    return;

  }

  nsTArray<nsCString> codecs;

  if (mInfo->HasAudio() &&

      !mInfo->mAudio.GetAsAudioInfo()->mMimeType.IsEmpty()) {

    codecs.AppendElement(mInfo->mAudio.GetAsAudioInfo()->mMimeType);

  }

  if (mInfo->HasVideo() &&

      !mInfo->mVideo.GetAsVideoInfo()->mMimeType.IsEmpty()) {

    codecs.AppendElement(mInfo->mVideo.GetAsVideoInfo()->mMimeType);

  }

  if (codecs.IsEmpty()) {

    codecs.AppendElement(

      nsPrintfCString("resource; %s", ContainerType().OriginalString().Data()));

  }

  for (const nsCString& codec : codecs) {

    LOG("Telemetry MEDIA_CODEC_USED= '%s'", codec.get());

    Telemetry::Accumulate(Telemetry::HistogramID::MEDIA_CODEC_USED, codec);

  }

  mTelemetryReported = true;

}

const char*

MediaDecoder::PlayStateStr()

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  return ToPlayStateStr(mPlayState);

}

void

MediaDecoder::FirstFrameLoaded(nsAutoPtr<MediaInfo> aInfo,

                               MediaDecoderEventVisibility aEventVisibility)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  AbstractThread::AutoEnter context(AbstractMainThread());

  LOG("FirstFrameLoaded, channels=%u rate=%u hasAudio=%d hasVideo=%d "

      "mPlayState=%s transportSeekable=%d",

      aInfo->mAudio.mChannels, aInfo->mAudio.mRate, aInfo->HasAudio(),

      aInfo->HasVideo(), PlayStateStr(), IsTransportSeekable());

  mInfo = aInfo.forget();

  Invalidate();

  // The element can run javascript via events

  // before reaching here, so only change the

  // state if we're still set to the original

  // loading state.

  if (mPlayState == PLAY_STATE_LOADING) {

    ChangeState(mNextState);

  }

  // GetOwner()->FirstFrameLoaded() might call us back. Put it at the bottom of

  // this function to avoid unexpected shutdown from reentrant calls.

  if (aEventVisibility != MediaDecoderEventVisibility::Suppressed) {

    GetOwner()->FirstFrameLoaded();

  }

}

void

MediaDecoder::NetworkError(const MediaResult& aError)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  GetOwner()->NetworkError(aError);

}

void

MediaDecoder::DecodeError(const MediaResult& aError)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  GetOwner()->DecodeError(aError);

}

void

MediaDecoder::UpdateSameOriginStatus(bool aSameOrigin)

{

  MOZ_ASSERT(NS_IsMainThread());

  AbstractThread::AutoEnter context(AbstractMainThread());

  mSameOriginMedia = aSameOrigin;

}

bool

MediaDecoder::IsSeeking() const

{

  MOZ_ASSERT(NS_IsMainThread());

  return mLogicallySeeking;

}

bool

MediaDecoder::OwnerHasError() const

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  return GetOwner()->HasError();

}

bool

MediaDecoder::IsEnded() const

{

  MOZ_ASSERT(NS_IsMainThread());

  return mPlayState == PLAY_STATE_ENDED;

}

bool

MediaDecoder::IsShutdown() const

{

  MOZ_ASSERT(NS_IsMainThread());

  return mPlayState == PLAY_STATE_SHUTDOWN;

}

void

MediaDecoder::PlaybackEnded()

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  if (mLogicallySeeking || mPlayState == PLAY_STATE_LOADING ||

      mPlayState == PLAY_STATE_ENDED) {

    LOG("MediaDecoder::PlaybackEnded bailed out, "

        "mLogicallySeeking=%d mPlayState=%s",

        mLogicallySeeking.Ref(), ToPlayStateStr(mPlayState));

    return;

  }

  LOG("MediaDecoder::PlaybackEnded");

  ChangeState(PLAY_STATE_ENDED);

  InvalidateWithFlags(VideoFrameContainer::INVALIDATE_FORCE);

  GetOwner()->PlaybackEnded();

}

void

MediaDecoder::NotifyPrincipalChanged()

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  AbstractThread::AutoEnter context(AbstractMainThread());

  nsCOMPtr<nsIPrincipal> newPrincipal = GetCurrentPrincipal();

  mMediaPrincipalHandle = MakePrincipalHandle(newPrincipal);

  GetOwner()->NotifyDecoderPrincipalChanged();

}

void

MediaDecoder::OnSeekResolved()

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  AbstractThread::AutoEnter context(AbstractMainThread());

  mSeekRequest.Complete();

  mLogicallySeeking = false;

  // Ensure logical position is updated after seek.

  UpdateLogicalPositionInternal();

  GetOwner()->SeekCompleted();

  GetOwner()->AsyncResolveSeekDOMPromiseIfExists();

}

void

MediaDecoder::OnSeekRejected()

{

  MOZ_ASSERT(NS_IsMainThread());

  mSeekRequest.Complete();

  mLogicallySeeking = false;

  GetOwner()->AsyncRejectSeekDOMPromiseIfExists();

}

void

MediaDecoder::SeekingStarted()

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  GetOwner()->SeekStarted();

}

void

MediaDecoder::ChangeState(PlayState aState)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_ASSERT(!IsShutdown(), "SHUTDOWN is the final state.");

  AbstractThread::AutoEnter context(AbstractMainThread());

  if (mNextState == aState) {

    mNextState = PLAY_STATE_PAUSED;

  }

  if (mPlayState != aState) {

    DDLOG(DDLogCategory::Property, "play_state", ToPlayStateStr(aState));

  }

  mPlayState = aState;

  if (mPlayState == PLAY_STATE_PLAYING) {

    GetOwner()->ConstructMediaTracks(mInfo);

  } else if (IsEnded()) {

    GetOwner()->RemoveMediaTracks();

  }

}

void

MediaDecoder::UpdateLogicalPositionInternal()

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  double currentPosition = CurrentPosition().ToSeconds();

  if (mPlayState == PLAY_STATE_ENDED) {

    currentPosition = std::max(currentPosition, mDuration);

  }

  bool logicalPositionChanged = mLogicalPosition != currentPosition;

  mLogicalPosition = currentPosition;

  DDLOG(DDLogCategory::Property, "currentTime", mLogicalPosition);

  // Invalidate the frame so any video data is displayed.

  // Do this before the timeupdate event so that if that

  // event runs JavaScript that queries the media size, the

  // frame has reflowed and the size updated beforehand.

  Invalidate();

  if (logicalPositionChanged) {

    FireTimeUpdate();

  }

}

void

MediaDecoder::DurationChanged()

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());

  AbstractThread::AutoEnter context(AbstractMainThread());

  double oldDuration = mDuration;

  // Use the explicit duration if we have one.

  // Otherwise use the duration mirrored from MDSM.

  if (mExplicitDuration.isSome()) {

    mDuration = mExplicitDuration.ref();

  } else if (mStateMachineDuration.Ref().isSome()) {

    mDuration = mStateMachineDuration.Ref().ref().ToSeconds();

  }

  if (mDuration == oldDuration || IsNaN(mDuration)) {

    return;

  }

  LOG("Duration changed to %f", mDuration);

  // See https://www.w3.org/Bugs/Public/show_bug.cgi?id=28822 for a discussion

  // of whether we should fire durationchange on explicit infinity.

  if (mFiredMetadataLoaded &&

      (!mozilla::IsInfinite<double>(mDuration) || mExplicitDuration.isSome())) {

    GetOwner()->DispatchAsyncEvent(NS_LITERAL_STRING("durationchange"));

  }

  if (CurrentPosition() > TimeUnit::FromSeconds(mDuration)) {