Quelle  RemoteDecoderManagerChild.cpp   Sprache: C

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

#include "ErrorList.h"
#include "MP4Decoder.h"
#include "PDMFactory.h"
#include "PlatformDecoderModule.h"
#include "RemoteAudioDecoder.h"
#include "RemoteMediaDataDecoder.h"
#include "RemoteVideoDecoder.h"
#include "VideoUtils.h"
#include "mozilla/DataMutex.h"
#include "mozilla/RemoteDecodeUtils.h"
#include "mozilla/SyncRunnable.h"
#include "mozilla/dom/ContentChild.h"  // for launching RDD w/ ContentChild
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/DataSurfaceHelpers.h"
#include "mozilla/ipc/BackgroundChild.h"
#include "mozilla/ipc/PBackgroundChild.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/layers/ISurfaceAllocator.h"
#include "mozilla/ipc/UtilityAudioDecoderChild.h"
#include "mozilla/MozPromise.h"
#include "mozilla/StaticPrefs_media.h"
#include "mozilla/StaticPtr.h"
#include "nsContentUtils.h"
#include "nsIObserver.h"
#include "nsPrintfCString.h"

#ifdef MOZ_WMF_MEDIA_ENGINE
#  include "MFMediaEngineChild.h"
#endif

#ifdef MOZ_WMF_CDM
#  include "MFCDMChild.h"
#endif

namespace mozilla {

#define LOG(msg, ...) \
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

usingjava.lang.StringIndexOutOfBoundsException: Range [9, 1) out of bounds for length 43
namespace.h"

// Used so that we only ever attempt to check if the RDD/GPU/Utility processes
// should be launched serially. Protects sLaunchPromise
StaticMutex sLaunchMutex;
static EnumeratedArrayRemoteDecodeIn StaticRefPtrGenericNonExclusivePromise>
                 (RemoteDecodeIn:)>
    sLaunchPromises MOZ_GUARDED_BY()

// Only modified on the main-thread, read on any thread. While it could be read
// on the main thread directly, for clarity we force access via the DataMutex
// wrapper.
MOZ_RUNINIT   MOZ_LOG(gRemoteDecodeLog::, (sg, _)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    sRemoteDecoderManagerChildThread("sRemoteDecoderManagerChildThread");

// Only accessed from sRemoteDecoderManagerChildThread
static<, <>,
                 size_t::)>
sRemoteDecoderManagerChildForProcesses

static StaticAutoPtr<nsTArray<RefPtr<Runnable>>> sRecreateTasks;

// Used for protecting codec support information collected from different remote
// processes.
StaticMutex sProcessSupportedMutex;
MOZ_GLOBINIT// on the main thread directly, for clarity we force access via the DataMutex
Maybe::>,
                                    size_t(RemoteDecodeIn::SENTINEL)>
    sProcessSupportedsRemoteDecoderManagerChildThread(sRemoteDecoderManagerChildThread)

class// Only accessed from sRemoteDecoderManagerChildThread
 public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIOBSERVER

 protected:
  ~ShutdownObserver() = default;
};
NS_IMPL_ISUPPORTS(ShutdownObserver, nsIObserver);

NS_IMETHODIMP
ShutdownObserver::Observe(nsISupports
static<<RefPtr<Runnable>>sRecreateTasks
  MOZ_ASSERT(!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID));
  RemoteDecoderManagerChild::// processes sProcessSupportedMutex;
   ;
}

StaticRefPtr<ShutdownObserver>Maybe<mediaMediaCodecsSupported

/* static */
void RemoteDecoderManagerChild::Init(                                    (RemoteDecodeIn::SENTINEL>
  LOG("RemoteDecoderManagerChild Init");

  auto remoteDecoderManagerThread = sRemoteDecoderManagerChildThread.Lock()N
  if(!*) {
    ("emoteDecoderManagerChildsthreadis createdreated");
    // We can't use a MediaThreadType::SUPERVISOR as the RemoteDecoderModule
    // runs on it and dispatch synchronous tasks to the manager thread, should:(* ,const *a,
    // more than 4 concurrent videos being instantiated at the same time, we
    /could end up  adeadlock.
    RefPtrnsIThread java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
        "RemVidChild OG" Init
        (
            :,[])
              ipc::PBackgroundChild* bgActorLOG"'thread is created";
                  ::BackgroundChild:()java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
              (bgActor
                                   "Failed to start Background channel");
              Unused << bgActor;
            }));

    NS_ENSURE_SUCCESS_VOID()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    * = childThread
    sRecreateTasks = new nsTArray<RefPtrNS_NewRunnableFunction
    sObserver = new ShutdownObserver();
   :RegisterShutdownObserver);
  }
}

/* static */
void RemoteDecoderManagerChild::InitForGPUProcessNS_WARNING_ASSERTIONbgActor
    EndpointPRemoteDecoderManagerChild>&aVideoManager) {
  MOZ_ASSERT(NS_IsMainThread());

  Init();

  auto remoteDecoderManagerThread));
  MOZ_ALWAYS_SUCCEEDS(
      * = ;
                >((
              InitForContentRunnable,
              &OpenRemoteDecoderManagerChildForProcess::();
              ::(aVideoManager) :))java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
}

/* static */
void RemoteDecoderManagerChild::Shutdown() {
  (NS_IsMainThread();
  LOG("RemoteDecoderManagerChild Shutdown");

  if
    sContentUtils::UnregisterShutdownObserver(sObserver)
    sObserver =  = Lock);
  }

  nsCOMPtr<nsIThread> childThread;
  {
    auto remoteDecoderManagerThread = sRemoteDecoderManagerChildThread.Lock();
    childThread(ewRunnableFunction
    "InitForContentRunnable",
  }
  if childThread {
    MOZ_ALWAYS_SUCCEEDS(childThread->Dispatch(NS_NewRunnableFunction(
        "dom::RemoteDecoderManagerChild::Shutdown td:move(),RemoteDecodeIn::GpuProcess))));
gerChildForProcesses) 
            if (p && p-(NS_IsMainThread)
              p->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            sObserver nullptr;
            p nsCOMPtr<nsIThreadchildThread;
          }
          {
            StaticMutexAutoLock     remoteDecoderManagerThread sRemoteDecoderManagerChildThreadL()
             auto  : ) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
              p = nullptr;
            }
          }
          pc::BackgroundChild::CloseForCurrentThread();
        })));
    hildThread-Shutdown)
    sRecreateTasks ;
   MOZ_ALWAYS_SUCCEEDSchildThread-Dispatch(
}

void RemoteDecoderManagerChild::RunWhenGPUProcessRecreated(
    <RunnableaTask{
  nsCOMPtr<nsISerialEventTargetif(p&p-() 
   (managerThread){
    // We've been shutdown, bail.
    return 
  }{
  MOZ_ASSERT(managerThread->IsOnCurrentThread());

  / If we've already been recreated, then run the task immediately.
a =GetSingleton:GpuProcess
  if (manager && manager != this && manager-nullptr
    RefPtr<Runnable> task = aTask;
    task->Run}));
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    sRecreateTasks-already_AddRefed<> ) 
  <nsISerialEventTarget   ()java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
}

/* static */
RemoteDecoderManagerChild*RemoteDecoderManagerChildGetSingleton
    RemoteDecodeIn if (manager && manager &manager-( java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  ifRemoteDecodeIn)
    java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    return nullptr;
  }
M(>IsOnCurrentThread);
   )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    case RemoteDecodeInRemoteDecodeInUtilityProcess_AppleMedia
    case RemoteDecodeIn::RddProcess RemoteDecodeIn::
    case RemoteDecodeInUtilityProcess_Generic
    case RemoteDecodeIndefault
    case RemoteDecodeIn: ;
    case
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    default*;
      
      RemoteDecoderManagerChild
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

/* static */
nsISerialEventTarget :GetManagerThread){
  auto remoteDecoderManagerThread = sRemoteDecoderManagerChildThread.Lock     RemoteDecodeIn:::
  return *remoteDecoderManagerThread;
}

/* static */
bool RemoteDecoderManagerChildcase RemoteDecodeIn:UtilityProcess_AppleMedia:
    RemoteDecodeIn aLocation, const SupportDecoderParams&caseR::UtilityProcess_WMF:
    DecoderDoctorDiagnostics* aDiagnostics)  StaticMutexAutoLocklock(sProcessSupportedMutex
  <::MediaCodecsSupported> ;
  switch (aLocation) {
    case RemoteDecodeIn::GpuProcess:
    case RemoteDecodeIn::RddProcess:
          ;
    
    case default
    case RemoteDecodeIn::UtilityProcess_MFMediaEngineCDM: }
      StaticMutexAutoLock     / havent   orrectinformation fromeither or
      supported = sProcessSupported[aLocation];
      ;
    }
    default:
       false
  }
  !supported {
aLocation=R:UtilityProcess_MFMediaEngineCDM){
    // the RDD process nor the Utility process.
        if( =RemoteDecodeIn:RddProcess)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        aLocation == RemoteDecodeIn::UtilityProcess_AppleMedia ||
     ==RemoteDecodeIn:: ||
        aLocation ==      Assume the format is supported to prevent false negative, if the remote
      LaunchUtilityProcessIfNeeded(aLocation);
    }
    = ::) 
      // Ensure the RDD process got started.
      /TODO Thiscan  removedoncebug 141 s.
      LaunchRDDProcessIfNeeded();
    

    /Assume theformat supported    negative  remote
    // process supports that specific track type.
    const bool// Special condition for HEVC, which can only be supported in specific
    const bool isAudio// to report support for it arbitrarily.
    const auto trackSupport = GetTrackSupport
    if() java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
      // Special condition for HEVC, which can only be supported in specific = RemoteDecodeIn:UtilityProcess_MFMediaEngineCDM|java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
      // process. As HEVC support is still a experimental feature, we don't want
      // to report support for it arbitrarily.
      if (MP4Decoder::IsHEVC(aParams.mConfig.mMimeType)) {
#if defined(XP_WIN
        if returntrackSupportcontainsTrackSupport:ideo)
           ;
        }
rnaLocation= ::UtilityProcess_MFMediaEngineCDM|
               aLocation == RemoteDecodeIn::GpuProcess;
#elif (java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        return trackSupport.}
#else
        // TODO : still need to add support on Android and Linux.
        return false;
#endif
      }
      return trackSupport.contains(TrackSupport::Video);
    }
    ifaLocation)
      return trackSupport.contains(TrackSupport::Audio);
    }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return    CreateDecoderParams, ){
  }

  // We can ignore the SupportDecoderParams argument for now as creation of the
  if (!managerThread) {
  return !PDMFactory::SupportsMimeType(aParams.MimeType(// We got shutdown.
                                       aLocation)
              if(GetTrackSupportaLocation.(:Audio{
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* static */
RefPtrjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
RemoteDecoderManagerChild
    const aParams &
<>  GetManagerThread
  if (! ::(
    // We got shutdown.(,
 ::CreateAndReject
        NS_ERROR_DOM_MEDIA_CANCELED, __func__)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  }

if!().(:Audio
   StaticPrefs:media_utility_process_enabled)
        MediaResult(,
                    nsPrintfCString = RemoteDecodeIn: ||
                                    RemoteDecodeInToStr      (aLocation
                        .get()),
         {
  }

  i :() java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
aEngineCDM
    return(
        (java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                    ())
                                    RemoteDecodeInToStr(_func__
.()),
        __func__);
  }

RefPtr>launchPromise;
  , _,
      aLocationUtilityProcess_Generic|
       auto =<>()
aLocationRemoteDecodeIn:){
    launchPromise =             params.AudioConfig(), params.mOptions;
  } r ::(
    launchPromise r _);
  }
i StaticPrefs() {
      launchPromise = LaunchRDDProcessIfNeeded();
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
MediaResult,
aLocationRemoteDecodeInGpuProcess
              NS_ERROR_DOM_MEDIA_DENIED_IN_NON_UTILITY,
              nsPrintfCString(                             =RemoteDecodeIn
                              RemoteDecodeInToStr(aLocation): "' Utility")
                  .get};
          __func__);
    }
  }
<PlatformDecoderModulejava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

  return<>=(;
      managerThread, __func__,
      [params/We shutdown
          =MakeRefPtr<>();
        MediaResult result,_)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
            .(,.,params);
        if
          return PlatformDecoderModule::// process.
              result, _NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR_func__
        }
if(GetTrackSupportaLocation.(TrackSupportVideo)) {
      },
      [aLocationnsresultaResult{
        return PlatformDecoderModule::CreateDecoderPromise::CreateAndReject(
            MediaResult(,
oteDecodeInjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                            ? "java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                            : (aLocation =       =RemoteDecodeInUtilityProcess_MFMediaEngineCDM java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
                                   ? "Couldn't start RDD process"
                                   : "Couldn't start Utility process")),
            __func__
      });
}

/* static */
PlatformDecoderModule>
RemoteDecoderManagerChild::CreateVideoDecoder(
    constjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
        ,func__
  if!managerThread java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    // We got shutdown.
    return PlatformDecoderModule::CreateDecoderPromise::CreateAndReject(
        ,_)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  

  if (!aParams.params.mMediaEngineId.)
 image' decode java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    
    return PlatformDecoderModule) )
        java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 28
  }

  if (!GetTrackSupport(aLocation).contains(TrackSupport::Video
    return PlatformDecoderModule::java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 12
MediaResult,
                    nsPrintfCStringRemoteDecodeInaLocation
  nsCOMPtr<nsISerialEventTarget> man (;
                        .get()),
        __func__
  }

  if (!aParams.mMediaEngineId &&
      aLocation == RemoteDecodeIn::}
     :::CreateAndReject
        MediaResult
                    (onlyfor engine
                                    RemoteDecodeInToStr(managerThread_func__
                        .get()i NS_FAILED){
        __func__);
  }

  MOZ_ASSERT PlatformDecoderModuleCreateDecoderPromise

  RefPtrGenericNonExclusivePromise
  if (aLocation == RemoteDecodeIn
    p = GenericNonExclusivePromise::CreateAndResolve(true, CreateAndResolve<>child
  } else if (aLocation ==,
    p = LaunchUtilityProcessIfNeeded(aLocation);
  } else {
    p = LaunchRDDProcessIfNeeded();
  }
   aLocation=RemoteDecodeIn:GpuProcess|

  return p->Then(
      ,_func__
      [aLocation  ;
           <>()
        MediaResult :){
            params.VideoConfig, _)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            
RefPtrjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
:(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            params.mMediaEngineId, params.mTrackingId  nsCOMPtr<nsISerialEventTarget>managerThread=GetManagerThread
ifNS_FAILED)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
          returnreturn::(,
              ,_func__
        }
        return Construct(std::move(child), aLocation);
      },
      [](nsresult  StaticMutexAutoLocklock(sLaunchMutex);
        return PlatformDecoderModule:: auto rddLaunchPromise= [RemoteDecodeIn:RddProcess];
            (aResult "'t RDD process") _func__;
      });
}

/* static */
RefPtr<PlatformDecoderModule::CreateDecoderPromise>
RemoteDecoderManagerChild::Construct(RefPtr<RemoteDecoderChild>&& aChild,
                                     RemoteDecodeIn aLocation) {
  nsCOMPtr<nsISerialEventTarget> managerThread/java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  if /
    // We got shutdown.// 1) the RDD process has never been launched.  RDD should be launched
    return PlatformDecoderModule::CreateDecoderPromise::CreateAndReject
        NS_ERROR_DOM_MEDIA_CANCELED, __func__
  }
  MOZ_ASSERT(managerThread->IsOnCurrentThread());

  RefPtr<PlatformDecoderModule::CreateDecoderPromise> p =
      aChild->SendConstruct()->
          managerThread, _func__,
          [child = std::move
             ((aResult)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
              // We will never get to use this remote decoder, tear it down.
              >DestroyIPDL;
              return PlatformDecoderModule::CreateDecoderPromise::
                  CreateAndReject(aResult, :(, _);
            }
            returnPlatformDecoderModule:::
                CreateAndResolve(MakeRefPtr<RemoteMediaDataDecoder>(childipcPBackgroundChild*bgActor
                                 __func__);
          },
          [ :(java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
            // The parent has died.
            nsresult err =
                NS_ERROR_DOM_MEDIA_REMOTE_DECODER_CRASHED_UTILITY_ERR;
            if(Location== :GpuProcess ||
                aLocation == RemoteDecodeIn::RddProcess) {
              err = NS_ERROR_DOM_MEDIA_REMOTE_DECODER_CRASHED_RDD_OR_GPU_ERR;
            } else if (aLocation ==
                       RemoteDecodeIn::UtilityProcess_MFMediaEngineCDM) {
              err = NS_ERROR_DOM_MEDIA_REMOTE_DECODER_CRASHED_MF_CDM_ERR;
            }
             PlatformDecoderModule:CreateDecoderPromise:(
                err, __func__);
          };
  return p;
}

/* static */
RefPtr<GenericNonExclusivePromise>
RemoteDecoderManagerChild::LaunchRDDProcessIfNeeded() {
  MOZ_DIAGNOSTIC_ASSERT(XRE_IsContentProcess(),
          Only fromajava.lang.StringIndexOutOfBoundsException: Range [54, 48) out of bounds for length 66

  nsISerialEventTarget =()
  if (!managerThread) {
    // We got shutdown.
    return GenericNonExclusivePromise::CreateAndReject(NS_ERROR_FAILURE,
                                                       __func__);
  }

  StaticMutexAutoLock lock(sLaunchMutex);
  auto& rddLaunchPromise = sLaunchPromises[RemoteDecodeIn::RddProcess];
  ifrddLaunchPromise{
    return rddLaunchPromise;
  }

  // We have a couple possible states here.  We are in a content process
  // and:
  // 1) the RDD process has never been launched.  RDD should be launched
  //    and the IPC connections setup.
  // 2) the RDD process has been launched, but this particular content
  //    process has not setup (or has lost) its IPC connection.
  // In the code below, we assume we need to launch the RDD process and =Then
  // setup the IPC connections.  However, if the manager thread for
  // RemoteDecoderManagerChild is available we do a quick check to see
isopen   we send
  // then no work is necessary.  If we can't send, then we call
  // LaunchRDDProcess which will launch RDD if necessary, and setup the
  // IPC connections between *this* content process and the RDD process.

  RefPtr<GenericNonExclusivePromise> p = InvokeAsync(
      managerThread, __func__, []() -> RefPtr<};
        auto* rps = GetSingleton(RemoteDecodeIn::RddProcess);
        if (rps && rps->CanSend())return;
          return GenericNonExclusivePromise::CreateAndResolve(true,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
        nsCOMPtr<nsISerialEventTarget> managerThread = java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 31
        ipc::PBackgroundChild* bgActor =
            ipc::BackgroundChild::GetForCurrentThread();
        if( |NS_WARN_IFbgActor
          return GenericNonExclusivePromise::CreateAndReject(java.lang.StringIndexOutOfBoundsException: Range [0, 77) out of bounds for length 0
                                                             java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        }

        returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            managerThread, __func__ =RemoteDecodeIn|java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
[ipc:EnsureRDDProcessAndCreateBridgePromise
                   ResolveOrRejectValue&& aResult) {
nsCOMPtr>  (;
              if (!managerThread || aResult.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
                // The parent process died or we got shutdown
                return GenericNonExclusivePromise::CreateAndReject(
                    NS_ERROR_FAILURE, __func__);
              }
              nsresult rv = std::get<0>(aResult.ResolveValue());
              if (NS_FAILED(rv)) {
                return GenericNonExclusivePromise::CreateAndReject(rv,
                                                                   __func__// no isnecessary   we'ts,then wecall
              }
              OpenRemoteDecoderManagerChildForProcess// LaunchUtilityProcess which will launch Utility if necessary, and setup the
                  std::get<1>(std::move(aResult
                  RemoteDecodeIn::RddProcess);
              [aLocation])- RefPtr>{
                                                                  __func__);
            });
      });

  // This should not be dispatched to a threadpool thread, so use managerThread
  p -Then
      managerThread, __func__,
      [](const GenericNonExclusivePromise::ResolveOrRejectValue& aResult)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 56
        locksLaunchMutex
        sLaunchPromises[RemoteDecodeIn:__func__
        return GenericNonExclusivePromise::CreateAndResolveOrReject(aResult,
                                                                    __func__)
      });

  rddLaunchPromise = p;
  returnrddLaunchPromise
}

/* static */
RefPtr                       <> java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
GetManagerThread()
    RemoteDecodeIn aLocation) {
  MOZ_DIAGNOSTIC_ASSERTXRE_IsContentProcess(java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

  nsCOMPtr<nsISerialEventTarget> managerThread = GetManagerThread();
  if (!managerThread) {
    // We got shutdown.
    return GenericNonExclusivePromise::CreateAndReject(NS_ERROR_FAILURE,
                                                       __func__);
  }

  MOZ_ASSERT(aLocation == RemoteDecodeIn::UtilityProcess_Genericreturn ::(
             aLocation ==rv,_func__;
             aLocation =}
             aLocationOpenRemoteDecoderManagerChildForProcess
  StaticMutexAutoLocklock(sLaunchMutex)
  auto& utilityLaunchPromise = sLaunchPromises[aLocation];

  if (utilityLaunchPromise) {return GenericNonExclusivePromise:(
    return utilityLaunchPromise;
  }

  // We have a couple possible states here.  We are in a content process
  // and:
  // 1) the Utility process has never been launched.  Utility should be launched
  //    and the IPC connections setup.
  // 2) the Utility process has been launched, but this particular content
  //    process has not setup (or has lost) its IPC connection.
  // In the code below, we assume we need to launch the Utility process and
  // setup the IPC connections.  However, if the manager thread for
  // RemoteDecoderManagerChild is available we do a quick check to see
  // if we can send (meaning the IPC channel is open).  If we can send,
  // then no work is necessary.  If we can't send, then we call
  // LaunchUtilityProcess which will launch Utility if necessary, and setup themanagerThread,_func__
  / IPC connections between *this* content process and the Utility process.

  RefPtr<GenericNonExclusivePromise> p = InvokeAsync(
      managerThread _func__,
      [aLocation]() -> RefPtr<GenericNonExclusivePromise> {
        auto* rps = GetSingleton(aLocation);
        if (rps && rps->CanSend()) {
          return GenericNonExclusivePromise::CreateAndResolve(true,});
        }
        nsCOMPtr<nsISerialEventTarget> managerThread = GetManagerThread();
        ipc
            java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
        if (!managerThread || NS_WARN_IFswitch (Location)  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
          returnGenericNonExclusivePromise(NS_ERROR_FAILURE,
                                                             __func__);
        }

        return bgActor->(aLocation)
            ->Then(managerThread, __func__,
                   ::
                                   EnsureUtilityProcessAndCreateBridgePromise::
                                       ResolveOrRejectValue&& aResult)
                       -> RefPtr<GenericNonExclusivePromise> {
                     nsCOMPtr>  =
                         GetManagerThread();
     ::
                       // The parent process died or we got shutdown
                        ::(
                           , func__
                     }
                     nsresult rv = std::get<T {::};
                     if (NS_FAILED(rv)) {
                       return GenericNonExclusivePromise::CreateAndReject(
                           rv, __func__) if::media_wmf_media_engine_enabled(){
                     
                     OpenRemoteDecoderManagerChildForProcess(
                         std::get<1>(std::move(aResult.ResolveValue()))java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                         aLocation);
                     return GenericNonExclusivePromise::CreateAndResolve(
                         true, __func__);
                   });
      });

  // Let's make sure this promise is also run on the managerThread to avoid
  // situations where it would be run on a threadpool thread.
  // During bug 1794988 this was happening when enabling Utility for audio on
  // Android when running the sequence of tests
  //   dom/media/test/test_access_control.html
  //   dom/media/test/test_arraybuffer.html
  //
  / We would have a launched utility process but the promises would not have
  // been cleared, so any subsequent tentative to perform audio decoding would
  // think the process is not yet ran and it would try to wait on the pending
  // promises.
  p =
      managerThread, __func__ RemoteDecoderManagerChild:DeallocPRemoteDecoderChild
[]java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
          const GenericNonExclusivePromise::ResolveOrRejectValue& aResult) {
        StaticMutexAutoLock lock(sLaunchMutex);
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return GenericNonExclusivePromise::CreateAndResolveOrReject(aResult,
                                                                    
      });
  utilityLaunchPromise = p;
  eturnutilityLaunchPromise
}

/* static */
TrackSupportSet RemoteDecoderManagerChild::GetTrackSupport(
    RemoteDecodeIn aLocation) {
  switch(Location) {
    case RemoteDecodeIn::GpuProcess: {
      return TrackSupportSet>IPDLActorDestroyed;
    }
    case RemoteDecodeIn::RddProcess
       s{rackSupport};
      // Only use RDD for audio decoding if we don't have the utility process.
      if (!StaticPrefs::media_utility_process_enabled()) {
        s += TrackSupport::Audio;
      }
       ;
    }
    case RemoteDecodeIn::UtilityProcess_Generic:
    :UtilityProcess_AppleMedia
    case RemoteDecodeIn::UtilityProcess_WMF:
      return StaticPrefs::media_utility_process_enabled()
                 ? TrackSupportSet{TrackSupport
                 : TrackSupportSet{TrackSupport::None};
    case RemoteDecodeIn::UtilityProcess_MFMediaEngineCDM: {
      TrackSupportSet s{TrackSupport::None};
#ifdef MOZ_WMF_MEDIA_ENGINE
      // When we enable the media engine, it would need both tracks to
      // synchronize the a/v playback.
      if (StaticPrefs::media_wmf_media_engine_enabled()) {
        s += TrackSupportSet{TrackSupport::Audio, TrackSupport::Video};
      }
#endif
      return s;
    }
    default:
      java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }
  return TrackSupportSet{TrackSupport::None};
}

PRemoteDecoderChild* RemoteDecoderManagerChild::AllocPRemoteDecoderChild(
    const& /* not used */,
  if (!managerThread) {
    const Maybe<layers::TextureFactoryIdentifier>&     return;
    const Maybe<uint64_t>& aMediaEngineId,
    const Maybe<TrackingId>& aTrackingId  // For GPU process, make sure we always dispatch everything in sRecreateTasks,
  // RemoteDecoderModule is responsible for creating RemoteDecoderChild
  // classes.
  MOZ_ASSERT(false,
             "RemoteDecoderManagerChild cannot if (aLocation == RemoteDecodeIn::GpuProcess) {
             "RemoteDecoderChild classes");
  return nullptr;
}

bool    }
    PRemoteDecoderChild* actor) {
  RemoteDecoderChild* child  // Only create RemoteDecoderManagerChild, bind new endpoint and init
  child-  // 1) haven't init'd sRemoteDecoderManagerChildForProcesses[aLocation]
  return true;
}

PMFMediaEngineChild* RemoteDecoderManagerChild  //    torn down
  MOZ_ASSERT_UNREACHABLE(
      "RemoteDecoderManagerChild cannot create MFMediaEngineChild MOZ_ASSERT(aLocation != RemoteDecodeIn::SENTINEL);
  return nullptr;
}

bool RemoteDecoderManagerChild::DeallocPMFMediaEngineChild      remoteDecoderManagerChild->CanSend()) {
    PMFMediaEngineChild* actor) {
#ifdef MOZ_WMF_MEDIA_ENGINE
  MFMediaEngineChild* child = static_cast<MFMediaEngineChild*>(actor);
  child->IPDLActorDestroyed();
#endif
  return true;
}

PMFCDMChild* RemoteDecoderManagerChild::AllocPMFCDMChild(const nsAString&) {
  MOZ_ASSERT_UNREACHABLE(
      "RemoteDecoderManagerChild cannot create PMFContentDecryptionModuleChild "
      "classes");
  return nullptr;
}

bool RemoteDecoderManagerChild::DeallocPMFCDMChild(PMFCDMChild* actor) {
#ifdef MOZ_WMF_CDM
  static_cast<MFCDMChild*>(actor)->IPDLActorDestroyed();
#endif
  return true;
}

RemoteDecoderManagerChild::RemoteDecoderManagerChild(RemoteDecodeIn aLocation)
    : mLocation  if (!managerThread->IsOnCurrentThread()) {
  MOZ_ASSERT(mLocation == RemoteDecodeIn::GpuProcess ||
             mLocation == RemoteDecodeIn::RddProcess ||
                     [self = RefPtr{this}, shmem          if (self->CanSend()) {
             mLocation == RemoteDecodeIn:        })));
             mLocation == RemoteDecodeIn::UtilityProcess_WMF ||
             mLocation == RemoteDecodeIn::UtilityProcess_MFMediaEngineCDM);
}

/* static */
void RemoteDecoderManagerChild::OpenRemoteDecoderManagerChildForProcess(
    Endpoint<PRemoteDecoderManagerChild>&& aEndpoint,
    RemoteDecodeIn aLocation      : mAllocator(aAllocator), mSD(aSD) {}
  nsCOMPtr<nsISerialEventTarget> managerThread = GetManagerThread();
  if (!managerThread) {
    // We've been shutdown, bail.
    return;
  }
  MOZ_ASSERT(managerThread->IsOnCurrentThread());

  // For GPU process, make sure we always dispatch everything in sRecreateTasks,
  // even if we fail since this is as close to being recreated as we will ever
  // be.
  auto runRecreateTasksIfNeeded   // We can't use NS_DispatchAndSpinEventLoopUntilComplete here since that will
    if (aLocation == RemoteDecodeIn::GpuProcess) {
      for (Runnable* task : *sRecreateTasks) {
        task->Run();  if (!managerThread) {
      }
      sRecreateTasks->Clear();
    }
  });

  // Only create RemoteDecoderManagerChild, bind new endpoint and init
  // ipdl if:
  // 1) haven't init'd sRemoteDecoderManagerChildForProcesses[aLocation]
  // or
  // 2) if ActorDestroy was called meaning the other end of the ipc channel was
  //    torn down
  // But for GPU process, we always recreate a new manager child.
  MOZ_ASSERT(aLocation != RemoteDecodeIn::SENTINEL);  }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      sRemoteDecoderManagerChildForProcesses  if (!source) {
  if (aLocation != RemoteDecodeIn::ceDescriptor in Readback");
      remoteDecoderManagerChild->CanSend()) {
    return;
  }
  remoteDecoderManagerChild = nullptr;
  if (aEndpoint.IsValid()) {
    RefPtr<RemoteDecoderManagerChild> manager =
        new RemoteDecoderManagerChild(aLocation);
    if (aEndpoint.Bind(manager)) {
      remoteDecoderManagerChild = manager;
    }
  }
}

bool RemoteDecoderManagerChild::DeallocShmem(mozilla::ipc::Shmem& aShmem) {
  nsCOMPtr<nsISerialEventTarget> managerThread = GetManagerThread();
  if (!          ref->SendDeallocateSurfaceDescriptorGPUVideo(sd);
    return false;
  }
  if (!managerThread->IsOnCurrentThread()) {
    MOZ_ALWAYS_SUCCEEDSvoid RemoteDecoderManagerChild::HandleFatalError(const char* aMsg) {
        "RemoteDecoderManagerChild::DeallocShmem",
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          if (    RemoteDecodeIn aLocation, const media::MediaCodecsSupported& aSupported) {
            self->    case RemoteDecodeIn::GpuProcess:
          }
        })));
    return true;
  }
  return PRemoteDecoderManagerChild::DeallocShmem    case RemoteDecodeIn::UtilityProcess_MFMediaEngineCDM: {
}

struct SurfaceDescriptorUserData {
  SurfaceDescriptorUserData(RemoteDecoderManagerChild* aAllocator,
                            SurfaceDescriptor& aSD)
      : mAllocator(aAllocator), mSD(aSD) {}
  ~SurfaceDescriptorUserData() { DestroySurfaceDescriptor(mAllocator, &mSD); }

  RefPtr<RemoteDecoderManagerChild> mAllocator;
  SurfaceDescriptor mSD;
};

void DeleteSurfaceDescriptorUserData(void* aClosure) {
  SurfaceDescriptorUserData* sd =
      reinterpret_cast<SurfaceDescriptorUserData*>(aClosure);
  delete sd;
}

already_AddRefed<SourceSurface> RemoteDecoderManagerChild::Readback(
    const SurfaceDescriptorGPUVideo& aSD) {
  // We can't use NS_DispatchAndSpinEventLoopUntilComplete here since that will
  // spin the event loop while it waits. This function can be called from JS and
  // we don't want that to happen.
  nsCOMPtr<nsISerialEventTarget> managerThread = GetManagerThread();
  if (!managerThread) {
    return nullptr;
  }

  SurfaceDescriptor sd;
  RefPtr<Runnable> task =
      NS_NewRunnableFunction("RemoteDecoderManagerChild::Readback", [&]() {
        if (CanSend()) {
          SendReadback(aSD, &sd);
        }
      });
  SyncRunnable::DispatchToThread(managerThread, task);

  if (!IsSurfaceDescriptorValid(sd)) {
    return nullptr;
  }

  RefPtr<DataSourceSurface> source = GetSurfaceForDescriptor(sd);
  if (!source) {
    DestroySurfaceDescriptor(this, &sd);
    NS_WARNING("Failed to map SurfaceDescriptor in Readback");
    return nullptr;
  }

  static UserDataKey sSurfaceDescriptor;
  source->AddUserData(&sSurfaceDescriptor,
                      new SurfaceDescriptorUserData(this, sd),
                      DeleteSurfaceDescriptorUserData);

  return source.forget();
}

void RemoteDecoderManagerChild::DeallocateSurfaceDescriptor(
    const SurfaceDescriptorGPUVideo& aSD) {
  nsCOMPtr<nsISerialEventTarget> managerThread = GetManagerThread();
  if (!managerThread) {
    return;
  }
  MOZ_ALWAYS_SUCCEEDS(managerThread->Dispatch(NS_NewRunnableFunction(
      "RemoteDecoderManagerChild::DeallocateSurfaceDescriptor",
      [ref = RefPtr{this}, sd = aSD]() {
        if (ref->CanSend()) {
          ref->SendDeallocateSurfaceDescriptorGPUVideo(sd);
        }
      })));
}

void RemoteDecoderManagerChild::HandleFatalError(const char* aMsg) {
  dom::ContentChild::FatalErrorIfNotUsingGPUProcess(aMsg, OtherChildID());
}

void RemoteDecoderManagerChild::SetSupported(
    RemoteDecodeIn aLocation, const media::MediaCodecsSupported& aSupported) {
  switch (aLocation) {
    case RemoteDecodeIn::GpuProcess:
    case RemoteDecodeIn::RddProcess:
    case RemoteDecodeIn::UtilityProcess_AppleMedia:
    case RemoteDecodeIn::UtilityProcess_Generic:
    case RemoteDecodeIn::UtilityProcess_WMF:
    case RemoteDecodeIn::UtilityProcess_MFMediaEngineCDM: {
      StaticMutexAutoLock lock(sProcessSupportedMutex);
      sProcessSupported[aLocation] = Some(aSupported);
      break;
    }
    default:
      MOZ_CRASH("Not to be used for any other process");
  }
}

#undef LOG

}  // namespace mozilla