diff options
Diffstat (limited to 'layout/style/StreamLoader.cpp')
| -rw-r--r-- | layout/style/StreamLoader.cpp | 212 |
1 files changed, 212 insertions, 0 deletions
diff --git a/layout/style/StreamLoader.cpp b/layout/style/StreamLoader.cpp new file mode 100644 index 0000000000..3e8bd37d76 --- /dev/null +++ b/layout/style/StreamLoader.cpp @@ -0,0 +1,212 @@ +/* -*- 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 "mozilla/css/StreamLoader.h" + +#include "mozilla/Encoding.h" +#include "mozilla/TaskQueue.h" +#include "nsContentUtils.h" +#include "nsIChannel.h" +#include "nsIInputStream.h" +#include "nsIThreadRetargetableRequest.h" +#include "nsIStreamTransportService.h" +#include "nsNetCID.h" +#include "nsServiceManagerUtils.h" + +namespace mozilla::css { + +StreamLoader::StreamLoader(SheetLoadData& aSheetLoadData) + : mSheetLoadData(&aSheetLoadData), mStatus(NS_OK) {} + +StreamLoader::~StreamLoader() { +#ifdef NIGHTLY_BUILD + MOZ_RELEASE_ASSERT(mOnStopRequestCalled || mChannelOpenFailed); +#endif +} + +NS_IMPL_ISUPPORTS(StreamLoader, nsIStreamListener, + nsIThreadRetargetableStreamListener) + +/* nsIRequestObserver implementation */ +NS_IMETHODIMP +StreamLoader::OnStartRequest(nsIRequest* aRequest) { + MOZ_ASSERT(aRequest); + mSheetLoadData->NotifyStart(aRequest); + + // It's kinda bad to let Web content send a number that results + // in a potentially large allocation directly, but efficiency of + // compression bombs is so great that it doesn't make much sense + // to require a site to send one before going ahead and allocating. + if (nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest)) { + int64_t length; + nsresult rv = channel->GetContentLength(&length); + if (NS_SUCCEEDED(rv) && length > 0) { + CheckedInt<nsACString::size_type> checkedLength(length); + if (!checkedLength.isValid()) { + return (mStatus = NS_ERROR_OUT_OF_MEMORY); + } + if (!mBytes.SetCapacity(checkedLength.value(), fallible)) { + return (mStatus = NS_ERROR_OUT_OF_MEMORY); + } + } + } + if (nsCOMPtr<nsIThreadRetargetableRequest> rr = do_QueryInterface(aRequest)) { + nsCOMPtr<nsIEventTarget> sts = + do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID); + RefPtr queue = + TaskQueue::Create(sts.forget(), "css::StreamLoader Delivery Queue"); + rr->RetargetDeliveryTo(queue); + } + + mSheetLoadData->mExpirationTime = [&] { + auto info = nsContentUtils::GetSubresourceCacheValidationInfo( + aRequest, mSheetLoadData->mURI); + + // For now, we never cache entries that we have to revalidate, or whose + // channel don't support caching. + if (info.mMustRevalidate || !info.mExpirationTime) { + return nsContentUtils::SecondsFromPRTime(PR_Now()) - 1; + } + return *info.mExpirationTime; + }(); + + return NS_OK; +} + +NS_IMETHODIMP +StreamLoader::CheckListenerChain() { return NS_OK; } + +NS_IMETHODIMP +StreamLoader::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) { +#ifdef NIGHTLY_BUILD + MOZ_RELEASE_ASSERT(!mOnStopRequestCalled); + mOnStopRequestCalled = true; +#endif + + nsresult rv = mStatus; + // Decoded data + nsCString utf8String; + { + // Hold the nsStringBuffer for the bytes from the stack to ensure release + // no matter which return branch is taken. + nsCString bytes = std::move(mBytes); + + nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest); + + if (NS_FAILED(mStatus)) { + mSheetLoadData->VerifySheetReadyToParse(mStatus, ""_ns, ""_ns, channel); + return mStatus; + } + + rv = mSheetLoadData->VerifySheetReadyToParse(aStatus, mBOMBytes, bytes, + channel); + if (rv != NS_OK_PARSE_SHEET) { + return rv; + } + + // BOM detection generally happens during the write callback, but that won't + // have happened if fewer than three bytes were received. + if (mEncodingFromBOM.isNothing()) { + HandleBOM(); + MOZ_ASSERT(mEncodingFromBOM.isSome()); + } + + // The BOM handling has happened, but we still may not have an encoding if + // there was no BOM. Ensure we have one. + const Encoding* encoding = mEncodingFromBOM.value(); + if (!encoding) { + // No BOM + encoding = mSheetLoadData->DetermineNonBOMEncoding(bytes, channel); + } + mSheetLoadData->mEncoding = encoding; + + size_t validated = 0; + if (encoding == UTF_8_ENCODING) { + validated = Encoding::UTF8ValidUpTo(bytes); + } + + if (validated == bytes.Length()) { + // Either this is UTF-8 and all valid, or it's not UTF-8 but is an empty + // string. This assumes that an empty string in any encoding decodes to + // empty string, which seems like a plausible assumption. + utf8String = std::move(bytes); + } else { + rv = encoding->DecodeWithoutBOMHandling(bytes, utf8String, validated); + NS_ENSURE_SUCCESS(rv, rv); + } + } // run destructor for `bytes` + + // For reasons I don't understand, factoring the below lines into + // a method on SheetLoadData resulted in a linker error. Hence, + // accessing fields of mSheetLoadData from here. + mSheetLoadData->mLoader->ParseSheet(utf8String, *mSheetLoadData, + Loader::AllowAsyncParse::Yes); + + return NS_OK; +} + +/* nsIStreamListener implementation */ +NS_IMETHODIMP +StreamLoader::OnDataAvailable(nsIRequest*, nsIInputStream* aInputStream, + uint64_t, uint32_t aCount) { + if (NS_FAILED(mStatus)) { + return mStatus; + } + uint32_t dummy; + return aInputStream->ReadSegments(WriteSegmentFun, this, aCount, &dummy); +} + +NS_IMETHODIMP +StreamLoader::OnDataFinished(nsresult aStatus) { return NS_OK; } + +void StreamLoader::HandleBOM() { + MOZ_ASSERT(mEncodingFromBOM.isNothing()); + MOZ_ASSERT(mBytes.IsEmpty()); + + auto [encoding, bomLength] = Encoding::ForBOM(mBOMBytes); + mEncodingFromBOM.emplace(encoding); // Null means no BOM. + + // BOMs are three bytes at most, but may be fewer. Copy over anything + // that wasn't part of the BOM to mBytes. Note that we need to track + // any BOM bytes as well for SRI handling. + mBytes.Append(Substring(mBOMBytes, bomLength)); + mBOMBytes.Truncate(bomLength); +} + +nsresult StreamLoader::WriteSegmentFun(nsIInputStream*, void* aClosure, + const char* aSegment, uint32_t, + uint32_t aCount, uint32_t* aWriteCount) { + *aWriteCount = 0; + StreamLoader* self = static_cast<StreamLoader*>(aClosure); + if (NS_FAILED(self->mStatus)) { + return self->mStatus; + } + + // If we haven't done BOM detection yet, divert bytes into the special buffer. + if (self->mEncodingFromBOM.isNothing()) { + size_t bytesToCopy = std::min<size_t>(3 - self->mBOMBytes.Length(), aCount); + self->mBOMBytes.Append(aSegment, bytesToCopy); + aSegment += bytesToCopy; + *aWriteCount += bytesToCopy; + aCount -= bytesToCopy; + + if (self->mBOMBytes.Length() == 3) { + self->HandleBOM(); + } else { + return NS_OK; + } + } + + if (!self->mBytes.Append(aSegment, aCount, fallible)) { + self->mBytes.Truncate(); + return (self->mStatus = NS_ERROR_OUT_OF_MEMORY); + } + + *aWriteCount += aCount; + return NS_OK; +} + +} // namespace mozilla::css |