mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-19 16:25:38 +00:00
7753be203b
The old code assumes that it's OK to use nsAString::BeginWriting() to write past the string's logical length if the string has enough capacity. This is bogus, because the string doesn't know of data written past its logical length. The BulkWrite API has been created precisely for this purpose and allows orderly capacity-aware low-level writes to the string. MozReview-Commit-ID: BYQHl8Z9Fbd Differential Revision: https://phabricator.services.mozilla.com/D3886 --HG-- extra : moz-landing-system : lando
270 lines
5.8 KiB
C++
270 lines
5.8 KiB
C++
/* -*- 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 "XMLHttpRequestString.h"
|
|
#include "nsISupportsImpl.h"
|
|
#include "mozilla/dom/DOMString.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
class XMLHttpRequestStringBuffer final
|
|
{
|
|
friend class XMLHttpRequestStringWriterHelper;
|
|
friend class XMLHttpRequestStringSnapshotReaderHelper;
|
|
|
|
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
|
|
{
|
|
return mData.Length();
|
|
}
|
|
|
|
mozilla::BulkWriteHandle<char16_t>
|
|
UnsafeBulkWrite(uint32_t aCapacity, nsresult& aRv)
|
|
{
|
|
return mData.BulkWrite(aCapacity, UnsafeLength(), false, aRv);
|
|
}
|
|
|
|
void
|
|
Append(const nsAString& aString)
|
|
{
|
|
NS_ASSERT_OWNINGTHREAD(XMLHttpRequestStringBuffer);
|
|
|
|
MutexAutoLock lock(mMutex);
|
|
mData.Append(aString);
|
|
}
|
|
|
|
MOZ_MUST_USE bool
|
|
GetAsString(nsAString& aString)
|
|
{
|
|
MutexAutoLock lock(mMutex);
|
|
return aString.Assign(mData, mozilla::fallible);
|
|
}
|
|
|
|
size_t
|
|
SizeOfThis(MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
return mData.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
|
|
}
|
|
|
|
MOZ_MUST_USE bool
|
|
GetAsString(DOMString& aString, uint32_t aLength)
|
|
{
|
|
MutexAutoLock lock(mMutex);
|
|
MOZ_ASSERT(aLength <= mData.Length());
|
|
|
|
// XXX: Bug 1408793 suggests encapsulating the following sequence within
|
|
// DOMString.
|
|
nsStringBuffer* buf = nsStringBuffer::FromString(mData);
|
|
if (buf) {
|
|
// 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()
|
|
{}
|
|
|
|
nsString& UnsafeData()
|
|
{
|
|
return mData;
|
|
}
|
|
|
|
Mutex mMutex;
|
|
|
|
// The following member variable is protected by mutex.
|
|
nsString mData;
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// XMLHttpRequestString
|
|
|
|
XMLHttpRequestString::XMLHttpRequestString()
|
|
: mBuffer(new XMLHttpRequestStringBuffer())
|
|
{
|
|
}
|
|
|
|
XMLHttpRequestString::~XMLHttpRequestString()
|
|
{
|
|
}
|
|
|
|
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()
|
|
{
|
|
}
|
|
|
|
XMLHttpRequestStringSnapshot&
|
|
XMLHttpRequestStringSnapshot::operator=(const XMLHttpRequestStringSnapshot& aOther)
|
|
{
|
|
mBuffer = aOther.mBuffer;
|
|
mLength = aOther.mLength;
|
|
mVoid = aOther.mVoid;
|
|
return *this;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// XMLHttpRequestStringWriterHelper
|
|
|
|
XMLHttpRequestStringWriterHelper::XMLHttpRequestStringWriterHelper(XMLHttpRequestString& aString)
|
|
: mBuffer(aString.mBuffer)
|
|
, mLock(aString.mBuffer->mMutex)
|
|
{
|
|
}
|
|
|
|
uint32_t
|
|
XMLHttpRequestStringWriterHelper::Length() const
|
|
{
|
|
return mBuffer->UnsafeLength();
|
|
}
|
|
|
|
mozilla::BulkWriteHandle<char16_t>
|
|
XMLHttpRequestStringWriterHelper::BulkWrite(uint32_t aCapacity, nsresult& aRv)
|
|
{
|
|
return mBuffer->UnsafeBulkWrite(aCapacity, aRv);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// XMLHttpRequestStringReaderHelper
|
|
|
|
XMLHttpRequestStringSnapshotReaderHelper::XMLHttpRequestStringSnapshotReaderHelper(XMLHttpRequestStringSnapshot& aSnapshot)
|
|
: mBuffer(aSnapshot.mBuffer)
|
|
, mLock(aSnapshot.mBuffer->mMutex)
|
|
{
|
|
}
|
|
|
|
const char16_t*
|
|
XMLHttpRequestStringSnapshotReaderHelper::Buffer() const
|
|
{
|
|
return mBuffer->UnsafeData().BeginReading();
|
|
}
|
|
|
|
uint32_t
|
|
XMLHttpRequestStringSnapshotReaderHelper::Length() const
|
|
{
|
|
return mBuffer->UnsafeLength();
|
|
}
|
|
|
|
} // dom namespace
|
|
} // mozilla namespace
|