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 file,
* You can obtain one at */
#ifndef mozilla_dom_FakeString_h__
#define mozilla_dom_FakeString_h__
#include "nsString.h"
#include "nsStringBuffer.h"
#include "mozilla/RefPtr.h"
#include "mozilla/Span.h"
#include "js/String.h"
#include "nsTStringRepr.h"
namespace mozilla::dom::binding_detail {
// A struct that has a layout compatible with nsAString, so that
// reinterpret-casting a FakeString as a const nsAString is safe, but much
// faster constructor and destructor behavior. FakeString uses inline storage
// for small strings and an nsStringBuffer for longer strings. It can also
// point to a literal (static-lifetime) string that's compiled into the binary,
// or point at the buffer of an nsAString whose lifetime is longer than that of
// the FakeString.
template <typename CharT>
struct FakeString {
using char_type = CharT;
using string_type = nsTString<CharT>;
using size_type = typename string_type::size_type;
using DataFlags = typename string_type::DataFlags;
using ClassFlags = typename string_type::ClassFlags;
using AString = nsTSubstring<CharT>;
using LengthStorage = mozilla::detail::nsTStringLengthStorage<CharT>;
static const size_t kInlineCapacity = 64;
using AutoString = nsTAutoStringN<CharT, kInlineCapacity>;
: mDataFlags(DataFlags::TERMINATED),
mInlineCapacity(kInlineCapacity - 1) {}
~FakeString() {
if (mDataFlags & DataFlags::REFCOUNTED) {
// Share aString's string buffer, if it has one; otherwise, make this string
// depend upon aString's data. aString should outlive this instance of
// FakeString.
void ShareOrDependUpon(const AString& aString) {
RefPtr<nsStringBuffer> sharedBuffer = nsStringBuffer::FromString(aString);
if (!sharedBuffer) {
InitData(aString.BeginReading(), aString.Length());
if (!aString.IsTerminated()) {
mDataFlags &= ~DataFlags::TERMINATED;
} else {
AssignFromStringBuffer(sharedBuffer.forget(), aString.Length());
void Truncate() { InitData(string_type::char_traits::sEmptyBuffer, 0); }
void SetIsVoid(bool aValue) {
MOZ_ASSERT(aValue, "We don't support SetIsVoid(false) on FakeString!");
mDataFlags |= DataFlags::VOIDED;
char_type* BeginWriting() {
return mData;
size_type Length() const { return mLength; }
operator mozilla::Span<const char_type>() const {
// Explicitly specify template argument here to avoid instantiating
// Span<char_type> first and then implicitly converting to Span<const
// char_type>
return mozilla::Span<const char_type>{mData, Length()};
mozilla::Result<mozilla::BulkWriteHandle<CharT>, nsresult> BulkWrite(
size_type aCapacity, size_type aPrefixToPreserve, bool aAllowShrinking) {
InitData(mStorage, 0);
mDataFlags |= DataFlags::INLINE;
return ToAStringPtr()->BulkWrite(aCapacity, aPrefixToPreserve,
// Reserve space to write aLength chars, not including null-terminator.
bool SetLength(size_type aLength, mozilla::fallible_t const&) {
// Use mStorage for small strings.
if (aLength < kInlineCapacity) {
InitData(mStorage, aLength);
mDataFlags |= DataFlags::INLINE;
} else {
RefPtr<nsStringBuffer> buf =
nsStringBuffer::Alloc((aLength + 1) * sizeof(char_type));
if (MOZ_UNLIKELY(!buf)) {
return false;
AssignFromStringBuffer(buf.forget(), aLength);
mData[mLength] = char_type(0);
return true;
// Returns false on allocation failure.
bool EnsureMutable() {
if (IsMutable()) {
return true;
RefPtr<nsStringBuffer> buffer;
if (mDataFlags & DataFlags::REFCOUNTED) {
// Make sure we'll drop it when we're done.
buffer = dont_AddRef(nsStringBuffer::FromData(mData));
// And make sure we don't release it twice by accident.
const char_type* oldChars = mData;
mDataFlags = DataFlags::TERMINATED;
#ifdef DEBUG
// Reset mDataInitialized because we're explicitly reinitializing
// it via the SetLength call.
mDataInitialized = false;
#endif // DEBUG
// SetLength will make sure we have our own buffer to work with. Note that
// we may be transitioning from having a (short) readonly stringbuffer to
// our inline storage or whatnot. That's all fine; SetLength is responsible
// for setting up our flags correctly.
if (!SetLength(Length(), fallible)) {
return false;
MOZ_ASSERT(oldChars != mData, "Should have new chars now!");
MOZ_ASSERT(IsMutable(), "Why are we still not mutable?");
memcpy(mData, oldChars, Length() * sizeof(char_type));
return true;
void AssignFromStringBuffer(already_AddRefed<nsStringBuffer> aBuffer,
size_t aLength) {
InitData(static_cast<char_type*>(aBuffer.take()->Data()), aLength);
mDataFlags |= DataFlags::REFCOUNTED;
// The preferred way to assign literals to a FakeString. This should only be
// called with actual C++ literal strings (i.e. u"stuff") or character arrays
// that originally come from passing such literal strings.
template <int N>
void AssignLiteral(const char_type (&aData)[N]) {
AssignLiteral(aData, N - 1);
// Assign a literal to a FakeString when it's not an actual literal
// in the code, but is known to be a literal somehow (e.g. it came
// from an nsAString that tested true for IsLiteral()).
void AssignLiteral(const char_type* aData, size_t aLength) {
InitData(aData, aLength);
mDataFlags |= DataFlags::LITERAL;
// If this ever changes, change the corresponding code in the
// Optional<nsA[C]String> specialization as well.
const AString* ToAStringPtr() const {
return reinterpret_cast<const string_type*>(this);
operator const AString&() const { return *ToAStringPtr(); }
AString* ToAStringPtr() { return reinterpret_cast<string_type*>(this); }
// mData is left uninitialized for optimization purposes.
MOZ_INIT_OUTSIDE_CTOR char_type* mData;
// mLength is left uninitialized for optimization purposes.
MOZ_INIT_OUTSIDE_CTOR uint32_t mLength;
DataFlags mDataFlags;
const ClassFlags mClassFlags;
const uint32_t mInlineCapacity;
char_type mStorage[kInlineCapacity];
#ifdef DEBUG
bool mDataInitialized = false;
#endif // DEBUG
FakeString(const FakeString& other) = delete;
void operator=(const FakeString& other) = delete;
void InitData(const char_type* aData, size_type aLength) {
MOZ_ASSERT(aLength <= LengthStorage::kMax, "string is too large");
MOZ_ASSERT(mDataFlags == DataFlags::TERMINATED);
mData = const_cast<char_type*>(aData);
mLength = uint32_t(aLength);
#ifdef DEBUG
mDataInitialized = true;
#endif // DEBUG
bool IsMutable() {
return (mDataFlags & DataFlags::INLINE) ||
((mDataFlags & DataFlags::REFCOUNTED) &&
friend class NonNull<AString>;
// A class to use for our static asserts to ensure our object layout
// matches that of nsString.
class StringAsserter;
friend class StringAsserter;
class StringAsserter : public AutoString {
static void StaticAsserts() {
static_assert(sizeof(AutoString) == sizeof(FakeString),
"Should be binary compatible with nsTAutoString");
offsetof(FakeString, mInlineCapacity) == sizeof(string_type),
"FakeString should include all nsString members");
offsetof(FakeString, mData) == offsetof(StringAsserter, mData),
"Offset of mData should match");
offsetof(FakeString, mLength) == offsetof(StringAsserter, mLength),
"Offset of mLength should match");
static_assert(offsetof(FakeString, mDataFlags) ==
offsetof(StringAsserter, mDataFlags),
"Offset of mDataFlags should match");
static_assert(offsetof(FakeString, mClassFlags) ==
offsetof(StringAsserter, mClassFlags),
"Offset of mClassFlags should match");
static_assert(offsetof(FakeString, mInlineCapacity) ==
offsetof(StringAsserter, mInlineCapacity),
"Offset of mInlineCapacity should match");
offsetof(FakeString, mStorage) == offsetof(StringAsserter, mStorage),
"Offset of mStorage should match");
static_assert(JS::MaxStringLength <= LengthStorage::kMax,
"JS::MaxStringLength fits in a nsTString");
} // namespace mozilla::dom::binding_detail
template <typename CharT>
inline void AssignFromStringBuffer(
nsStringBuffer* aBuffer, size_t aLength,
mozilla::dom::binding_detail::FakeString<CharT>& aDest) {
aDest.AssignFromStringBuffer(do_AddRef(aBuffer), aLength);
#endif /* mozilla_dom_FakeString_h__ */