diff options
Diffstat (limited to 'layout/style/StreamLoader.cpp')
| -rw-r--r-- | layout/style/StreamLoader.cpp | 210 |
1 files changed, 210 insertions, 0 deletions
diff --git a/layout/style/StreamLoader.cpp b/layout/style/StreamLoader.cpp new file mode 100644 index 0000000000..dec4dc5530 --- /dev/null +++ b/layout/style/StreamLoader.cpp @@ -0,0 +1,210 @@ +/* -*- 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 "nsContentUtils.h" +#include "nsIChannel.h" +#include "nsIInputStream.h" + +#include <limits> + +using namespace mozilla; + +namespace mozilla { +namespace 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) + +/* 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) { + if (length > std::numeric_limits<nsACString::size_type>::max()) { + return (mStatus = NS_ERROR_OUT_OF_MEMORY); + } + if (!mBytes.SetCapacity(length, fallible)) { + return (mStatus = NS_ERROR_OUT_OF_MEMORY); + } + } + } + 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(mBytes); + mBytes.Truncate(); + + 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.Assign(bytes); + } else { + rv = encoding->DecodeWithoutBOMHandling(bytes, utf8String, validated); + NS_ENSURE_SUCCESS(rv, rv); + } + } // run destructor for `bytes` + + auto info = nsContentUtils::GetSubresourceCacheValidationInfo(aRequest); + + // data: URIs are safe to cache across documents under any circumstance, so we + // special-case them here even though the channel itself doesn't have any + // caching policy. + // + // TODO(emilio): Figure out which other schemes that don't have caching + // policies are safe to cache. Blobs should be... + if (mSheetLoadData->mURI->SchemeIs("data")) { + MOZ_ASSERT(!info.mExpirationTime); + MOZ_ASSERT(!info.mMustRevalidate); + info.mExpirationTime = Some(0); // 0 means "doesn't expire". + } + + // For now, we never cache entries that we have to revalidate, or whose + // channel don't support caching. + if (!info.mExpirationTime || info.mMustRevalidate) { + info.mExpirationTime = + Some(nsContentUtils::SecondsFromPRTime(PR_Now()) - 1); + } + mSheetLoadData->mExpirationTime = *info.mExpirationTime; + + // 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); +} + +void StreamLoader::HandleBOM() { + MOZ_ASSERT(mEncodingFromBOM.isNothing()); + MOZ_ASSERT(mBytes.IsEmpty()); + + const Encoding* encoding; + size_t bomLength; + Tie(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(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 css +} // namespace mozilla |