Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include "XMLHttpRequestString.h"
#include "js/String.h"
#include "mozilla/dom/DOMString.h"
#include "nsISupportsImpl.h"
namespace mozilla::dom {
class XMLHttpRequestStringBuffer final {
friend class XMLHttpRequestStringSnapshot;
friend class XMLHttpRequestStringWriterHelper;
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(XMLHttpRequestStringBuffer)
NS_DECL_OWNINGTHREAD
XMLHttpRequestStringBuffer() : mMutex("XMLHttpRequestStringBuffer::mMutex") {}
uint32_t Length() {
MutexAutoLock lock(mMutex);
return mData.Length();
}
uint32_t UnsafeLength() const MOZ_NO_THREAD_SAFETY_ANALYSIS {
return mData.Length();
}
mozilla::Result<mozilla::BulkWriteHandle<char16_t>, nsresult> UnsafeBulkWrite(
uint32_t aCapacity) MOZ_NO_THREAD_SAFETY_ANALYSIS {
return mData.BulkWrite(aCapacity, UnsafeLength(), false);
}
void Append(const nsAString& aString) {
NS_ASSERT_OWNINGTHREAD(XMLHttpRequestStringBuffer);
MutexAutoLock lock(mMutex);
mData.Append(aString);
}
[[nodiscard]] bool GetAsString(nsAString& aString) {
MutexAutoLock lock(mMutex);
return aString.Assign(mData, mozilla::fallible);
}
size_t SizeOfThis(MallocSizeOf aMallocSizeOf) {
MutexAutoLock lock(mMutex);
return mData.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
}
[[nodiscard]] bool GetAsString(DOMString& aString, uint32_t aLength) {
MutexAutoLock lock(mMutex);
MOZ_ASSERT(aLength <= mData.Length());
// DOMString.
if (StringBuffer* buf = mData.GetStringBuffer()) {
// We have to use SetStringBuffer, because once we release our mutex mData
// can get mutated from some other thread while the DOMString is still
// alive.
aString.SetStringBuffer(buf, aLength);
return true;
}
// We can get here if mData is empty. In that case it won't have an
// nsStringBuffer....
MOZ_ASSERT(mData.IsEmpty());
return aString.AsAString().Assign(mData.BeginReading(), aLength,
mozilla::fallible);
}
void CreateSnapshot(XMLHttpRequestStringSnapshot& aSnapshot) {
MutexAutoLock lock(mMutex);
aSnapshot.Set(this, mData.Length());
}
private:
~XMLHttpRequestStringBuffer() = default;
Mutex mMutex;
// The following member variable is protected by mutex.
nsString mData MOZ_GUARDED_BY(mMutex);
};
// ---------------------------------------------------------------------------
// XMLHttpRequestString
XMLHttpRequestString::XMLHttpRequestString()
: mBuffer(new XMLHttpRequestStringBuffer()) {}
XMLHttpRequestString::~XMLHttpRequestString() = default;
void XMLHttpRequestString::Truncate() {
mBuffer = new XMLHttpRequestStringBuffer();
}
uint32_t XMLHttpRequestString::Length() const { return mBuffer->Length(); }
void XMLHttpRequestString::Append(const nsAString& aString) {
mBuffer->Append(aString);
}
bool XMLHttpRequestString::GetAsString(nsAString& aString) const {
return mBuffer->GetAsString(aString);
}
size_t XMLHttpRequestString::SizeOfThis(MallocSizeOf aMallocSizeOf) const {
return mBuffer->SizeOfThis(aMallocSizeOf);
}
bool XMLHttpRequestString::IsEmpty() const { return !mBuffer->Length(); }
void XMLHttpRequestString::CreateSnapshot(
XMLHttpRequestStringSnapshot& aSnapshot) {
mBuffer->CreateSnapshot(aSnapshot);
}
// ---------------------------------------------------------------------------
// XMLHttpRequestStringSnapshot
XMLHttpRequestStringSnapshot::XMLHttpRequestStringSnapshot()
: mLength(0), mVoid(false) {}
XMLHttpRequestStringSnapshot::~XMLHttpRequestStringSnapshot() = default;
void XMLHttpRequestStringSnapshot::ResetInternal(bool aIsVoid) {
mBuffer = nullptr;
mLength = 0;
mVoid = aIsVoid;
}
void XMLHttpRequestStringSnapshot::Set(XMLHttpRequestStringBuffer* aBuffer,
uint32_t aLength) {
MOZ_ASSERT(aBuffer);
MOZ_ASSERT(aLength <= aBuffer->UnsafeLength());
mBuffer = aBuffer;
mLength = aLength;
mVoid = false;
}
bool XMLHttpRequestStringSnapshot::GetAsString(DOMString& aString) const {
if (mBuffer) {
MOZ_ASSERT(!mVoid);
return mBuffer->GetAsString(aString, mLength);
}
if (mVoid) {
aString.SetNull();
}
return true;
}
JSString* XMLHttpRequestStringSnapshot::GetAsJSStringCopy(
JSContext* aCx) const {
MutexAutoLock lock(mBuffer->mMutex);
return JS_NewUCStringCopyN(aCx, mBuffer->mData.BeginReading(),
mBuffer->mData.Length());
}
// ---------------------------------------------------------------------------
// XMLHttpRequestStringWriterHelper
XMLHttpRequestStringWriterHelper::XMLHttpRequestStringWriterHelper(
XMLHttpRequestString& aString)
: mBuffer(aString.mBuffer), mLock(aString.mBuffer->mMutex) {}
XMLHttpRequestStringWriterHelper::~XMLHttpRequestStringWriterHelper() = default;
uint32_t XMLHttpRequestStringWriterHelper::Length() const {
return mBuffer->UnsafeLength();
}
mozilla::Result<mozilla::BulkWriteHandle<char16_t>, nsresult>
XMLHttpRequestStringWriterHelper::BulkWrite(uint32_t aCapacity) {
return mBuffer->UnsafeBulkWrite(aCapacity);
}
} // namespace mozilla::dom