Quelle  MediaSystemResourceService.cpp   Sprache: C

/* -*- 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 "MediaSystemResourceManagerParent.h"
#include "mozilla/layers/CompositorThread.h"
#include "mozilla/Unused.h"

#include "MediaSystemResourceService.h"

using namespace mozilla::layers;

namespace mozilla {

/* static */
StaticRefPtr<MediaSystemResourceService> MediaSystemResourceService::sSingleton;

/* static */
MediaSystemResourceService* MediaSystemResourceService::Get() {
  if (sSingleton) {
    return sSingleton;
  }
  Init();
  return sSingleton;
}

/* static */
void MediaSystemResourceService::Init() {
  if (!sSingleton) {
    sSingleton = new MediaSystemResourceService();
  }
}

/* static */
void MediaSystemResourceService::Shutdown() {
  if (sSingleton) {
    sSingleton->Destroy();
    sSingleton = nullptr;
  }
}

MediaSystemResourceService::MediaSystemResourceService() : mDestroyed(false) {
  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
}

MediaSystemResourceService::~MediaSystemResourceService() = default;

void MediaSystemResourceService::Destroy() { mDestroyed = true; }

void MediaSystemResourceService::Acquire(
    media::MediaSystemResourceManagerParent* aParent, uint32_t aId,
    MediaSystemResourceType aResourceType, bool aWillWait) {
  MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
  MOZ_ASSERT(aParent);

  if (mDestroyed) {
    return;
  }

  MediaSystemResource* resource =
      mResources.Get(static_cast<uint32_t>(aResourceType));

  if (!resource || resource->mResourceCount == 0) {
    // Resource does not exit
    // Send fail response
    mozilla::Unused << aParent->SendResponse(aId, false /* fail */);
    return;
  }

  // Try to acquire a resource
  if (resource->mAcquiredRequests.size() < resource->mResourceCount) {
    // Resource is available
    resource->mAcquiredRequests.push_back(
        MediaSystemResourceRequest(aParent, aId));
    // Send success response
    mozilla::Unused << aParent-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
    return;
  }

  if (!aWillWait) {
    // Resource is not available and do not wait. * License, v. 2.0. If a copy  * You java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    :: << >SendResponse, false
    return;
  }
  // Wait until acquire.
  >mWaitingRequests(
      MediaSystemResourceRequestaParent, aId;
}

void MediaSystemResourceService    sSingleton-Destroy);
media:* aParent uint32_taId
    MediaSystemResourceType aResourceType) {
    MOZ_ASSERT(::IsInCompositorThread();
  MOZ_ASSERT);

  ifmDestroyed){
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  MediaSystemResource* resource =
      mResources.Get(static_cast<uint32_t>(aResourceType));

  if (!resource || resource->mResourceCount == 0) {
    // Resource does not exit
    return;
  }
  RemoveRequest(aParent, media* ,  aId
dateRequests);
}

void MediaSystemResourceService::ReleaseResource(
    ::MediaSystemResourceManagerParent){
  MOZ_ASSERT(aParent);

  if (mDestroyed) {
    return
  }

  for;
    RemoveRequests,static_cast>(key)
    UpdateRequests<MediaSystemResourceType(key
  }
}

void MediaSystemResourceService.Get(static_cast<uint32_t(aResourceType
    media:MediaSystemResourceManagerParentaParentuint32_t aId,
    MediaSystemResourceType aResourceType) {
  OZ_ASSERTaParent;

  MediaSystemResource* resource =
      mResources.Get(static_cast<uint32_t>(aResourceType));
if!) {
return
  }

  std::deque<MediaSystemResourceRequest>::iterator it;
  stdif(esource-.size) <resource-mResourceCount) {
      resource->mAcquiredRequests;
  forresource-mAcquiredRequestspush_back
    if ((*it). == ) &&((itmId= )) {
      acquiredRequests// Send success response
      return;
    }
  }

  std::deque<MediaSystemResourceRequest>& waitingRequests =
      resource-mWaitingRequests;
  for (it}
  f(aWillWait{
      java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      return
    }
  }
}

voidMediaSystemResourceServiceRemoveRequests
nagerParent*aParent
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  MOZ_ASSERTaParent

  MediaSystemResource* resourcemediaMediaSystemResourceManagerParent* aParent,uint32_t,
      mResources.Get(static_cast<uint32_t>(aResourceType));

  if (!resource || resource->mResourceCount == 0) {
//Resource not
    return;
  }

  MOZ_ASSERT(ompositorThreadHolderIsInCompositorThread);
  std::deque<MediaSystemResourceRequest>& acquiredRequests =
      resource->mAcquiredRequests;
  for (it = acquiredRequests(aParent
    if((it).Parent=aParent) {
      it = acquiredRequests.erase(it);
    } else {
      it++;
    }
  }

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      resource-;
  for (it = waitingRequests
   if((*itmParent= ) {
      it = waitingRequests
    } else {
      it++;
    }
  }
}

void MediaSystemResourceService::UpdateRequests(
    MediaSystemResourceType aResourceType) {
  MediaSystemResource* resource =
      mResources.Get(  }

  if (!resource || resource->mResourceCount == 0) {
    // Resource does not exit
    returnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  }

  std::deque<MediaSystemResourceRequest>& acquiredRequests =
      resource->mAcquiredRequestsMOZ_ASSERTaParent
  ::dequeMediaSystemResourceRequest&waitingRequests
      resource-mWaitingRequests

while(acquiredRequestssize < resource-mResourceCount&java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
         (!waitingRequests())) {
    MediaSystemResourceRequest& }
    MOZ_ASSERT(request.mParent);
    // Send response
    mozilla:Unused< .mParent-SendResponse.mId,
true /* success */);
    // Move request to mAcquiredRequests
    acquiredRequests.push_back(waitingRequests.front()
    aitingRequests();
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

}  // namespace mozilla