summaryrefslogtreecommitdiffstats
path: root/dom/file/MemoryBlobImpl.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/file/MemoryBlobImpl.h')
-rw-r--r--dom/file/MemoryBlobImpl.h160
1 files changed, 160 insertions, 0 deletions
diff --git a/dom/file/MemoryBlobImpl.h b/dom/file/MemoryBlobImpl.h
new file mode 100644
index 0000000000..29d812feee
--- /dev/null
+++ b/dom/file/MemoryBlobImpl.h
@@ -0,0 +1,160 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_MemoryBlobImpl_h
+#define mozilla_dom_MemoryBlobImpl_h
+
+#include "mozilla/dom/BaseBlobImpl.h"
+#include "mozilla/LinkedList.h"
+#include "mozilla/StaticMutex.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/StreamBufferSource.h"
+#include "nsCOMPtr.h"
+#include "nsICloneableInputStream.h"
+#include "nsIInputStream.h"
+#include "nsIIPCSerializableInputStream.h"
+#include "nsISeekableStream.h"
+
+namespace mozilla::dom {
+
+class MemoryBlobImpl final : public BaseBlobImpl {
+ public:
+ NS_INLINE_DECL_REFCOUNTING_INHERITED(MemoryBlobImpl, BaseBlobImpl)
+
+ // File constructor.
+ static already_AddRefed<MemoryBlobImpl> CreateWithLastModifiedNow(
+ void* aMemoryBuffer, uint64_t aLength, const nsAString& aName,
+ const nsAString& aContentType, RTPCallerType aRTPCallerType);
+
+ // File constructor with custom lastModified attribue value. You should
+ // probably use CreateWithLastModifiedNow() instead of this one.
+ static already_AddRefed<MemoryBlobImpl> CreateWithCustomLastModified(
+ void* aMemoryBuffer, uint64_t aLength, const nsAString& aName,
+ const nsAString& aContentType, int64_t aLastModifiedDate);
+
+ // Blob constructor.
+ MemoryBlobImpl(void* aMemoryBuffer, uint64_t aLength,
+ const nsAString& aContentType)
+ : BaseBlobImpl(aContentType, aLength),
+ mDataOwner(new DataOwner(aMemoryBuffer, aLength)) {
+ MOZ_ASSERT(mDataOwner && mDataOwner->mData, "must have data");
+ }
+
+ void CreateInputStream(nsIInputStream** aStream,
+ ErrorResult& aRv) const override;
+
+ already_AddRefed<BlobImpl> CreateSlice(uint64_t aStart, uint64_t aLength,
+ const nsAString& aContentType,
+ ErrorResult& aRv) const override;
+
+ bool IsMemoryFile() const override { return true; }
+
+ size_t GetAllocationSize() const override { return mLength; }
+
+ size_t GetAllocationSize(
+ FallibleTArray<BlobImpl*>& aVisitedBlobImpls) const override {
+ return GetAllocationSize();
+ }
+
+ void GetBlobImplType(nsAString& aBlobImplType) const override {
+ aBlobImplType = u"MemoryBlobImpl"_ns;
+ }
+
+ class DataOwner final : public mozilla::LinkedListElement<DataOwner> {
+ public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DataOwner)
+ DataOwner(void* aMemoryBuffer, uint64_t aLength)
+ : mData(aMemoryBuffer), mLength(aLength) {
+ mozilla::StaticMutexAutoLock lock(sDataOwnerMutex);
+
+ if (!sDataOwners) {
+ sDataOwners = new mozilla::LinkedList<DataOwner>();
+ EnsureMemoryReporterRegistered();
+ }
+ sDataOwners->insertBack(this);
+ }
+
+ private:
+ // Private destructor, to discourage deletion outside of Release():
+ ~DataOwner() {
+ mozilla::StaticMutexAutoLock lock(sDataOwnerMutex);
+
+ remove();
+ if (sDataOwners->isEmpty()) {
+ // Free the linked list if it's empty.
+ sDataOwners = nullptr;
+ }
+
+ free(mData);
+ }
+
+ public:
+ static void EnsureMemoryReporterRegistered();
+
+ // sDataOwners and sMemoryReporterRegistered may only be accessed while
+ // holding sDataOwnerMutex! You also must hold the mutex while touching
+ // elements of the linked list that DataOwner inherits from.
+ static mozilla::StaticMutex sDataOwnerMutex MOZ_UNANNOTATED;
+ static mozilla::StaticAutoPtr<mozilla::LinkedList<DataOwner> > sDataOwners;
+ static bool sMemoryReporterRegistered;
+
+ void* mData;
+ uint64_t mLength;
+ };
+
+ class DataOwnerAdapter final : public StreamBufferSource {
+ using DataOwner = MemoryBlobImpl::DataOwner;
+
+ public:
+ static nsresult Create(DataOwner* aDataOwner, size_t aStart, size_t aLength,
+ nsIInputStream** _retval);
+
+ Span<const char> Data() override { return mData; }
+
+ // This StreamBufferSource is owning, as the `mData` span references the
+ // immutable data buffer owned by `mDataOwner` which is being kept alive.
+ bool Owning() override { return true; }
+
+ // The memory usage from `DataOwner` is reported elsewhere, so we don't need
+ // to record it here.
+ size_t SizeOfExcludingThisEvenIfShared(MallocSizeOf) override { return 0; }
+
+ private:
+ ~DataOwnerAdapter() override = default;
+
+ DataOwnerAdapter(DataOwner* aDataOwner, Span<const char> aData)
+ : mDataOwner(aDataOwner), mData(aData) {}
+
+ RefPtr<DataOwner> mDataOwner;
+ Span<const char> mData;
+ };
+
+ private:
+ // File constructor.
+ MemoryBlobImpl(void* aMemoryBuffer, uint64_t aLength, const nsAString& aName,
+ const nsAString& aContentType, int64_t aLastModifiedDate)
+ : BaseBlobImpl(aName, aContentType, aLength, aLastModifiedDate),
+ mDataOwner(new DataOwner(aMemoryBuffer, aLength)) {
+ MOZ_ASSERT(mDataOwner && mDataOwner->mData, "must have data");
+ }
+
+ // Create slice
+ MemoryBlobImpl(const MemoryBlobImpl* aOther, uint64_t aStart,
+ uint64_t aLength, const nsAString& aContentType)
+ : BaseBlobImpl(aContentType, aOther->mStart + aStart, aLength),
+ mDataOwner(aOther->mDataOwner) {
+ MOZ_ASSERT(mDataOwner && mDataOwner->mData, "must have data");
+ }
+
+ ~MemoryBlobImpl() override = default;
+
+ // Used when backed by a memory store
+ RefPtr<DataOwner> mDataOwner;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_MemoryBlobImpl_h