/* -*- 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
