private:

RefPtr<nsHtml5TreeOpExecutor> mExecutor;

public:

explicit nsHtml5LoadFlusher(nsHtml5TreeOpExecutor* aExecutor)

: Runnable("nsHtml5LoadFlusher"), mExecutor(aExecutor) {}

NS_IMETHOD Run() override {

mExecutor->FlushSpeculativeLoads();

return NS_OK;

}

nsHtml5Parser* aOwner,

eParserMode aMode)

: mSniffingLength(0),

mBomState(eBomState::BOM_SNIFFING_NOT_STARTED),

mCharsetSource(kCharsetUninitialized),

mEncoding(WINDOWS_1252_ENCODING),

mFeedChardet(true),

mReparseForbidden(false),

mLastBuffer(nullptr), // Will be filled when starting

mExecutor(aExecutor),

mTreeBuilder(new nsHtml5TreeBuilder(

(aMode == VIEW_SOURCE_HTML || aMode == VIEW_SOURCE_XML)

? nullptr

: mExecutor->GetStage(),

aMode == NORMAL ? mExecutor->GetStage() : nullptr)),

mTokenizer(new nsHtml5Tokenizer(mTreeBuilder, aMode == VIEW_SOURCE_XML)),

mTokenizerMutex("nsHtml5StreamParser mTokenizerMutex"),

mOwner(aOwner),

mLastWasCR(false),

mStreamState(eHtml5StreamState::STREAM_NOT_STARTED),

mSpeculating(false),

mAtEOF(false),

mSpeculationMutex("nsHtml5StreamParser mSpeculationMutex"),

mSpeculationFailureCount(0),

mLocalFileBytesBuffered(0),

mTerminated(false),

mInterrupted(false),

mTerminatedMutex("nsHtml5StreamParser mTerminatedMutex"),

mEventTarget(nsHtml5Module::GetStreamParserThread()->SerialEventTarget()),

mExecutorFlusher(new nsHtml5ExecutorFlusher(aExecutor)),

mLoadFlusher(new nsHtml5LoadFlusher(aExecutor)),

mJapaneseDetector(mozilla::JapaneseDetector::Create(

StaticPrefs::intl_charset_detector_iso2022jp_allowed())),

mInitialEncodingWasFromParentFrame(false),

mHasHadErrors(false),

mDecodingLocalFileAsUTF8(false),

mFlushTimer(NS_NewTimer(mEventTarget)),

mFlushTimerMutex("nsHtml5StreamParser mFlushTimerMutex"),

mFlushTimerArmed(false),

mFlushTimerEverFired(false),

mMode(aMode),

mSkipContentSniffing(false) {

NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");

#ifdef DEBUG

mAtomTable.SetPermittedLookupEventTarget(mEventTarget);

#endif

mTokenizer->setInterner(&mAtomTable);

mTokenizer->setEncodingDeclarationHandler(this);

if (aMode == VIEW_SOURCE_HTML || aMode == VIEW_SOURCE_XML) {

nsHtml5Highlighter* highlighter =

new nsHtml5Highlighter(mExecutor->GetStage());

mTokenizer->EnableViewSource(highlighter); // takes ownership

mTreeBuilder->EnableViewSource(highlighter); // doesn't own

}

// Chardet instantiation adapted from File.

// Chardet is initialized here even if it turns out to be useless

// to make the chardet refcount its observer (nsHtml5StreamParser)

// on the main thread.

nsAutoCString detectorName;

Preferences::GetLocalizedCString("intl.charset.detector", detectorName);

if (!detectorName.IsEmpty()) {

// We recognize one of the two magic strings for Russian and Ukranian.

if (detectorName.EqualsLiteral("ruprob")) {

mChardet = new nsRUProbDetector();

} else if (detectorName.EqualsLiteral("ukprob")) {

mChardet = new nsUKProbDetector();

}

if (mChardet) {

(void)mChardet->Init(this);

}

}

// There's a zeroing operator new for everything else

NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");

return mRequest ? CallQueryInterface(mRequest, aChannel)

: NS_ERROR_NOT_AVAILABLE;

NS_ASSERTION(IsParserThread(), "Wrong thread!");

if (aConf == eBestAnswer || aConf == eSureAnswer) {

mFeedChardet = false; // just in case

auto encoding =

Encoding::ForLabelNoReplacement(nsDependentCString(aCharset));

if (!encoding) {

return NS_OK;

}

if (HasDecoder()) {

if (mEncoding == encoding) {

MOZ_ASSERT(mCharsetSource < kCharsetFromAutoDetection,

"Why are we running chardet at all?");

mCharsetSource = kCharsetFromAutoDetection;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

} else {

// We've already committed to a decoder. Request a reload from the

// docshell.

mTreeBuilder->NeedsCharsetSwitchTo(WrapNotNull(encoding),

kCharsetFromAutoDetection, 0);

FlushTreeOpsAndDisarmTimer();

Interrupt();

}

} else {

// Got a confident answer from the sniffing buffer. That code will

// take care of setting up the decoder.

mEncoding = WrapNotNull(encoding);

mCharsetSource = kCharsetFromAutoDetection;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

}

}

return NS_OK;

bool aLast) {

const Encoding* detected = mJapaneseDetector->Feed(aBuffer, aLast);

if (!detected) {

return;

}

mFeedChardet = false;

if (mDecodingLocalFileAsUTF8 && detected != ISO_2022_JP_ENCODING) {

return;

}

int32_t source = kCharsetFromAutoDetection;

if (mCharsetSource == kCharsetFromParentForced ||

mCharsetSource == kCharsetFromUserForced) {

source = kCharsetFromUserForcedAutoDetection;

}

if (detected == mEncoding) {

MOZ_ASSERT(mCharsetSource < source, "Why are we running chardet at all?");

mCharsetSource = source;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

} else if (HasDecoder()) {

// We've already committed to a decoder. Request a reload from the

// docshell.

mTreeBuilder->NeedsCharsetSwitchTo(WrapNotNull(detected), source, 0);

FlushTreeOpsAndDisarmTimer();

Interrupt();

} else {

// Got a confident answer from the sniffing buffer. That code will

// take care of setting up the decoder.

mEncoding = WrapNotNull(detected);

mCharsetSource = source;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

}

bool aLast) {

if (mEncoding->IsJapaneseLegacy()) {

FeedJapaneseDetector(aBuffer, aLast);

} else if (mEncoding == WINDOWS_1251_ENCODING && mChardet &&

!mDecodingLocalFileAsUTF8) {

if (!aBuffer.IsEmpty()) {

bool dontFeed = false;

mozilla::Unused << mChardet->DoIt((const char*)aBuffer.Elements(),

aBuffer.Length(), &dontFeed);

if (dontFeed) {

mFeedChardet = false;

}

}

if (aLast) {

mozilla::Unused << mChardet->Done();

}

} else {

mFeedChardet = false;

}

MOZ_ASSERT(NS_IsMainThread());

nsIDocShell* docshell = mExecutor->GetDocument()->GetDocShell();

if (docshell && docshell->GetWatchedByDevtools()) {

mURIToSendToDevtools = aURL;

nsID uuid;

nsresult rv = nsContentUtils::GenerateUUIDInPlace(uuid);

if (!NS_FAILED(rv)) {

char buffer[NSID_LENGTH];

uuid.ToProvidedString(buffer);

mUUIDForDevtools = NS_ConvertASCIItoUTF16(buffer);

}

}

if (aURL) {

nsCOMPtr<nsIURI> temp;

if (aURL->SchemeIs("view-source")) {

nsCOMPtr<nsINestedURI> nested = do_QueryInterface(aURL);

nested->GetInnerURI(getter_AddRefs(temp));

} else {

temp = aURL;

}

if (temp->SchemeIs("data")) {

// Avoid showing potentially huge data: URLs. The three last bytes are

// UTF-8 for an ellipsis.

mViewSourceTitle.AssignLiteral("data:\xE2\x80\xA6");

} else {

nsresult rv = temp->GetSpec(mViewSourceTitle);

if (NS_FAILED(rv)) {

mViewSourceTitle.AssignLiteral("\xE2\x80\xA6");

}

}

}

Span<const uint8_t> aFromSegment) {

NS_ASSERTION(IsParserThread(), "Wrong thread!");

nsresult rv = NS_OK;

if (mDecodingLocalFileAsUTF8 && mCharsetSource <= kCharsetFromFileURLGuess) {

MOZ_ASSERT(mEncoding != UTF_8_ENCODING);

mUnicodeDecoder = UTF_8_ENCODING->NewDecoderWithBOMRemoval();

} else {

if (mCharsetSource >= kCharsetFromAutoDetection &&

!(mCharsetSource == kCharsetFromUserForced ||

mCharsetSource == kCharsetFromParentForced)) {

mFeedChardet = false;

}

mDecodingLocalFileAsUTF8 = false;

mUnicodeDecoder = mEncoding->NewDecoderWithBOMRemoval();

}

if (mSniffingBuffer) {

rv = WriteStreamBytes(MakeSpan(mSniffingBuffer.get(), mSniffingLength));

NS_ENSURE_SUCCESS(rv, rv);

mSniffingBuffer = nullptr;

}

mMetaScanner = nullptr;

return WriteStreamBytes(aFromSegment);

NotNull<const Encoding*> aEncoding) {

NS_ASSERTION(IsParserThread(), "Wrong thread!");

mEncoding = aEncoding;

mDecodingLocalFileAsUTF8 = false;

mUnicodeDecoder = mEncoding->NewDecoderWithoutBOMHandling();

mCharsetSource = kCharsetFromByteOrderMark;

mFeedChardet = false;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

mSniffingBuffer = nullptr;

mMetaScanner = nullptr;

mBomState = BOM_SNIFFING_OVER;

return NS_OK;

Span<const uint8_t> aFromSegment) {

// Avoid underspecified heuristic craziness for XHR

if (mMode == LOAD_AS_DATA) {

return;

}

// Make sure there's enough data. Require room for "<title></title>"

if (mSniffingLength + aFromSegment.Length() < 30) {

return;

}

// even-numbered bytes tracked at 0, odd-numbered bytes tracked at 1

bool byteZero[2] = {false, false};

bool byteNonZero[2] = {false, false};

uint32_t i = 0;

if (mSniffingBuffer) {

for (; i < mSniffingLength; ++i) {

if (mSniffingBuffer[i]) {

if (byteNonZero[1 - (i % 2)]) {

return;

}

byteNonZero[i % 2] = true;

} else {

if (byteZero[1 - (i % 2)]) {

return;

}

byteZero[i % 2] = true;

}

}

}

for (size_t j = 0; j < aFromSegment.Length(); ++j) {

if (aFromSegment[j]) {

if (byteNonZero[1 - ((i + j) % 2)]) {

return;

}

byteNonZero[(i + j) % 2] = true;

} else {

if (byteZero[1 - ((i + j) % 2)]) {

return;

}

byteZero[(i + j) % 2] = true;

}

}

if (byteNonZero[0]) {

mEncoding = UTF_16LE_ENCODING;

} else {

mEncoding = UTF_16BE_ENCODING;

}

mCharsetSource = kCharsetFromIrreversibleAutoDetection;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

mFeedChardet = false;

mTreeBuilder->MaybeComplainAboutCharset("EncBomlessUtf16", true, 0);

if (aEncoding) {

nsDependentString utf16(aEncoding);

nsAutoCString utf8;

CopyUTF16toUTF8(utf16, utf8);

auto encoding = PreferredForInternalEncodingDecl(utf8);

if (encoding) {

mEncoding = WrapNotNull(encoding);

mCharsetSource = kCharsetFromMetaTag; // closest for XML

return;

}

// else the page declared an encoding Gecko doesn't support and we'd

// end up defaulting to UTF-8 anyway. Might as well fall through here

// right away and let the encoding be set to UTF-8 which we'd default to

// anyway.

}

mEncoding = UTF_8_ENCODING; // XML defaults to UTF-8 without a BOM

mCharsetSource = kCharsetFromMetaTag; // means confident

const XML_Char* aEncoding, int aStandalone) {

UserData* ud = static_cast<UserData*>(aUserData);

ud->mStreamParser->SetEncodingFromExpat(

reinterpret_cast<const char16_t*>(aEncoding));

XML_StopParser(ud->mExpat, false);

const XML_Char** aAtts) {

UserData* ud = static_cast<UserData*>(aUserData);

XML_StopParser(ud->mExpat, false);

const XML_Char* aTarget,

const XML_Char* aData) {

UserData* ud = static_cast<UserData*>(aUserData);

XML_StopParser(ud->mExpat, false);

Span<const uint8_t> aFromSegment, uint32_t aCountToSniffingLimit,

bool aEof) {

if (mSniffingBuffer) {

FeedDetector(MakeSpan(mSniffingBuffer.get(), mSniffingLength), false);

}

if (mFeedChardet && !aFromSegment.IsEmpty()) {

// Avoid buffer boundary-dependent behavior when

// reparsing is forbidden. If reparse is forbidden,

// act as if we only saw the first 1024 bytes.

// When reparsing isn't forbidden, buffer boundaries

// can have an effect on whether the page is loaded

// once or twice. :-(

FeedDetector(mReparseForbidden ? aFromSegment.To(aCountToSniffingLimit)

: aFromSegment,

false);

}

if (mFeedChardet && aEof &&

(!mReparseForbidden || aCountToSniffingLimit == aFromSegment.Length())) {

// Don't signal EOF if reparse is forbidden and we didn't pass all input

// to the detector above.

mFeedChardet = false;

FeedDetector(Span<const uint8_t>(), true);

}

uint32_t aCountToSniffingLimit,

bool aEof) {

MOZ_ASSERT(IsParserThread(), "Wrong thread!");

MOZ_ASSERT(mCharsetSource < kCharsetFromUserForcedAutoDetection,

"Should not finalize sniffing with strong decision already made.");

if (mMode == VIEW_SOURCE_XML) {

static const XML_Memory_Handling_Suite memsuite = {

(void* (*)(size_t))moz_xmalloc, (void* (*)(void*, size_t))moz_xrealloc,

free};

static const char16_t kExpatSeparator[] = {0xFFFF, '\0'};

static const char16_t kISO88591[] = {'I', 'S', 'O', '-', '8', '8',

'5', '9', '-', '1', '\0'};

UserData ud;

ud.mStreamParser = this;

// If we got this far, the stream didn't have a BOM. UTF-16-encoded XML

// documents MUST begin with a BOM. We don't support EBCDIC and such.

// Thus, at this point, what we have is garbage or something encoded using

// a rough ASCII superset. ISO-8859-1 allows us to decode ASCII bytes

// without throwing errors when bytes have the most significant bit set

// and without triggering expat's unknown encoding code paths. This is

// enough to be able to use expat to parse the XML declaration in order

// to extract the encoding name from it.

ud.mExpat = XML_ParserCreate_MM(kISO88591, &memsuite, kExpatSeparator);

XML_SetXmlDeclHandler(ud.mExpat, HandleXMLDeclaration);

XML_SetElementHandler(ud.mExpat, HandleStartElement, HandleEndElement);

XML_SetCommentHandler(ud.mExpat, HandleComment);

XML_SetProcessingInstructionHandler(ud.mExpat, HandleProcessingInstruction);

XML_SetUserData(ud.mExpat, static_cast<void*>(&ud));

XML_Status status = XML_STATUS_OK;

// aFromSegment points to the data obtained from the current network

// event. mSniffingBuffer (if it exists) contains the data obtained before

// the current event. Thus, mSniffingLenth bytes of mSniffingBuffer

// followed by aCountToSniffingLimit bytes from aFromSegment are the

// first 1024 bytes of the file (or the file as a whole if the file is

// 1024 bytes long or shorter). Thus, we parse both buffers, but if the

// first call succeeds already, we skip parsing the second buffer.

if (mSniffingBuffer) {

status = XML_Parse(ud.mExpat,

reinterpret_cast<const char*>(mSniffingBuffer.get()),

mSniffingLength, false);

}

if (status == XML_STATUS_OK && mCharsetSource < kCharsetFromMetaTag) {

mozilla::Unused << XML_Parse(

ud.mExpat, reinterpret_cast<const char*>(aFromSegment.Elements()),

aCountToSniffingLimit, false);

}

XML_ParserFree(ud.mExpat);

if (mCharsetSource < kCharsetFromMetaTag) {

// Failed to get an encoding from the XML declaration. XML defaults

// confidently to UTF-8 in this case.

// It is also possible that the document has an XML declaration that is

// longer than 1024 bytes, but that case is not worth worrying about.

mEncoding = UTF_8_ENCODING;

mCharsetSource = kCharsetFromMetaTag; // means confident

}

return SetupDecodingAndWriteSniffingBufferAndCurrentSegment(aFromSegment);

}

// meta scan failed.

if (!mSkipContentSniffing && mCharsetSource < kCharsetFromMetaPrescan) {

// Check for BOMless UTF-16 with Basic

// Latin content for compat with IE. See bug 631751.

SniffBOMlessUTF16BasicLatin(aFromSegment.To(aCountToSniffingLimit));

}

// the charset may have been set now

// maybe try chardet now;

if (mFeedChardet) {

FinalizeSniffingWithDetector(aFromSegment, aCountToSniffingLimit, aEof);

// fall thru; callback may have changed charset

}

if (mCharsetSource == kCharsetUninitialized) {

// Hopefully this case is never needed, but dealing with it anyway

mEncoding = WINDOWS_1252_ENCODING;

mCharsetSource = kCharsetFromFallback;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

} else if (mMode == LOAD_AS_DATA && mCharsetSource == kCharsetFromFallback) {

NS_ASSERTION(mReparseForbidden, "Reparse should be forbidden for XHR");

NS_ASSERTION(!mFeedChardet, "Should not feed chardet for XHR");

NS_ASSERTION(mEncoding == UTF_8_ENCODING, "XHR should default to UTF-8");

// Now mark charset source as non-weak to signal that we have a decision

mCharsetSource = kCharsetFromDocTypeDefault;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

}

return SetupDecodingAndWriteSniffingBufferAndCurrentSegment(aFromSegment);

Span<const uint8_t> aFromSegment) {

NS_ASSERTION(IsParserThread(), "Wrong thread!");

nsresult rv = NS_OK;

// mEncoding and mCharsetSource potentially have come from channel or higher

// by now. If we find a BOM, SetupDecodingFromBom() will overwrite them.

// If we don't find a BOM, the previously set values of mEncoding and

// mCharsetSource are not modified by the BOM sniffing here.

for (uint32_t i = 0;

i < aFromSegment.Length() && mBomState != BOM_SNIFFING_OVER; i++) {

switch (mBomState) {

case BOM_SNIFFING_NOT_STARTED:

NS_ASSERTION(i == 0, "Bad BOM sniffing state.");

switch (aFromSegment[0]) {

case 0xEF:

mBomState = SEEN_UTF_8_FIRST_BYTE;

break;

case 0xFF:

mBomState = SEEN_UTF_16_LE_FIRST_BYTE;

break;

case 0xFE:

mBomState = SEEN_UTF_16_BE_FIRST_BYTE;

break;

default:

mBomState = BOM_SNIFFING_OVER;

break;

}

break;

case SEEN_UTF_16_LE_FIRST_BYTE:

if (aFromSegment[i] == 0xFE) {

rv = SetupDecodingFromBom(UTF_16LE_ENCODING);

NS_ENSURE_SUCCESS(rv, rv);

return WriteStreamBytes(aFromSegment.From(i + 1));

}

mBomState = BOM_SNIFFING_OVER;

break;

case SEEN_UTF_16_BE_FIRST_BYTE:

if (aFromSegment[i] == 0xFF) {

rv = SetupDecodingFromBom(UTF_16BE_ENCODING);

NS_ENSURE_SUCCESS(rv, rv);

return WriteStreamBytes(aFromSegment.From(i + 1));

}

mBomState = BOM_SNIFFING_OVER;

break;

case SEEN_UTF_8_FIRST_BYTE:

if (aFromSegment[i] == 0xBB) {

mBomState = SEEN_UTF_8_SECOND_BYTE;

} else {

mBomState = BOM_SNIFFING_OVER;

}

break;

case SEEN_UTF_8_SECOND_BYTE:

if (aFromSegment[i] == 0xBF) {

rv = SetupDecodingFromBom(UTF_8_ENCODING);

NS_ENSURE_SUCCESS(rv, rv);

return WriteStreamBytes(aFromSegment.From(i + 1));

}

mBomState = BOM_SNIFFING_OVER;

break;

default:

mBomState = BOM_SNIFFING_OVER;

break;

}

}

// if we get here, there either was no BOM or the BOM sniffing isn't complete

// yet

MOZ_ASSERT(mCharsetSource != kCharsetFromByteOrderMark,

"Should not come here if BOM was found.");

MOZ_ASSERT(mCharsetSource != kCharsetFromOtherComponent,

"kCharsetFromOtherComponent is for XSLT.");

if (mBomState == BOM_SNIFFING_OVER && mCharsetSource == kCharsetFromChannel) {

// There was no BOM and the charset came from channel. mEncoding

// still contains the charset from the channel as set by an

// earlier call to SetDocumentCharset(), since we didn't find a BOM and

// overwrite mEncoding. (Note that if the user has overridden the charset,

// we don't come here but check <meta> for XSS-dangerous charsets first.)

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

return SetupDecodingAndWriteSniffingBufferAndCurrentSegment(aFromSegment);

}

if (!mMetaScanner &&

(mMode == NORMAL || mMode == VIEW_SOURCE_HTML || mMode == LOAD_AS_DATA)) {

mMetaScanner = new nsHtml5MetaScanner(mTreeBuilder);

}

if (mSniffingLength + aFromSegment.Length() >= SNIFFING_BUFFER_SIZE) {

// this is the last buffer

uint32_t countToSniffingLimit = SNIFFING_BUFFER_SIZE - mSniffingLength;

if (mMode == NORMAL || mMode == VIEW_SOURCE_HTML || mMode == LOAD_AS_DATA) {

nsHtml5ByteReadable readable(

aFromSegment.Elements(),

aFromSegment.Elements() + countToSniffingLimit);

nsAutoCString charset;

auto encoding = mMetaScanner->sniff(&readable);

// Due to the way nsHtml5Portability reports OOM, ask the tree buider

nsresult rv;

if (NS_FAILED((rv = mTreeBuilder->IsBroken()))) {

MarkAsBroken(rv);

return rv;

}

if (encoding) {

// meta scan successful; honor overrides unless meta is XSS-dangerous

if ((mCharsetSource == kCharsetFromParentForced ||

mCharsetSource == kCharsetFromUserForced) &&

(encoding->IsAsciiCompatible() ||

encoding == ISO_2022_JP_ENCODING)) {

// Honor override

if (mEncoding->IsJapaneseLegacy()) {

mFeedChardet = true;

FinalizeSniffingWithDetector(aFromSegment, countToSniffingLimit,

false);

}

return SetupDecodingAndWriteSniffingBufferAndCurrentSegment(

aFromSegment);

}

mEncoding = WrapNotNull(encoding);

mCharsetSource = kCharsetFromMetaPrescan;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

return SetupDecodingAndWriteSniffingBufferAndCurrentSegment(

aFromSegment);

}

}

if (mCharsetSource == kCharsetFromParentForced ||

mCharsetSource == kCharsetFromUserForced) {

// meta not found, honor override

if (mEncoding->IsJapaneseLegacy()) {

mFeedChardet = true;

FinalizeSniffingWithDetector(aFromSegment, countToSniffingLimit, false);

}

return SetupDecodingAndWriteSniffingBufferAndCurrentSegment(aFromSegment);

}

return FinalizeSniffing(aFromSegment, countToSniffingLimit, false);

}

// not the last buffer

if (mMode == NORMAL || mMode == VIEW_SOURCE_HTML || mMode == LOAD_AS_DATA) {

nsHtml5ByteReadable readable(

aFromSegment.Elements(),

aFromSegment.Elements() + aFromSegment.Length());

auto encoding = mMetaScanner->sniff(&readable);

// Due to the way nsHtml5Portability reports OOM, ask the tree buider

nsresult rv;

if (NS_FAILED((rv = mTreeBuilder->IsBroken()))) {

MarkAsBroken(rv);

return rv;

}

if (encoding) {

// meta scan successful; honor overrides unless meta is XSS-dangerous

if ((mCharsetSource == kCharsetFromParentForced ||

mCharsetSource == kCharsetFromUserForced) &&

(encoding->IsAsciiCompatible() || encoding == ISO_2022_JP_ENCODING)) {

// Honor override

return SetupDecodingAndWriteSniffingBufferAndCurrentSegment(

aFromSegment);

}

mEncoding = WrapNotNull(encoding);

mCharsetSource = kCharsetFromMetaPrescan;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

return SetupDecodingAndWriteSniffingBufferAndCurrentSegment(aFromSegment);

}

}

if (!mSniffingBuffer) {

mSniffingBuffer = MakeUniqueFallible<uint8_t[]>(SNIFFING_BUFFER_SIZE);

if (!mSniffingBuffer) {

return NS_ERROR_OUT_OF_MEMORY;

}

}

memcpy(&mSniffingBuffer[mSniffingLength], aFromSegment.Elements(),

aFromSegment.Length());

mSniffingLength += aFromSegment.Length();

return NS_OK;

public:

AddContentRunnable(const nsAString& aParserID, nsIURI* aURI,

Span<const char16_t> aData, bool aComplete)

: Runnable("AddContent") {

nsAutoCString spec;

aURI->GetSpec(spec);

mData.mUri.Construct(NS_ConvertUTF8toUTF16(spec));

mData.mParserID.Construct(aParserID);

mData.mContents.Construct(aData.Elements(), aData.Length());

mData.mComplete.Construct(aComplete);

}

NS_IMETHOD Run() override {

nsAutoString json;

if (!mData.ToJSON(json)) {

return NS_ERROR_FAILURE;

}

nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();

if (obsService) {

obsService->NotifyObservers(nullptr, "devtools-html-content",

PromiseFlatString(json).get());

}

return NS_OK;

}

HTMLContent mData;

if (mURIToSendToDevtools) {

NS_DispatchToMainThread(new AddContentRunnable(mUUIDForDevtools,

mURIToSendToDevtools, aData,

/* aComplete */ false));

}

if (mURIToSendToDevtools) {

NS_DispatchToMainThread(new AddContentRunnable(

mUUIDForDevtools, mURIToSendToDevtools, Span<const char16_t>(),

/* aComplete */ true));

mURIToSendToDevtools = nullptr;

}

Span<const uint8_t> aFromSegment) {

NS_ASSERTION(IsParserThread(), "Wrong thread!");

// mLastBuffer should always point to a buffer of the size

// READ_BUFFER_SIZE.

if (!mLastBuffer) {

NS_WARNING("mLastBuffer should not be null!");

MarkAsBroken(NS_ERROR_NULL_POINTER);

return NS_ERROR_NULL_POINTER;

}

size_t totalRead = 0;

auto src = aFromSegment;

for (;;) {

auto dst = mLastBuffer->TailAsSpan(READ_BUFFER_SIZE);

uint32_t result;

size_t read;

size_t written;

bool hadErrors;

Tie(result, read, written, hadErrors) =

mUnicodeDecoder->DecodeToUTF16(src, dst, false);

if (!mDecodingLocalFileAsUTF8) {

OnNewContent(dst.To(written));

}

if (hadErrors && !mHasHadErrors) {

if (mDecodingLocalFileAsUTF8) {

ReDecodeLocalFile();

return NS_OK;

}

mHasHadErrors = true;

if (mEncoding == UTF_8_ENCODING) {

mTreeBuilder->TryToEnableEncodingMenu();

}

}

src = src.From(read);

totalRead += read;

mLastBuffer->AdvanceEnd(written);

if (result == kOutputFull) {

RefPtr<nsHtml5OwningUTF16Buffer> newBuf =

nsHtml5OwningUTF16Buffer::FalliblyCreate(READ_BUFFER_SIZE);

if (!newBuf) {

MarkAsBroken(NS_ERROR_OUT_OF_MEMORY);

return NS_ERROR_OUT_OF_MEMORY;

}

mLastBuffer = (mLastBuffer->next = newBuf.forget());

} else {

MOZ_ASSERT(totalRead == aFromSegment.Length(),

"The Unicode decoder consumed the wrong number of bytes.");

if (mDecodingLocalFileAsUTF8 &&

mLocalFileBytesBuffered == LOCAL_FILE_UTF_8_BUFFER_SIZE) {

CommitLocalFileToUTF8();

}

return NS_OK;

}

}

MOZ_ASSERT(mDecodingLocalFileAsUTF8);

mDecodingLocalFileAsUTF8 = false;

mUnicodeDecoder = mEncoding->NewDecoderWithBOMRemoval();

mHasHadErrors = false;

// We need the detector to start with fresh state.

// Turn off ISO-2022-JP detection, because if this doc was

// ISO-2022-JP, it would have already been detected.

mJapaneseDetector = mozilla::JapaneseDetector::Create(false);

mFeedChardet = true;

// Throw away previous decoded data

mLastBuffer = mFirstBuffer;

mLastBuffer->next = nullptr;

mLastBuffer->setStart(0);

mLastBuffer->setEnd(0);

// Decode again

for (auto&& buffer : mBufferedLocalFileData) {

DoDataAvailable(buffer);

}

MOZ_ASSERT(mDecodingLocalFileAsUTF8);

mDecodingLocalFileAsUTF8 = false;

mFeedChardet = false;

mEncoding = UTF_8_ENCODING;

mCharsetSource = kCharsetFromFileURLGuess;

mTreeBuilder->SetDocumentCharset(mEncoding, mCharsetSource);

nsHtml5OwningUTF16Buffer* buffer = mFirstBuffer;

while (buffer) {

Span<const char16_t> data(buffer->getBuffer() + buffer->getStart(),

buffer->getLength());

OnNewContent(data);

buffer = buffer->next;

}

public:

explicit MaybeRunCollector(nsIDocShell* aDocShell)

: Runnable("MaybeRunCollector"), mDocShell(aDocShell) {}

NS_IMETHOD Run() override {

nsJSContext::MaybeRunNextCollectorSlice(mDocShell,

JS::GCReason::HTML_PARSER);

return NS_OK;

}

nsCOMPtr<nsIDocShell> mDocShell;