1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*
* Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
* Copyright (C) 2009-2017 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#pragma once
#include "ContainerNode.h"
#include "ContentSecurityPolicy.h"
#include "LoadableScript.h"
#include "ReferrerPolicy.h"
#include "RequestPriority.h"
#include "ScriptExecutionContextIdentifier.h"
#include "ScriptType.h"
#include "UserGestureIndicator.h"
#include <wtf/MonotonicTime.h>
#include <wtf/text/TextPosition.h>
namespace WebCore {
class CachedScript;
class ContainerNode;
class Element;
class LoadableModuleScript;
class PendingScript;
class ScriptSourceCode;
class ScriptElement {
public:
virtual ~ScriptElement() = default;
Element& element() { return m_element; }
const Element& element() const { return m_element; }
bool prepareScript(const TextPosition& scriptStartPosition = TextPosition());
String scriptCharset() const { return m_characterEncoding; }
WEBCORE_EXPORT String scriptContent() const;
void executeClassicScript(const ScriptSourceCode&);
void executeModuleScript(LoadableModuleScript&);
void registerImportMap(const ScriptSourceCode&);
void executePendingScript(PendingScript&);
virtual bool hasAsyncAttribute() const = 0;
virtual bool hasDeferAttribute() const = 0;
virtual bool hasSourceAttribute() const = 0;
virtual bool hasNoModuleAttribute() const = 0;
// XML parser calls these
virtual void dispatchLoadEvent() = 0;
virtual void dispatchErrorEvent();
bool haveFiredLoadEvent() const { return m_haveFiredLoad; }
bool errorOccurred() const { return m_errorOccurred; }
bool willBeParserExecuted() const { return m_willBeParserExecuted; }
bool readyToBeParserExecuted() const { return m_readyToBeParserExecuted; }
bool willExecuteWhenDocumentFinishedParsing() const { return m_willExecuteWhenDocumentFinishedParsing; }
bool willExecuteInOrder() const { return m_willExecuteInOrder; }
LoadableScript* loadableScript() { return m_loadableScript.get(); }
ScriptType scriptType() const { return m_scriptType; }
void ref();
void deref();
static std::optional<ScriptType> determineScriptType(const String& typeAttribute, const String& languageAttribute, bool isHTMLDocument = true);
protected:
ScriptElement(Element&, bool createdByParser, bool isEvaluated);
void setHaveFiredLoadEvent(bool haveFiredLoad) { m_haveFiredLoad = haveFiredLoad; }
void setErrorOccurred(bool errorOccurred) { m_errorOccurred = errorOccurred; }
ParserInserted isParserInserted() const { return m_parserInserted; }
bool alreadyStarted() const { return m_alreadyStarted; }
bool forceAsync() const { return m_forceAsync; }
// Helper functions used by our parent classes.
Node::InsertedIntoAncestorResult insertedIntoAncestor(Node::InsertionType insertionType, ContainerNode&) const
{
if (insertionType.connectedToDocument && m_parserInserted == ParserInserted::No)
return Node::InsertedIntoAncestorResult::NeedsPostInsertionCallback;
return Node::InsertedIntoAncestorResult::Done;
}
void didFinishInsertingNode();
void childrenChanged(const ContainerNode::ChildChange&);
void handleSourceAttribute(const String& sourceURL);
void handleAsyncAttribute();
private:
void executeScriptAndDispatchEvent(LoadableScript&);
std::optional<ScriptType> determineScriptType() const;
bool ignoresLoadRequest() const;
void dispatchLoadEventRespectingUserGestureIndicator();
bool requestClassicScript(const String& sourceURL);
bool requestModuleScript(const TextPosition& scriptStartPosition);
bool requestImportMap(LocalFrame&, const String& sourceURL);
virtual String sourceAttributeValue() const = 0;
virtual String charsetAttributeValue() const = 0;
virtual String typeAttributeValue() const = 0;
virtual String languageAttributeValue() const = 0;
virtual ReferrerPolicy referrerPolicy() const = 0;
virtual RequestPriority fetchPriorityHint() const { return RequestPriority::Auto; }
virtual bool isScriptPreventedByAttributes() const { return false; }
Element& m_element;
OrdinalNumber m_startLineNumber { OrdinalNumber::beforeFirst() };
ParserInserted m_parserInserted : bitWidthOfParserInserted;
bool m_isExternalScript : 1 { false };
bool m_alreadyStarted : 1;
bool m_haveFiredLoad : 1 { false };
bool m_errorOccurred : 1 { false };
bool m_willBeParserExecuted : 1 { false }; // Same as "The parser will handle executing the script."
bool m_readyToBeParserExecuted : 1 { false };
bool m_willExecuteWhenDocumentFinishedParsing : 1 { false };
bool m_forceAsync : 1;
bool m_willExecuteInOrder : 1 { false };
ScriptType m_scriptType : bitWidthOfScriptType { ScriptType::Classic };
String m_characterEncoding;
String m_fallbackCharacterEncoding;
RefPtr<LoadableScript> m_loadableScript;
// https://html.spec.whatwg.org/multipage/scripting.html#preparation-time-document
ScriptExecutionContextIdentifier m_preparationTimeDocumentIdentifier;
MonotonicTime m_creationTime;
RefPtr<UserGestureToken> m_userGestureToken;
};
// FIXME: replace with is/downcast<ScriptElement>.
bool isScriptElement(Element&);
ScriptElement& downcastScriptElement(Element&);
}
|
