tor-browser

ResourceQueue.cpp (6269B)

---

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

#include "MediaData.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/IntegerPrintfMacros.h"
#include "mozilla/Logging.h"
#include "mozilla/Sprintf.h"

extern mozilla::LogModule* GetSourceBufferResourceLog();

#define SBR_DEBUG(arg, ...)                                       \
 MOZ_LOG(GetSourceBufferResourceLog(), mozilla::LogLevel::Debug, \
         ("ResourceQueue(%p)::%s: " arg, this, __func__, ##__VA_ARGS__))
#define SBR_DEBUGV(arg, ...)                                        \
 MOZ_LOG(GetSourceBufferResourceLog(), mozilla::LogLevel::Verbose, \
         ("ResourceQueue(%p)::%s: " arg, this, __func__, ##__VA_ARGS__))

namespace mozilla {

ResourceItem::ResourceItem(const MediaSpan& aData, uint64_t aOffset)
   : mData(aData), mOffset(aOffset) {}

size_t ResourceItem::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
 return aMallocSizeOf(this);
}

class ResourceQueueDeallocator : public nsDequeFunctor<ResourceItem> {
 void operator()(ResourceItem* aObject) override { delete aObject; }
};

ResourceQueue::ResourceQueue()
   : nsDeque<ResourceItem>(new ResourceQueueDeallocator()),
     mLogicalLength(0),
     mOffset(0) {}

uint64_t ResourceQueue::GetOffset() { return mOffset; }

uint64_t ResourceQueue::GetLength() { return mLogicalLength; }

const uint8_t* ResourceQueue::GetContiguousAccess(int64_t aOffset,
                                                 size_t aSize) {
 uint32_t offset = 0;
 uint32_t start = GetAtOffset(aOffset, &offset);
 if (start >= GetSize()) {
   return nullptr;
 }
 ResourceItem* item = ResourceAt(start);
 if (offset + aSize > item->mData.Length()) {
   return nullptr;
 }
 return item->mData.Elements() + offset;
}

void ResourceQueue::CopyData(uint64_t aOffset, uint32_t aCount, char* aDest) {
 uint32_t offset = 0;
 uint32_t start = GetAtOffset(aOffset, &offset);
 size_t i = start;
 while (i < uint32_t(GetSize()) && aCount > 0) {
   ResourceItem* item = ResourceAt(i++);
   uint32_t bytes = std::min(aCount, uint32_t(item->mData.Length() - offset));
   if (bytes != 0) {
     memcpy(aDest, item->mData.Elements() + offset, bytes);
     offset = 0;
     aCount -= bytes;
     aDest += bytes;
   }
 }
}

void ResourceQueue::AppendItem(const MediaSpan& aData) {
 uint64_t offset = mLogicalLength;
 mLogicalLength += aData.Length();
 Push(new ResourceItem(aData, offset));
}

uint32_t ResourceQueue::Evict(uint64_t aOffset, uint32_t aSizeToEvict) {
 SBR_DEBUG("Evict(aOffset=%" PRIu64 ", aSizeToEvict=%u)", aOffset,
           aSizeToEvict);
 return EvictBefore(std::min(aOffset, mOffset + (uint64_t)aSizeToEvict));
}

uint32_t ResourceQueue::EvictBefore(uint64_t aOffset) {
 SBR_DEBUG("EvictBefore(%" PRIu64 ")", aOffset);
 uint32_t evicted = 0;
 while (GetSize()) {
   ResourceItem* item = ResourceAt(0);
   SBR_DEBUG("item=%p length=%zu offset=%" PRIu64, item, item->mData.Length(),
             mOffset);
   if (item->mData.Length() + mOffset >= aOffset) {
     if (aOffset <= mOffset) {
       break;
     }
     uint32_t offset = aOffset - mOffset;
     mOffset += offset;
     evicted += offset;
     item->mData.RemoveFront(offset);
     item->mOffset += offset;
     break;
   }
   mOffset += item->mData.Length();
   evicted += item->mData.Length();
   delete PopFront();
 }
 return evicted;
}

uint32_t ResourceQueue::EvictAll() {
 SBR_DEBUG("EvictAll()");
 uint32_t evicted = 0;
 while (GetSize()) {
   ResourceItem* item = ResourceAt(0);
   SBR_DEBUG("item=%p length=%zu offset=%" PRIu64, item, item->mData.Length(),
             mOffset);
   mOffset += item->mData.Length();
   evicted += item->mData.Length();
   delete PopFront();
 }
 return evicted;
}

size_t ResourceQueue::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
 // Calculate the size of the internal deque.
 size_t size = nsDeque<ResourceItem>::SizeOfExcludingThis(aMallocSizeOf);

 // Sum the ResourceItems. The ResourceItems's MediaSpans may share the
 // same underlying MediaByteBuffers, so we need to de-dupe the buffers
 // in order to report an accurate size.
 nsTArray<MediaByteBuffer*> buffers;
 for (uint32_t i = 0; i < uint32_t(GetSize()); ++i) {
   const ResourceItem* item = ResourceAt(i);
   size += item->SizeOfIncludingThis(aMallocSizeOf);
   if (!buffers.Contains(item->mData.Buffer())) {
     buffers.AppendElement(item->mData.Buffer());
   }
 }

 for (MediaByteBuffer* buffer : buffers) {
   size += buffer->ShallowSizeOfExcludingThis(aMallocSizeOf);
 }

 return size;
}

#if defined(DEBUG)
void ResourceQueue::Dump(const char* aPath) {
 for (uint32_t i = 0; i < uint32_t(GetSize()); ++i) {
   ResourceItem* item = ResourceAt(i);

   char buf[255];
   SprintfLiteral(buf, "%s/%08u.bin", aPath, i);
   FILE* fp = fopen(buf, "wb");
   if (!fp) {
     return;
   }
   (void)fwrite(item->mData.Elements(), item->mData.Length(), 1, fp);
   fclose(fp);
 }
}
#endif

ResourceItem* ResourceQueue::ResourceAt(uint32_t aIndex) const {
 return static_cast<ResourceItem*>(ObjectAt(aIndex));
}

uint32_t ResourceQueue::GetAtOffset(uint64_t aOffset,
                                   uint32_t* aResourceOffset) const {
 MOZ_RELEASE_ASSERT(aOffset >= mOffset);

 size_t hi = GetSize();
 size_t lo = 0;
 while (lo < hi) {
   size_t mid = lo + (hi - lo) / 2;
   const ResourceItem* resource = ResourceAt(mid);
   if (resource->mOffset <= aOffset &&
       aOffset < resource->mOffset + resource->mData.Length()) {
     if (aResourceOffset) {
       *aResourceOffset = aOffset - resource->mOffset;
     }
     return uint32_t(mid);
   }
   if (resource->mOffset + resource->mData.Length() <= aOffset) {
     lo = mid + 1;
   } else {
     hi = mid;
   }
 }

 return uint32_t(GetSize());
}

ResourceItem* ResourceQueue::PopFront() {
 return nsDeque<ResourceItem>::PopFront();
}

#undef SBR_DEBUG
#undef SBR_DEBUGV

}  // namespace mozilla