mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-24 21:31:04 +00:00
48c797f422
MozReview-Commit-ID: 4lTbxSSrCf4 --HG-- extra : rebase_source : ccd67d8326f5cb9fb0372d5a42b15481aa886d66
264 lines
10 KiB
C++
264 lines
10 KiB
C++
/* 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/. */
|
|
|
|
#ifndef nsHtml5SpeculativeLoad_h
|
|
#define nsHtml5SpeculativeLoad_h
|
|
|
|
#include "nsString.h"
|
|
#include "nsContentUtils.h"
|
|
|
|
class nsHtml5TreeOpExecutor;
|
|
|
|
enum eHtml5SpeculativeLoad {
|
|
#ifdef DEBUG
|
|
eSpeculativeLoadUninitialized,
|
|
#endif
|
|
eSpeculativeLoadBase,
|
|
eSpeculativeLoadCSP,
|
|
eSpeculativeLoadMetaReferrer,
|
|
eSpeculativeLoadImage,
|
|
eSpeculativeLoadOpenPicture,
|
|
eSpeculativeLoadEndPicture,
|
|
eSpeculativeLoadPictureSource,
|
|
eSpeculativeLoadScript,
|
|
eSpeculativeLoadScriptFromHead,
|
|
eSpeculativeLoadStyle,
|
|
eSpeculativeLoadManifest,
|
|
eSpeculativeLoadSetDocumentCharset,
|
|
eSpeculativeLoadSetDocumentMode,
|
|
eSpeculativeLoadPreconnect
|
|
};
|
|
|
|
class nsHtml5SpeculativeLoad {
|
|
public:
|
|
nsHtml5SpeculativeLoad();
|
|
~nsHtml5SpeculativeLoad();
|
|
|
|
inline void InitBase(const nsAString& aUrl)
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadBase;
|
|
mUrl.Assign(aUrl);
|
|
}
|
|
|
|
inline void InitMetaCSP(const nsAString& aCSP) {
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadCSP;
|
|
mMetaCSP.Assign(
|
|
nsContentUtils::TrimWhitespace<nsContentUtils::IsHTMLWhitespace>(aCSP));
|
|
}
|
|
|
|
inline void InitMetaReferrerPolicy(const nsAString& aReferrerPolicy) {
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadMetaReferrer;
|
|
mReferrerPolicy.Assign(
|
|
nsContentUtils::TrimWhitespace<nsContentUtils::IsHTMLWhitespace>(aReferrerPolicy));
|
|
}
|
|
|
|
inline void InitImage(const nsAString& aUrl,
|
|
const nsAString& aCrossOrigin,
|
|
const nsAString& aReferrerPolicy,
|
|
const nsAString& aSrcset,
|
|
const nsAString& aSizes)
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadImage;
|
|
mUrl.Assign(aUrl);
|
|
mCrossOrigin.Assign(aCrossOrigin);
|
|
mReferrerPolicy.Assign(
|
|
nsContentUtils::TrimWhitespace<nsContentUtils::IsHTMLWhitespace>(aReferrerPolicy));
|
|
mSrcset.Assign(aSrcset);
|
|
mSizes.Assign(aSizes);
|
|
}
|
|
|
|
// <picture> elements have multiple <source> nodes followed by an <img>,
|
|
// where we use the first valid source, which may be the img. Because we
|
|
// can't determine validity at this point without parsing CSS and getting
|
|
// main thread state, we push preload operations for picture pushed and
|
|
// popped, so that the target of the preload ops can determine what picture
|
|
// and nesting level each source/img from the main preloading code exists
|
|
// at.
|
|
inline void InitOpenPicture()
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadOpenPicture;
|
|
}
|
|
|
|
inline void InitEndPicture()
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadEndPicture;
|
|
}
|
|
|
|
inline void InitPictureSource(const nsAString& aSrcset,
|
|
const nsAString& aSizes,
|
|
const nsAString& aType,
|
|
const nsAString& aMedia)
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadPictureSource;
|
|
mSrcset.Assign(aSrcset);
|
|
mSizes.Assign(aSizes);
|
|
mTypeOrCharsetSourceOrDocumentMode.Assign(aType);
|
|
mMedia.Assign(aMedia);
|
|
}
|
|
|
|
inline void InitScript(const nsAString& aUrl,
|
|
const nsAString& aCharset,
|
|
const nsAString& aType,
|
|
const nsAString& aCrossOrigin,
|
|
const nsAString& aIntegrity,
|
|
bool aParserInHead)
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = aParserInHead ?
|
|
eSpeculativeLoadScriptFromHead : eSpeculativeLoadScript;
|
|
mUrl.Assign(aUrl);
|
|
mCharset.Assign(aCharset);
|
|
mTypeOrCharsetSourceOrDocumentMode.Assign(aType);
|
|
mCrossOrigin.Assign(aCrossOrigin);
|
|
mIntegrity.Assign(aIntegrity);
|
|
}
|
|
|
|
inline void InitStyle(const nsAString& aUrl, const nsAString& aCharset,
|
|
const nsAString& aCrossOrigin,
|
|
const nsAString& aIntegrity)
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadStyle;
|
|
mUrl.Assign(aUrl);
|
|
mCharset.Assign(aCharset);
|
|
mCrossOrigin.Assign(aCrossOrigin);
|
|
mIntegrity.Assign(aIntegrity);
|
|
}
|
|
|
|
/**
|
|
* "Speculative" manifest loads aren't truly speculative--if a manifest
|
|
* gets loaded, we are committed to it. There can never be a <script>
|
|
* before the manifest, so the situation of having to undo a manifest due
|
|
* to document.write() never arises. The reason why a parser
|
|
* thread-discovered manifest gets loaded via the speculative load queue
|
|
* as opposed to tree operation queue is that the manifest must get
|
|
* processed before any actual speculative loads such as scripts. Thus,
|
|
* manifests seen by the parser thread have to maintain the queue order
|
|
* relative to true speculative loads. See bug 541079.
|
|
*/
|
|
inline void InitManifest(const nsAString& aUrl)
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadManifest;
|
|
mUrl.Assign(aUrl);
|
|
}
|
|
|
|
/**
|
|
* "Speculative" charset setting isn't truly speculative. If the charset
|
|
* is set via this operation, we are committed to it unless chardet or
|
|
* a late meta cause a reload. The reason why a parser
|
|
* thread-discovered charset gets communicated via the speculative load
|
|
* queue as opposed to tree operation queue is that the charset change
|
|
* must get processed before any actual speculative loads such as style
|
|
* sheets. Thus, encoding decisions by the parser thread have to maintain
|
|
* the queue order relative to true speculative loads. See bug 675499.
|
|
*/
|
|
inline void InitSetDocumentCharset(nsACString& aCharset,
|
|
int32_t aCharsetSource)
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadSetDocumentCharset;
|
|
CopyUTF8toUTF16(aCharset, mCharset);
|
|
mTypeOrCharsetSourceOrDocumentMode.Assign((char16_t)aCharsetSource);
|
|
}
|
|
|
|
/**
|
|
* Speculative document mode setting isn't really speculative. Once it
|
|
* happens, we are committed to it. However, this information needs to
|
|
* travel in the speculation queue in order to have this information
|
|
* available before parsing the speculatively loaded style sheets.
|
|
*/
|
|
inline void InitSetDocumentMode(nsHtml5DocumentMode aMode)
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadSetDocumentMode;
|
|
mTypeOrCharsetSourceOrDocumentMode.Assign((char16_t)aMode);
|
|
}
|
|
|
|
inline void InitPreconnect(const nsAString& aUrl,
|
|
const nsAString& aCrossOrigin)
|
|
{
|
|
NS_PRECONDITION(mOpCode == eSpeculativeLoadUninitialized,
|
|
"Trying to reinitialize a speculative load!");
|
|
mOpCode = eSpeculativeLoadPreconnect;
|
|
mUrl.Assign(aUrl);
|
|
mCrossOrigin.Assign(aCrossOrigin);
|
|
}
|
|
|
|
void Perform(nsHtml5TreeOpExecutor* aExecutor);
|
|
|
|
private:
|
|
eHtml5SpeculativeLoad mOpCode;
|
|
nsString mUrl;
|
|
nsString mReferrerPolicy;
|
|
nsString mMetaCSP;
|
|
|
|
/**
|
|
* If mOpCode is eSpeculativeLoadStyle or eSpeculativeLoadScript[FromHead]
|
|
* then this is the value of the "charset" attribute. For
|
|
* eSpeculativeLoadSetDocumentCharset it is the charset that the
|
|
* document's charset is being set to. Otherwise it's empty.
|
|
*/
|
|
nsString mCharset;
|
|
/**
|
|
* If mOpCode is eSpeculativeLoadSetDocumentCharset, this is a
|
|
* one-character string whose single character's code point is to be
|
|
* interpreted as a charset source integer. If mOpCode is
|
|
* eSpeculativeLoadSetDocumentMode, this is a one-character string whose
|
|
* single character's code point is to be interpreted as an
|
|
* nsHtml5DocumentMode. Otherwise, it is empty or the value of the type
|
|
* attribute.
|
|
*/
|
|
nsString mTypeOrCharsetSourceOrDocumentMode;
|
|
/**
|
|
* If mOpCode is eSpeculativeLoadImage or eSpeculativeLoadScript[FromHead]
|
|
* or eSpeculativeLoadPreconnect this is the value of the "crossorigin"
|
|
* attribute. If the attribute is not set, this will be a void string.
|
|
*/
|
|
nsString mCrossOrigin;
|
|
/**
|
|
* If mOpCode is eSpeculativeLoadImage or eSpeculativeLoadPictureSource,
|
|
* this is the value of "srcset" attribute. If the attribute is not set,
|
|
* this will be a void string.
|
|
*/
|
|
nsString mSrcset;
|
|
/**
|
|
* If mOpCode is eSpeculativeLoadPictureSource, this is the value of "sizes"
|
|
* attribute. If the attribute is not set, this will be a void string.
|
|
*/
|
|
nsString mSizes;
|
|
/**
|
|
* If mOpCode is eSpeculativeLoadPictureSource, this is the value of "media"
|
|
* attribute. If the attribute is not set, this will be a void string.
|
|
*/
|
|
nsString mMedia;
|
|
/**
|
|
* If mOpCode is eSpeculativeLoadScript[FromHead], this is the value of the
|
|
* "integrity" attribute. If the attribute is not set, this will be a void
|
|
* string.
|
|
*/
|
|
nsString mIntegrity;
|
|
};
|
|
|
|
#endif // nsHtml5SpeculativeLoad_h
|