Revision 806517f1d13e19fc2fee667ded674db7d01693b0 authored by ffxbld on 19 March 2020, 13:38:51 UTC, committed by ffxbld on 19 March 2020, 13:38:51 UTC
Differential Revision: https://phabricator.services.mozilla.com/D67473
1 parent 8c6e5e6
MemoryBlobImpl.h
/* -*- 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 "nsICloneableInputStream.h"
#include "nsIInputStream.h"
#include "nsIIPCSerializableInputStream.h"
#include "nsIMemoryReporter.h"
#include "nsISeekableStream.h"
namespace mozilla {
namespace dom {
class MemoryBlobImpl final : public BaseBlobImpl {
public:
NS_INLINE_DECL_REFCOUNTING_INHERITED(MemoryBlobImpl, BaseBlobImpl)
MemoryBlobImpl(void* aMemoryBuffer, uint64_t aLength, const nsAString& aName,
const nsAString& aContentType, int64_t aLastModifiedDate)
: BaseBlobImpl(NS_LITERAL_STRING("MemoryBlobImpl"), aName, aContentType,
aLength, aLastModifiedDate),
mDataOwner(new DataOwner(aMemoryBuffer, aLength)) {
MOZ_ASSERT(mDataOwner && mDataOwner->mData, "must have data");
}
MemoryBlobImpl(void* aMemoryBuffer, uint64_t aLength,
const nsAString& aContentType)
: BaseBlobImpl(NS_LITERAL_STRING("MemoryBlobImpl"), aContentType,
aLength),
mDataOwner(new DataOwner(aMemoryBuffer, aLength)) {
MOZ_ASSERT(mDataOwner && mDataOwner->mData, "must have data");
}
virtual void CreateInputStream(nsIInputStream** aStream,
ErrorResult& aRv) override;
virtual already_AddRefed<BlobImpl> CreateSlice(uint64_t aStart,
uint64_t aLength,
const nsAString& aContentType,
ErrorResult& aRv) override;
virtual bool IsMemoryFile() const override { return true; }
size_t GetAllocationSize() const override { return mLength; }
size_t GetAllocationSize(
FallibleTArray<BlobImpl*>& aVisitedBlobImpls) const override {
return GetAllocationSize();
}
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;
static mozilla::StaticAutoPtr<mozilla::LinkedList<DataOwner> > sDataOwners;
static bool sMemoryReporterRegistered;
void* mData;
uint64_t mLength;
};
class DataOwnerAdapter final : public nsIInputStream,
public nsISeekableStream,
public nsIIPCSerializableInputStream,
public nsICloneableInputStream {
typedef MemoryBlobImpl::DataOwner DataOwner;
public:
static nsresult Create(DataOwner* aDataOwner, uint32_t aStart,
uint32_t aLength, nsIInputStream** _retval);
NS_DECL_THREADSAFE_ISUPPORTS
// These are mandatory.
NS_FORWARD_NSIINPUTSTREAM(mStream->)
NS_FORWARD_NSISEEKABLESTREAM(mSeekableStream->)
NS_FORWARD_NSITELLABLESTREAM(mSeekableStream->)
NS_FORWARD_NSICLONEABLEINPUTSTREAM(mCloneableInputStream->)
// This is optional. We use a conditional QI to keep it from being called
// if the underlying stream doesn't support it.
NS_FORWARD_NSIIPCSERIALIZABLEINPUTSTREAM(mSerializableInputStream->)
private:
~DataOwnerAdapter() {}
DataOwnerAdapter(DataOwner* aDataOwner, nsIInputStream* aStream)
: mDataOwner(aDataOwner),
mStream(aStream),
mSeekableStream(do_QueryInterface(aStream)),
mSerializableInputStream(do_QueryInterface(aStream)),
mCloneableInputStream(do_QueryInterface(aStream)) {
MOZ_ASSERT(mSeekableStream, "Somebody gave us the wrong stream!");
}
RefPtr<DataOwner> mDataOwner;
nsCOMPtr<nsIInputStream> mStream;
nsCOMPtr<nsISeekableStream> mSeekableStream;
nsCOMPtr<nsIIPCSerializableInputStream> mSerializableInputStream;
nsCOMPtr<nsICloneableInputStream> mCloneableInputStream;
};
private:
// Create slice
MemoryBlobImpl(const MemoryBlobImpl* aOther, uint64_t aStart,
uint64_t aLength, const nsAString& aContentType)
: BaseBlobImpl(NS_LITERAL_STRING("MemoryBlobImpl"), aContentType,
aOther->mStart + aStart, aLength),
mDataOwner(aOther->mDataOwner) {
MOZ_ASSERT(mDataOwner && mDataOwner->mData, "must have data");
mImmutable = aOther->mImmutable;
}
~MemoryBlobImpl() {}
// Used when backed by a memory store
RefPtr<DataOwner> mDataOwner;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_MemoryBlobImpl_h
![swh spinner](/static/img/swh-spinner.gif)
Computing file changes ...