DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Header

Mercurial (21feee30ec61)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
/* -*- 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 "RemoteMediaDataDecoder.h"

#include "base/thread.h"

#include "IRemoteDecoderChild.h"

namespace mozilla {

using base::Thread;

RemoteMediaDataDecoder::RemoteMediaDataDecoder(
    IRemoteDecoderChild* aChild, nsIThread* aManagerThread,
    AbstractThread* aAbstractManagerThread)
    : mChild(aChild),
      mManagerThread(aManagerThread),
      mAbstractManagerThread(aAbstractManagerThread) {}

RemoteMediaDataDecoder::~RemoteMediaDataDecoder() {
  /* Shutdown method should have been called. */
  MOZ_ASSERT(!mChild);
}

RefPtr<MediaDataDecoder::InitPromise> RemoteMediaDataDecoder::Init() {
  RefPtr<RemoteMediaDataDecoder> self = this;
  return InvokeAsync(mAbstractManagerThread, __func__,
                     [self]() { return self->mChild->Init(); })
      ->Then(
          mAbstractManagerThread, __func__,
          [self, this](TrackType aTrack) {
            // If shutdown has started in the meantime shutdown promise may
            // be resloved before this task. In this case mChild will be null
            // and the init promise has to be canceled.
            if (!mChild) {
              return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_CANCELED,
                                                  __func__);
            }
            mDescription =
                mChild->GetDescriptionName() + NS_LITERAL_CSTRING(" (remote)");
            mIsHardwareAccelerated =
                mChild->IsHardwareAccelerated(mHardwareAcceleratedReason);
            mConversion = mChild->NeedsConversion();
            return InitPromise::CreateAndResolve(aTrack, __func__);
          },
          [self](const MediaResult& aError) {
            return InitPromise::CreateAndReject(aError, __func__);
          });
}

RefPtr<MediaDataDecoder::DecodePromise> RemoteMediaDataDecoder::Decode(
    MediaRawData* aSample) {
  RefPtr<RemoteMediaDataDecoder> self = this;
  RefPtr<MediaRawData> sample = aSample;
  return InvokeAsync(mAbstractManagerThread, __func__,
                     [self, sample]() { return self->mChild->Decode(sample); });
}

RefPtr<MediaDataDecoder::FlushPromise> RemoteMediaDataDecoder::Flush() {
  RefPtr<RemoteMediaDataDecoder> self = this;
  return InvokeAsync(mAbstractManagerThread, __func__,
                     [self]() { return self->mChild->Flush(); });
}

RefPtr<MediaDataDecoder::DecodePromise> RemoteMediaDataDecoder::Drain() {
  RefPtr<RemoteMediaDataDecoder> self = this;
  return InvokeAsync(mAbstractManagerThread, __func__,
                     [self]() { return self->mChild->Drain(); });
}

RefPtr<ShutdownPromise> RemoteMediaDataDecoder::Shutdown() {
  RefPtr<RemoteMediaDataDecoder> self = this;
  return InvokeAsync(mAbstractManagerThread, __func__, [self]() {
    RefPtr<ShutdownPromise> p = self->mChild->Shutdown();

    // We're about to be destroyed and drop our ref to
    // *DecoderChild. Make sure we put a ref into the
    // task queue for the *DecoderChild thread to keep
    // it alive until we send the delete message.
    p->Then(self->mManagerThread, __func__,
            [child = RefPtr<IRemoteDecoderChild>(self->mChild.forget())](
                const ShutdownPromise::ResolveOrRejectValue& aValue) {
              MOZ_ASSERT(aValue.IsResolve());
              child->DestroyIPDL();
              return ShutdownPromise::CreateAndResolveOrReject(aValue,
                                                               __func__);
            });
    return p;
  });
}

bool RemoteMediaDataDecoder::IsHardwareAccelerated(
    nsACString& aFailureReason) const {
  aFailureReason = mHardwareAcceleratedReason;
  return mIsHardwareAccelerated;
}

void RemoteMediaDataDecoder::SetSeekThreshold(const media::TimeUnit& aTime) {
  RefPtr<RemoteMediaDataDecoder> self = this;
  media::TimeUnit time = aTime;
  mManagerThread->Dispatch(
      NS_NewRunnableFunction("dom::RemoteMediaDataDecoder::SetSeekThreshold",
                             [=]() {
                               MOZ_ASSERT(self->mChild);
                               self->mChild->SetSeekThreshold(time);
                             }),
      NS_DISPATCH_NORMAL);
}

MediaDataDecoder::ConversionRequired RemoteMediaDataDecoder::NeedsConversion()
    const {
  return mConversion;
}

nsCString RemoteMediaDataDecoder::GetDescriptionName() const {
  return mDescription;
}

}  // namespace mozilla