tor-browser

AllocationPolicy.cpp (8398B)

---

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* 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 "AllocationPolicy.h"

#include "ImageContainer.h"
#include "MediaInfo.h"
#include "PDMFactory.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/SchedulerGroup.h"
#ifdef MOZ_WIDGET_ANDROID
#  include "mozilla/jni/Utils.h"
#endif

namespace mozilla {

using TrackType = TrackInfo::TrackType;

class AllocPolicyImpl::AutoDeallocToken : public Token {
public:
 explicit AutoDeallocToken(const RefPtr<AllocPolicyImpl>& aPolicy)
     : mPolicy(aPolicy) {}

private:
 ~AutoDeallocToken() { mPolicy->Dealloc(); }

 RefPtr<AllocPolicyImpl> mPolicy;
};

AllocPolicyImpl::AllocPolicyImpl(int aDecoderLimit)
   : mMaxDecoderLimit(aDecoderLimit),
     mMonitor("AllocPolicyImpl"),
     mDecoderLimit(aDecoderLimit) {}
AllocPolicyImpl::~AllocPolicyImpl() { RejectAll(); }

auto AllocPolicyImpl::Alloc() -> RefPtr<Promise> {
 ReentrantMonitorAutoEnter mon(mMonitor);
 // No decoder limit set.
 if (mDecoderLimit < 0) {
   return Promise::CreateAndResolve(new Token(), __func__);
 }

 RefPtr<PromisePrivate> p = new PromisePrivate(__func__);
 mPromises.push(p);
 ResolvePromise(mon);
 return p;
}

void AllocPolicyImpl::Dealloc() {
 ReentrantMonitorAutoEnter mon(mMonitor);
 ++mDecoderLimit;
 ResolvePromise(mon);
}

void AllocPolicyImpl::ResolvePromise(ReentrantMonitorAutoEnter& aProofOfLock) {
 MOZ_ASSERT(mDecoderLimit >= 0);

 if (mDecoderLimit > 0 && !mPromises.empty()) {
   --mDecoderLimit;
   RefPtr<PromisePrivate> p = std::move(mPromises.front());
   mPromises.pop();
   p->Resolve(new AutoDeallocToken(this), __func__);
 }
}

void AllocPolicyImpl::RejectAll() {
 ReentrantMonitorAutoEnter mon(mMonitor);
 while (!mPromises.empty()) {
   RefPtr<PromisePrivate> p = std::move(mPromises.front());
   mPromises.pop();
   p->Reject(true, __func__);
 }
}

static int32_t MediaDecoderLimitDefault() { return -1; }

StaticMutex GlobalAllocPolicy::sMutex;

NotNull<AllocPolicy*> GlobalAllocPolicy::Instance(TrackType aTrack) {
 StaticMutexAutoLock lock(sMutex);
 if (aTrack == TrackType::kAudioTrack) {
   static RefPtr<AllocPolicyImpl> sAudioPolicy = []() {
     SchedulerGroup::Dispatch(NS_NewRunnableFunction(
         "GlobalAllocPolicy::GlobalAllocPolicy:Audio", []() {
           ClearOnShutdown(&sAudioPolicy, ShutdownPhase::XPCOMShutdownThreads);
         }));
     return new AllocPolicyImpl(MediaDecoderLimitDefault());
   }();
   return WrapNotNull(sAudioPolicy.get());
 }
 static RefPtr<AllocPolicyImpl> sVideoPolicy = []() {
   SchedulerGroup::Dispatch(NS_NewRunnableFunction(
       "GlobalAllocPolicy::GlobalAllocPolicy:Audio", []() {
         ClearOnShutdown(&sVideoPolicy, ShutdownPhase::XPCOMShutdownThreads);
       }));
   return new AllocPolicyImpl(MediaDecoderLimitDefault());
 }();
 return WrapNotNull(sVideoPolicy.get());
}

class SingleAllocPolicy::AutoDeallocCombinedToken : public Token {
public:
 AutoDeallocCombinedToken(already_AddRefed<Token> aSingleAllocPolicyToken,
                          already_AddRefed<Token> aGlobalAllocPolicyToken)
     : mSingleToken(aSingleAllocPolicyToken),
       mGlobalToken(aGlobalAllocPolicyToken) {}

private:
 // Release tokens allocated from GlobalAllocPolicy and LocalAllocPolicy
 // and process next token request if any.
 ~AutoDeallocCombinedToken() = default;
 const RefPtr<Token> mSingleToken;
 const RefPtr<Token> mGlobalToken;
};

auto SingleAllocPolicy::Alloc() -> RefPtr<Promise> {
 MOZ_DIAGNOSTIC_ASSERT(MaxDecoderLimit() == 1,
                       "We can only handle at most one token out at a time.");
 RefPtr<SingleAllocPolicy> self = this;
 return AllocPolicyImpl::Alloc()->Then(
     mOwnerThread, __func__,
     [self](RefPtr<Token> aToken) {
       RefPtr<Token> localToken = std::move(aToken);
       RefPtr<Promise> p = self->mPendingPromise.Ensure(__func__);
       GlobalAllocPolicy::Instance(self->mTrack)
           ->Alloc()
           ->Then(
               self->mOwnerThread, __func__,
               [self, localToken = std::move(localToken)](
                   RefPtr<Token> aToken) mutable {
                 self->mTokenRequest.Complete();
                 RefPtr<Token> combinedToken = new AutoDeallocCombinedToken(
                     localToken.forget(), aToken.forget());
                 self->mPendingPromise.Resolve(combinedToken, __func__);
               },
               [self]() {
                 self->mTokenRequest.Complete();
                 self->mPendingPromise.Reject(true, __func__);
               })
           ->Track(self->mTokenRequest);
       return p;
     },
     []() { return Promise::CreateAndReject(true, __func__); });
}

SingleAllocPolicy::~SingleAllocPolicy() {
 mPendingPromise.RejectIfExists(true, __func__);
 mTokenRequest.DisconnectIfExists();
}

void SingleAllocPolicy::Cancel() {
 MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
 mPendingPromise.RejectIfExists(true, __func__);
 mTokenRequest.DisconnectIfExists();
 RejectAll();
}

AllocationWrapper::AllocationWrapper(
   already_AddRefed<MediaDataDecoder> aDecoder, already_AddRefed<Token> aToken)
   : mDecoder(aDecoder), mToken(aToken) {
 DecoderDoctorLogger::LogConstructionAndBase(
     "AllocationWrapper", this, static_cast<const MediaDataDecoder*>(this));
 DecoderDoctorLogger::LinkParentAndChild("AllocationWrapper", this, "decoder",
                                         mDecoder.get());
}

AllocationWrapper::~AllocationWrapper() {
 DecoderDoctorLogger::LogDestruction("AllocationWrapper", this);
}

RefPtr<ShutdownPromise> AllocationWrapper::Shutdown() {
 RefPtr<MediaDataDecoder> decoder = std::move(mDecoder);
 RefPtr<Token> token = std::move(mToken);
 return decoder->Shutdown()->Then(
     GetCurrentSerialEventTarget(), __func__,
     [token]() { return ShutdownPromise::CreateAndResolve(true, __func__); });
}
/* static */ RefPtr<AllocationWrapper::AllocateDecoderPromise>
AllocationWrapper::CreateDecoder(const CreateDecoderParams& aParams,
                                AllocPolicy* aPolicy) {
 RefPtr<AllocateDecoderPromise> p =
     (aPolicy ? aPolicy : GlobalAllocPolicy::Instance(aParams.mType))
         ->Alloc()
         ->Then(
             GetCurrentSerialEventTarget(), __func__,
             [params =
                  CreateDecoderParamsForAsync(aParams)](RefPtr<Token> aToken) {
               // result may not always be updated by
               // PDMFactory::CreateDecoder either when the creation
               // succeeded or failed, as such it must be initialized to a
               // fatal error by default.
               MediaResult result =
                   MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
                               nsPrintfCString("error creating %s decoder",
                                               TrackTypeToStr(params.mType)));
               RefPtr<PDMFactory> pdm = new PDMFactory();
               RefPtr<PlatformDecoderModule::CreateDecoderPromise> p =
                   pdm->CreateDecoder(params)->Then(
                       GetCurrentSerialEventTarget(), __func__,
                       [aToken](RefPtr<MediaDataDecoder>&& aDecoder) mutable {
                         RefPtr<AllocationWrapper> wrapper =
                             new AllocationWrapper(aDecoder.forget(),
                                                   aToken.forget());
                         return AllocateDecoderPromise::CreateAndResolve(
                             wrapper, __func__);
                       },
                       [](const MediaResult& aError) {
                         return AllocateDecoderPromise::CreateAndReject(
                             aError, __func__);
                       });
               return p;
             },
             []() {
               return AllocateDecoderPromise::CreateAndReject(
                   MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
                               "Allocation policy expired"),
                   __func__);
             });
 return p;
}

}  // namespace mozilla