layout/style/StreamLoader.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/css/StreamLoader.h"
   8 #include "mozilla/StaticPrefs_network.h"
   9 #include "mozilla/Encoding.h"
  10 #include "mozilla/glean/GleanMetrics.h"
  11 #include "mozilla/TaskQueue.h"
  12 #include "nsContentUtils.h"
  13 #include "nsIChannel.h"
  14 #include "nsIInputStream.h"
  15 #include "nsIThreadRetargetableRequest.h"
  16 #include "nsIStreamTransportService.h"
  17 #include "nsNetCID.h"
  18 #include "nsNetUtil.h"
  19 #include "nsProxyRelease.h"
  20 #include "nsServiceManagerUtils.h"
  21
  22 namespace mozilla::css {
  23
  24 StreamLoader::StreamLoader(SheetLoadData& aSheetLoadData)
  25     : mSheetLoadData(&aSheetLoadData),
  26       mStatus(NS_OK),
  27       mMainThreadSheetLoadData(new nsMainThreadPtrHolder<SheetLoadData>(
  28           "StreamLoader::SheetLoadData", mSheetLoadData, false)) {}
  29
  30 StreamLoader::~StreamLoader() {
  31 #ifdef NIGHTLY_BUILD
  32   MOZ_RELEASE_ASSERT(mOnStopProcessingDone || mChannelOpenFailed);
  33 #endif
  34 }
  35
  36 NS_IMPL_ISUPPORTS(StreamLoader, nsIStreamListener,
  37                   nsIThreadRetargetableStreamListener)
  38
  39 /* nsIRequestObserver implementation */
  40 NS_IMETHODIMP
  41 StreamLoader::OnStartRequest(nsIRequest* aRequest) {
  42   MOZ_ASSERT(aRequest);
  43   mRequest = aRequest;
  44   mSheetLoadData->NotifyStart(aRequest);
  45
  46   // It's kinda bad to let Web content send a number that results
  47   // in a potentially large allocation directly, but efficiency of
  48   // compression bombs is so great that it doesn't make much sense
  49   // to require a site to send one before going ahead and allocating.
  50   if (nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest)) {
  51     int64_t length;
  52     nsresult rv = channel->GetContentLength(&length);
  53     if (NS_SUCCEEDED(rv) && length > 0) {
  54       CheckedInt<nsACString::size_type> checkedLength(length);
  55       if (!checkedLength.isValid()) {
  56         return (mStatus = NS_ERROR_OUT_OF_MEMORY);
  57       }
  58       if (!mBytes.SetCapacity(checkedLength.value(), fallible)) {
  59         return (mStatus = NS_ERROR_OUT_OF_MEMORY);
  60       }
  61     }
  62     NS_GetFinalChannelURI(channel, getter_AddRefs(mFinalChannelURI));
  63     nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
  64     // we dont return on error here as the error is handled in
  65     // SheetLoadData::VerifySheetReadyToParse
  66     Unused << secMan->GetChannelResultPrincipal(
  67         channel, getter_AddRefs(mChannelResultPrincipal));
  68   }
  69   if (nsCOMPtr<nsIThreadRetargetableRequest> rr = do_QueryInterface(aRequest)) {
  70     nsCOMPtr<nsIEventTarget> sts =
  71         do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
  72     RefPtr queue =
  73         TaskQueue::Create(sts.forget(), "css::StreamLoader Delivery Queue");
  74     rr->RetargetDeliveryTo(queue);
  75   }
  76
  77   mSheetLoadData->mExpirationTime = [&] {
  78     auto info = nsContentUtils::GetSubresourceCacheValidationInfo(
  79         aRequest, mSheetLoadData->mURI);
  80
  81     // For now, we never cache entries that we have to revalidate, or whose
  82     // channel don't support caching.
  83     if (info.mMustRevalidate || !info.mExpirationTime) {
  84       return nsContentUtils::SecondsFromPRTime(PR_Now()) - 1;
  85     }
  86     return *info.mExpirationTime;
  87   }();
  88
  89   // We need to block block resolution of parse promise until we receive
  90   // OnStopRequest on Main thread. This is necessary because parse promise
  91   // resolution fires OnLoad event OnLoad event must not be dispatched until
  92   // OnStopRequest in main thread is processed, for stuff like performance
  93   // resource entries.
  94   mSheetLoadData->mSheet->BlockParsePromise();
  95
  96   return NS_OK;
  97 }
  98
  99 NS_IMETHODIMP
 100 StreamLoader::CheckListenerChain() { return NS_OK; }
 101
 102 NS_IMETHODIMP
 103 StreamLoader::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
 104   MOZ_ASSERT_IF(!StaticPrefs::network_send_OnDataFinished_cssLoader(),
 105                 !mOnStopProcessingDone);
 106
 107   // StreamLoader::OnStopRequest can get triggered twice for a request.
 108   // Once from the path
 109   // nsIThreadRetargetableStreamListener::OnDataFinished->StreamLoader::OnDataFinished
 110   // (non-main thread)  and
 111   // once from nsIRequestObserver::OnStopRequest path (main thread). It is
 112   // guaranteed that we will always get
 113   // nsIThreadRetargetableStreamListener::OnDataFinished trigger first and this
 114   // is always followed by nsIRequestObserver::OnStopRequest
 115
 116   // If we are executing OnStopRequest OMT, we need to block resolution of parse
 117   // promise and unblock again if we are executing this in main thread.
 118   // Resolution of parse promise fires onLoadEvent and this should not happen
 119   // before main thread OnStopRequest is dispatched.
 120   if (NS_IsMainThread()) {
 121     if (mOnDataFinishedTime) {
 122       // collect telemetry for the delta between OnDataFinished and
 123       // OnStopRequest
 124       TimeDuration delta = (TimeStamp::Now() - mOnDataFinishedTime);
 125       glean::networking::http_content_cssloader_ondatafinished_to_onstop_delay
 126           .AccumulateRawDuration(delta);
 127     }
 128     mSheetLoadData->mSheet->UnblockParsePromise();
 129   }
 130
 131   if (mOnStopProcessingDone) {
 132     return NS_OK;
 133   }
 134   mOnStopProcessingDone = true;
 135
 136   nsresult rv = mStatus;
 137   // Decoded data
 138   nsCString utf8String;
 139   {
 140     nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
 141
 142     if (NS_FAILED(mStatus)) {
 143       mSheetLoadData->VerifySheetReadyToParse(mStatus, ""_ns, ""_ns, channel,
 144                                               mFinalChannelURI,
 145                                               mChannelResultPrincipal);
 146
 147       if (!NS_IsMainThread()) {
 148         // When processing OMT, we have code paths in VerifySheetReadyToParse
 149         // that are main-thread only. We bail on such scenarios and continue
 150         // processing them on main thread OnStopRequest.
 151         mOnStopProcessingDone = false;
 152       }
 153       return mStatus;
 154     }
 155
 156     rv = mSheetLoadData->VerifySheetReadyToParse(aStatus, mBOMBytes, mBytes,
 157                                                  channel, mFinalChannelURI,
 158                                                  mChannelResultPrincipal);
 159     if (rv != NS_OK_PARSE_SHEET) {
 160       if (!NS_IsMainThread()) {
 161         mOnStopProcessingDone = false;
 162       }
 163       return rv;
 164     }
 165
 166     // At this point all the conditions that requires us to run on main
 167     // are checked in VerifySheetReadyToParse
 168
 169     // BOM detection generally happens during the write callback, but that
 170     // won't have happened if fewer than three bytes were received.
 171     if (mEncodingFromBOM.isNothing()) {
 172       HandleBOM();
 173       MOZ_ASSERT(mEncodingFromBOM.isSome());
 174     }
 175     // Hold the nsStringBuffer for the bytes from the stack to ensure release
 176     // after its scope ends
 177     nsCString bytes = std::move(mBytes);
 178     // The BOM handling has happened, but we still may not have an encoding if
 179     // there was no BOM. Ensure we have one.
 180     const Encoding* encoding = mEncodingFromBOM.value();
 181     if (!encoding) {
 182       // No BOM
 183       encoding = mSheetLoadData->DetermineNonBOMEncoding(bytes, channel);
 184     }
 185     mSheetLoadData->mEncoding = encoding;
 186
 187     size_t validated = 0;
 188     if (encoding == UTF_8_ENCODING) {
 189       validated = Encoding::UTF8ValidUpTo(bytes);
 190     }
 191
 192     if (validated == bytes.Length()) {
 193       // Either this is UTF-8 and all valid, or it's not UTF-8 but is an empty
 194       // string. This assumes that an empty string in any encoding decodes to
 195       // empty string, which seems like a plausible assumption.
 196       utf8String = std::move(bytes);
 197     } else {
 198       rv = encoding->DecodeWithoutBOMHandling(bytes, utf8String, validated);
 199       NS_ENSURE_SUCCESS(rv, rv);
 200     }
 201   }  // run destructor for `bytes`
 202
 203   // For reasons I don't understand, factoring the below lines into
 204   // a method on SheetLoadData resulted in a linker error. Hence,
 205   // accessing fields of mSheetLoadData from here.
 206   mSheetLoadData->mLoader->ParseSheet(utf8String, mMainThreadSheetLoadData,
 207                                       Loader::AllowAsyncParse::Yes);
 208
 209   mRequest = nullptr;
 210
 211   return NS_OK;
 212 }
 213
 214 /* nsIStreamListener implementation */
 215 NS_IMETHODIMP
 216 StreamLoader::OnDataAvailable(nsIRequest*, nsIInputStream* aInputStream,
 217                               uint64_t, uint32_t aCount) {
 218   if (NS_FAILED(mStatus)) {
 219     return mStatus;
 220   }
 221   uint32_t dummy;
 222   return aInputStream->ReadSegments(WriteSegmentFun, this, aCount, &dummy);
 223 }
 224
 225 void StreamLoader::HandleBOM() {
 226   MOZ_ASSERT(mEncodingFromBOM.isNothing());
 227   MOZ_ASSERT(mBytes.IsEmpty());
 228
 229   auto [encoding, bomLength] = Encoding::ForBOM(mBOMBytes);
 230   mEncodingFromBOM.emplace(encoding);  // Null means no BOM.
 231
 232   // BOMs are three bytes at most, but may be fewer. Copy over anything
 233   // that wasn't part of the BOM to mBytes. Note that we need to track
 234   // any BOM bytes as well for SRI handling.
 235   mBytes.Append(Substring(mBOMBytes, bomLength));
 236   mBOMBytes.Truncate(bomLength);
 237 }
 238
 239 NS_IMETHODIMP
 240 StreamLoader::OnDataFinished(nsresult aResult) {
 241   if (StaticPrefs::network_send_OnDataFinished_cssLoader()) {
 242     MOZ_ASSERT(mOnDataFinishedTime.IsNull(),
 243                "OnDataFinished should only be called once");
 244     mOnDataFinishedTime = TimeStamp::Now();
 245     return OnStopRequest(mRequest, aResult);
 246   }
 247
 248   return NS_OK;
 249 }
 250
 251 nsresult StreamLoader::WriteSegmentFun(nsIInputStream*, void* aClosure,
 252                                        const char* aSegment, uint32_t,
 253                                        uint32_t aCount, uint32_t* aWriteCount) {
 254   *aWriteCount = 0;
 255   StreamLoader* self = static_cast<StreamLoader*>(aClosure);
 256   if (NS_FAILED(self->mStatus)) {
 257     return self->mStatus;
 258   }
 259
 260   // If we haven't done BOM detection yet, divert bytes into the special buffer.
 261   if (self->mEncodingFromBOM.isNothing()) {
 262     size_t bytesToCopy = std::min<size_t>(3 - self->mBOMBytes.Length(), aCount);
 263     self->mBOMBytes.Append(aSegment, bytesToCopy);
 264     aSegment += bytesToCopy;
 265     *aWriteCount += bytesToCopy;
 266     aCount -= bytesToCopy;
 267
 268     if (self->mBOMBytes.Length() == 3) {
 269       self->HandleBOM();
 270     } else {
 271       return NS_OK;
 272     }
 273   }
 274
 275   if (!self->mBytes.Append(aSegment, aCount, fallible)) {
 276     self->mBytes.Truncate();
 277     return (self->mStatus = NS_ERROR_OUT_OF_MEMORY);
 278   }
 279
 280   *aWriteCount += aCount;
 281   return NS_OK;
 282 }
 283
 284 }  // namespace mozilla::css